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 && ! flag_writable_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) = ! flag_writable_strings;
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);
1880 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1882 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1884 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1886 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
1888 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1890 return unsignedp ? unsigned_V2HI_type_node : V2HI_type_node;
1892 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1894 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1896 return unsignedp ? unsigned_V1DI_type_node : V1DI_type_node;
1898 return V16SF_type_node;
1900 return V4SF_type_node;
1902 return V2SF_type_node;
1904 return V2DF_type_node;
1906 return V4DF_type_node;
1911 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1912 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1913 return TREE_VALUE (t);
1918 /* Return an unsigned type the same as TYPE in other respects. */
1920 c_common_unsigned_type (tree type)
1922 tree type1 = TYPE_MAIN_VARIANT (type);
1923 if (type1 == signed_char_type_node || type1 == char_type_node)
1924 return unsigned_char_type_node;
1925 if (type1 == integer_type_node)
1926 return unsigned_type_node;
1927 if (type1 == short_integer_type_node)
1928 return short_unsigned_type_node;
1929 if (type1 == long_integer_type_node)
1930 return long_unsigned_type_node;
1931 if (type1 == long_long_integer_type_node)
1932 return long_long_unsigned_type_node;
1933 if (type1 == widest_integer_literal_type_node)
1934 return widest_unsigned_literal_type_node;
1935 #if HOST_BITS_PER_WIDE_INT >= 64
1936 if (type1 == intTI_type_node)
1937 return unsigned_intTI_type_node;
1939 if (type1 == intDI_type_node)
1940 return unsigned_intDI_type_node;
1941 if (type1 == intSI_type_node)
1942 return unsigned_intSI_type_node;
1943 if (type1 == intHI_type_node)
1944 return unsigned_intHI_type_node;
1945 if (type1 == intQI_type_node)
1946 return unsigned_intQI_type_node;
1948 return c_common_signed_or_unsigned_type (1, type);
1951 /* Return a signed type the same as TYPE in other respects. */
1954 c_common_signed_type (tree type)
1956 tree type1 = TYPE_MAIN_VARIANT (type);
1957 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1958 return signed_char_type_node;
1959 if (type1 == unsigned_type_node)
1960 return integer_type_node;
1961 if (type1 == short_unsigned_type_node)
1962 return short_integer_type_node;
1963 if (type1 == long_unsigned_type_node)
1964 return long_integer_type_node;
1965 if (type1 == long_long_unsigned_type_node)
1966 return long_long_integer_type_node;
1967 if (type1 == widest_unsigned_literal_type_node)
1968 return widest_integer_literal_type_node;
1969 #if HOST_BITS_PER_WIDE_INT >= 64
1970 if (type1 == unsigned_intTI_type_node)
1971 return intTI_type_node;
1973 if (type1 == unsigned_intDI_type_node)
1974 return intDI_type_node;
1975 if (type1 == unsigned_intSI_type_node)
1976 return intSI_type_node;
1977 if (type1 == unsigned_intHI_type_node)
1978 return intHI_type_node;
1979 if (type1 == unsigned_intQI_type_node)
1980 return intQI_type_node;
1982 return c_common_signed_or_unsigned_type (0, type);
1985 /* Return a type the same as TYPE except unsigned or
1986 signed according to UNSIGNEDP. */
1989 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1991 if (! INTEGRAL_TYPE_P (type)
1992 || TREE_UNSIGNED (type) == unsignedp)
1995 /* Must check the mode of the types, not the precision. Enumeral types
1996 in C++ have precision set to match their range, but may use a wider
1997 mode to match an ABI. If we change modes, we may wind up with bad
2000 if (TYPE_MODE (type) == TYPE_MODE (signed_char_type_node))
2001 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2002 if (TYPE_MODE (type) == TYPE_MODE (integer_type_node))
2003 return unsignedp ? unsigned_type_node : integer_type_node;
2004 if (TYPE_MODE (type) == TYPE_MODE (short_integer_type_node))
2005 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2006 if (TYPE_MODE (type) == TYPE_MODE (long_integer_type_node))
2007 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2008 if (TYPE_MODE (type) == TYPE_MODE (long_long_integer_type_node))
2009 return (unsignedp ? long_long_unsigned_type_node
2010 : long_long_integer_type_node);
2011 if (TYPE_MODE (type) == TYPE_MODE (widest_integer_literal_type_node))
2012 return (unsignedp ? widest_unsigned_literal_type_node
2013 : widest_integer_literal_type_node);
2015 #if HOST_BITS_PER_WIDE_INT >= 64
2016 if (TYPE_MODE (type) == TYPE_MODE (intTI_type_node))
2017 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2019 if (TYPE_MODE (type) == TYPE_MODE (intDI_type_node))
2020 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2021 if (TYPE_MODE (type) == TYPE_MODE (intSI_type_node))
2022 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2023 if (TYPE_MODE (type) == TYPE_MODE (intHI_type_node))
2024 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2025 if (TYPE_MODE (type) == TYPE_MODE (intQI_type_node))
2026 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2031 /* The C version of the register_builtin_type langhook. */
2034 c_register_builtin_type (tree type, const char* name)
2038 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2039 DECL_ARTIFICIAL (decl) = 1;
2040 if (!TYPE_NAME (type))
2041 TYPE_NAME (type) = decl;
2044 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2048 /* Return the minimum number of bits needed to represent VALUE in a
2049 signed or unsigned type, UNSIGNEDP says which. */
2052 min_precision (tree value, int unsignedp)
2056 /* If the value is negative, compute its negative minus 1. The latter
2057 adjustment is because the absolute value of the largest negative value
2058 is one larger than the largest positive value. This is equivalent to
2059 a bit-wise negation, so use that operation instead. */
2061 if (tree_int_cst_sgn (value) < 0)
2062 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2064 /* Return the number of bits needed, taking into account the fact
2065 that we need one more bit for a signed than unsigned type. */
2067 if (integer_zerop (value))
2070 log = tree_floor_log2 (value);
2072 return log + 1 + ! unsignedp;
2075 /* Print an error message for invalid operands to arith operation
2076 CODE. NOP_EXPR is used as a special case (see
2077 c_common_truthvalue_conversion). */
2080 binary_op_error (enum tree_code code)
2087 error ("invalid truth-value expression");
2091 opname = "+"; break;
2093 opname = "-"; break;
2095 opname = "*"; break;
2097 opname = "max"; break;
2099 opname = "min"; break;
2101 opname = "=="; break;
2103 opname = "!="; break;
2105 opname = "<="; break;
2107 opname = ">="; break;
2109 opname = "<"; break;
2111 opname = ">"; break;
2113 opname = "<<"; break;
2115 opname = ">>"; break;
2116 case TRUNC_MOD_EXPR:
2117 case FLOOR_MOD_EXPR:
2118 opname = "%"; break;
2119 case TRUNC_DIV_EXPR:
2120 case FLOOR_DIV_EXPR:
2121 opname = "/"; break;
2123 opname = "&"; break;
2125 opname = "|"; break;
2126 case TRUTH_ANDIF_EXPR:
2127 opname = "&&"; break;
2128 case TRUTH_ORIF_EXPR:
2129 opname = "||"; break;
2131 opname = "^"; break;
2134 opname = "rotate"; break;
2136 opname = "unknown"; break;
2138 error ("invalid operands to binary %s", opname);
2141 /* Subroutine of build_binary_op, used for comparison operations.
2142 See if the operands have both been converted from subword integer types
2143 and, if so, perhaps change them both back to their original type.
2144 This function is also responsible for converting the two operands
2145 to the proper common type for comparison.
2147 The arguments of this function are all pointers to local variables
2148 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2149 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2151 If this function returns nonzero, it means that the comparison has
2152 a constant value. What this function returns is an expression for
2156 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2157 enum tree_code *rescode_ptr)
2160 tree op0 = *op0_ptr;
2161 tree op1 = *op1_ptr;
2162 int unsignedp0, unsignedp1;
2164 tree primop0, primop1;
2165 enum tree_code code = *rescode_ptr;
2167 /* Throw away any conversions to wider types
2168 already present in the operands. */
2170 primop0 = get_narrower (op0, &unsignedp0);
2171 primop1 = get_narrower (op1, &unsignedp1);
2173 /* Handle the case that OP0 does not *contain* a conversion
2174 but it *requires* conversion to FINAL_TYPE. */
2176 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2177 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2178 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2179 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2181 /* If one of the operands must be floated, we cannot optimize. */
2182 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2183 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2185 /* If first arg is constant, swap the args (changing operation
2186 so value is preserved), for canonicalization. Don't do this if
2187 the second arg is 0. */
2189 if (TREE_CONSTANT (primop0)
2190 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2193 int temi = unsignedp0;
2201 unsignedp0 = unsignedp1;
2224 *rescode_ptr = code;
2227 /* If comparing an integer against a constant more bits wide,
2228 maybe we can deduce a value of 1 or 0 independent of the data.
2229 Or else truncate the constant now
2230 rather than extend the variable at run time.
2232 This is only interesting if the constant is the wider arg.
2233 Also, it is not safe if the constant is unsigned and the
2234 variable arg is signed, since in this case the variable
2235 would be sign-extended and then regarded as unsigned.
2236 Our technique fails in this case because the lowest/highest
2237 possible unsigned results don't follow naturally from the
2238 lowest/highest possible values of the variable operand.
2239 For just EQ_EXPR and NE_EXPR there is another technique that
2240 could be used: see if the constant can be faithfully represented
2241 in the other operand's type, by truncating it and reextending it
2242 and see if that preserves the constant's value. */
2244 if (!real1 && !real2
2245 && TREE_CODE (primop1) == INTEGER_CST
2246 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2248 int min_gt, max_gt, min_lt, max_lt;
2249 tree maxval, minval;
2250 /* 1 if comparison is nominally unsigned. */
2251 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2254 type = c_common_signed_or_unsigned_type (unsignedp0,
2255 TREE_TYPE (primop0));
2257 /* In C, if TYPE is an enumeration, then we need to get its
2258 min/max values from it's underlying integral type, not the
2259 enumerated type itself. In C++, TYPE_MAX_VALUE and
2260 TYPE_MIN_VALUE have already been set correctly on the
2261 enumeration type. */
2262 if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
2263 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2265 maxval = TYPE_MAX_VALUE (type);
2266 minval = TYPE_MIN_VALUE (type);
2268 if (unsignedp && !unsignedp0)
2269 *restype_ptr = c_common_signed_type (*restype_ptr);
2271 if (TREE_TYPE (primop1) != *restype_ptr)
2272 primop1 = convert (*restype_ptr, primop1);
2273 if (type != *restype_ptr)
2275 minval = convert (*restype_ptr, minval);
2276 maxval = convert (*restype_ptr, maxval);
2279 if (unsignedp && unsignedp0)
2281 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2282 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2283 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2284 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2288 min_gt = INT_CST_LT (primop1, minval);
2289 max_gt = INT_CST_LT (primop1, maxval);
2290 min_lt = INT_CST_LT (minval, primop1);
2291 max_lt = INT_CST_LT (maxval, primop1);
2295 /* This used to be a switch, but Genix compiler can't handle that. */
2296 if (code == NE_EXPR)
2298 if (max_lt || min_gt)
2299 val = truthvalue_true_node;
2301 else if (code == EQ_EXPR)
2303 if (max_lt || min_gt)
2304 val = truthvalue_false_node;
2306 else if (code == LT_EXPR)
2309 val = truthvalue_true_node;
2311 val = truthvalue_false_node;
2313 else if (code == GT_EXPR)
2316 val = truthvalue_true_node;
2318 val = truthvalue_false_node;
2320 else if (code == LE_EXPR)
2323 val = truthvalue_true_node;
2325 val = truthvalue_false_node;
2327 else if (code == GE_EXPR)
2330 val = truthvalue_true_node;
2332 val = truthvalue_false_node;
2335 /* If primop0 was sign-extended and unsigned comparison specd,
2336 we did a signed comparison above using the signed type bounds.
2337 But the comparison we output must be unsigned.
2339 Also, for inequalities, VAL is no good; but if the signed
2340 comparison had *any* fixed result, it follows that the
2341 unsigned comparison just tests the sign in reverse
2342 (positive values are LE, negative ones GE).
2343 So we can generate an unsigned comparison
2344 against an extreme value of the signed type. */
2346 if (unsignedp && !unsignedp0)
2353 primop1 = TYPE_MIN_VALUE (type);
2359 primop1 = TYPE_MAX_VALUE (type);
2366 type = c_common_unsigned_type (type);
2369 if (TREE_CODE (primop0) != INTEGER_CST)
2371 if (val == truthvalue_false_node)
2372 warning ("comparison is always false due to limited range of data type");
2373 if (val == truthvalue_true_node)
2374 warning ("comparison is always true due to limited range of data type");
2379 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2380 if (TREE_SIDE_EFFECTS (primop0))
2381 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2385 /* Value is not predetermined, but do the comparison
2386 in the type of the operand that is not constant.
2387 TYPE is already properly set. */
2389 else if (real1 && real2
2390 && (TYPE_PRECISION (TREE_TYPE (primop0))
2391 == TYPE_PRECISION (TREE_TYPE (primop1))))
2392 type = TREE_TYPE (primop0);
2394 /* If args' natural types are both narrower than nominal type
2395 and both extend in the same manner, compare them
2396 in the type of the wider arg.
2397 Otherwise must actually extend both to the nominal
2398 common type lest different ways of extending
2400 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2402 else if (unsignedp0 == unsignedp1 && real1 == real2
2403 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2404 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2406 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2407 type = c_common_signed_or_unsigned_type (unsignedp0
2408 || TREE_UNSIGNED (*restype_ptr),
2410 /* Make sure shorter operand is extended the right way
2411 to match the longer operand. */
2413 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2414 TREE_TYPE (primop0)),
2417 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2418 TREE_TYPE (primop1)),
2423 /* Here we must do the comparison on the nominal type
2424 using the args exactly as we received them. */
2425 type = *restype_ptr;
2429 if (!real1 && !real2 && integer_zerop (primop1)
2430 && TREE_UNSIGNED (*restype_ptr))
2436 /* All unsigned values are >= 0, so we warn if extra warnings
2437 are requested. However, if OP0 is a constant that is
2438 >= 0, the signedness of the comparison isn't an issue,
2439 so suppress the warning. */
2440 if (extra_warnings && !in_system_header
2441 && ! (TREE_CODE (primop0) == INTEGER_CST
2442 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2444 warning ("comparison of unsigned expression >= 0 is always true");
2445 value = truthvalue_true_node;
2449 if (extra_warnings && !in_system_header
2450 && ! (TREE_CODE (primop0) == INTEGER_CST
2451 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2453 warning ("comparison of unsigned expression < 0 is always false");
2454 value = truthvalue_false_node;
2463 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2464 if (TREE_SIDE_EFFECTS (primop0))
2465 return build (COMPOUND_EXPR, TREE_TYPE (value),
2472 *op0_ptr = convert (type, primop0);
2473 *op1_ptr = convert (type, primop1);
2475 *restype_ptr = truthvalue_type_node;
2480 /* Return a tree for the sum or difference (RESULTCODE says which)
2481 of pointer PTROP and integer INTOP. */
2484 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2491 /* The result is a pointer of the same type that is being added. */
2493 tree result_type = TREE_TYPE (ptrop);
2495 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2497 if (pedantic || warn_pointer_arith)
2498 pedwarn ("pointer of type `void *' used in arithmetic");
2499 size_exp = integer_one_node;
2501 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2503 if (pedantic || warn_pointer_arith)
2504 pedwarn ("pointer to a function used in arithmetic");
2505 size_exp = integer_one_node;
2507 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2509 if (pedantic || warn_pointer_arith)
2510 pedwarn ("pointer to member function used in arithmetic");
2511 size_exp = integer_one_node;
2514 size_exp = size_in_bytes (TREE_TYPE (result_type));
2516 /* If what we are about to multiply by the size of the elements
2517 contains a constant term, apply distributive law
2518 and multiply that constant term separately.
2519 This helps produce common subexpressions. */
2521 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2522 && ! TREE_CONSTANT (intop)
2523 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2524 && TREE_CONSTANT (size_exp)
2525 /* If the constant comes from pointer subtraction,
2526 skip this optimization--it would cause an error. */
2527 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2528 /* If the constant is unsigned, and smaller than the pointer size,
2529 then we must skip this optimization. This is because it could cause
2530 an overflow error if the constant is negative but INTOP is not. */
2531 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2532 || (TYPE_PRECISION (TREE_TYPE (intop))
2533 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2535 enum tree_code subcode = resultcode;
2536 tree int_type = TREE_TYPE (intop);
2537 if (TREE_CODE (intop) == MINUS_EXPR)
2538 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2539 /* Convert both subexpression types to the type of intop,
2540 because weird cases involving pointer arithmetic
2541 can result in a sum or difference with different type args. */
2542 ptrop = build_binary_op (subcode, ptrop,
2543 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2544 intop = convert (int_type, TREE_OPERAND (intop, 0));
2547 /* Convert the integer argument to a type the same size as sizetype
2548 so the multiply won't overflow spuriously. */
2550 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2551 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2552 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2553 TREE_UNSIGNED (sizetype)), intop);
2555 /* Replace the integer argument with a suitable product by the object size.
2556 Do this multiplication as signed, then convert to the appropriate
2557 pointer type (actually unsigned integral). */
2559 intop = convert (result_type,
2560 build_binary_op (MULT_EXPR, intop,
2561 convert (TREE_TYPE (intop), size_exp), 1));
2563 /* Create the sum or difference. */
2565 result = build (resultcode, result_type, ptrop, intop);
2567 folded = fold (result);
2568 if (folded == result)
2569 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2573 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2574 or validate its data type for an `if' or `while' statement or ?..: exp.
2576 This preparation consists of taking the ordinary
2577 representation of an expression expr and producing a valid tree
2578 boolean expression describing whether expr is nonzero. We could
2579 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2580 but we optimize comparisons, &&, ||, and !.
2582 The resulting type should always be `truthvalue_type_node'. */
2585 c_common_truthvalue_conversion (tree expr)
2587 if (TREE_CODE (expr) == ERROR_MARK)
2590 if (TREE_CODE (expr) == FUNCTION_DECL)
2591 expr = build_unary_op (ADDR_EXPR, expr, 0);
2593 #if 0 /* This appears to be wrong for C++. */
2594 /* These really should return error_mark_node after 2.4 is stable.
2595 But not all callers handle ERROR_MARK properly. */
2596 switch (TREE_CODE (TREE_TYPE (expr)))
2599 error ("struct type value used where scalar is required");
2600 return truthvalue_false_node;
2603 error ("union type value used where scalar is required");
2604 return truthvalue_false_node;
2607 error ("array type value used where scalar is required");
2608 return truthvalue_false_node;
2615 switch (TREE_CODE (expr))
2618 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2619 case TRUTH_ANDIF_EXPR:
2620 case TRUTH_ORIF_EXPR:
2621 case TRUTH_AND_EXPR:
2623 case TRUTH_XOR_EXPR:
2624 case TRUTH_NOT_EXPR:
2625 TREE_TYPE (expr) = truthvalue_type_node;
2632 return integer_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2635 return real_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2639 if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2640 && ! DECL_WEAK (TREE_OPERAND (expr, 0)))
2642 /* Common Ada/Pascal programmer's mistake. We always warn
2643 about this since it is so bad. */
2644 warning ("the address of `%D', will always evaluate as `true'",
2645 TREE_OPERAND (expr, 0));
2646 return truthvalue_true_node;
2649 /* If we are taking the address of an external decl, it might be
2650 zero if it is weak, so we cannot optimize. */
2651 if (DECL_P (TREE_OPERAND (expr, 0))
2652 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2655 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2656 return build (COMPOUND_EXPR, truthvalue_type_node,
2657 TREE_OPERAND (expr, 0), truthvalue_true_node);
2659 return truthvalue_true_node;
2663 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2664 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2665 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2666 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2672 /* These don't change whether an object is nonzero or zero. */
2673 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2677 /* These don't change whether an object is zero or nonzero, but
2678 we can't ignore them if their second arg has side-effects. */
2679 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2680 return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1),
2681 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2683 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2686 /* Distribute the conversion into the arms of a COND_EXPR. */
2687 return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0),
2688 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2689 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2692 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2693 since that affects how `default_conversion' will behave. */
2694 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2695 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2697 /* Fall through.... */
2699 /* If this is widening the argument, we can ignore it. */
2700 if (TYPE_PRECISION (TREE_TYPE (expr))
2701 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2702 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2706 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2707 aren't guaranteed to the be same for modes that can represent
2708 infinity, since if x and y are both +infinity, or both
2709 -infinity, then x - y is not a number.
2711 Note that this transformation is safe when x or y is NaN.
2712 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2714 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2716 /* Fall through.... */
2718 /* This and MINUS_EXPR can be changed into a comparison of the
2720 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2721 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2722 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2723 TREE_OPERAND (expr, 1), 1);
2724 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2725 fold (build1 (NOP_EXPR,
2726 TREE_TYPE (TREE_OPERAND (expr, 0)),
2727 TREE_OPERAND (expr, 1))), 1);
2730 if (integer_onep (TREE_OPERAND (expr, 1))
2731 && TREE_TYPE (expr) != truthvalue_type_node)
2732 /* Using convert here would cause infinite recursion. */
2733 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2737 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2738 warning ("suggest parentheses around assignment used as truth value");
2745 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2747 tree t = save_expr (expr);
2748 return (build_binary_op
2749 ((TREE_SIDE_EFFECTS (expr)
2750 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2751 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2752 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2756 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2759 static tree builtin_function_2 (const char *, const char *, tree, tree,
2760 int, enum built_in_class, int, int,
2763 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2764 down to the element type of an array. */
2767 c_build_qualified_type (tree type, int type_quals)
2769 if (type == error_mark_node)
2772 if (TREE_CODE (type) == ARRAY_TYPE)
2773 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2775 TYPE_DOMAIN (type));
2777 /* A restrict-qualified pointer type must be a pointer to object or
2778 incomplete type. Note that the use of POINTER_TYPE_P also allows
2779 REFERENCE_TYPEs, which is appropriate for C++. */
2780 if ((type_quals & TYPE_QUAL_RESTRICT)
2781 && (!POINTER_TYPE_P (type)
2782 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2784 error ("invalid use of `restrict'");
2785 type_quals &= ~TYPE_QUAL_RESTRICT;
2788 return build_qualified_type (type, type_quals);
2791 /* Apply the TYPE_QUALS to the new DECL. */
2794 c_apply_type_quals_to_decl (int type_quals, tree decl)
2796 tree type = TREE_TYPE (decl);
2798 if (type == error_mark_node)
2801 if (((type_quals & TYPE_QUAL_CONST)
2802 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2803 /* An object declared 'const' is only readonly after it is
2804 initialized. We don't have any way of expressing this currently,
2805 so we need to be conservative and unset TREE_READONLY for types
2806 with constructors. Otherwise aliasing code will ignore stores in
2807 an inline constructor. */
2808 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2809 TREE_READONLY (decl) = 1;
2810 if (type_quals & TYPE_QUAL_VOLATILE)
2812 TREE_SIDE_EFFECTS (decl) = 1;
2813 TREE_THIS_VOLATILE (decl) = 1;
2815 if (type_quals & TYPE_QUAL_RESTRICT)
2817 while (type && TREE_CODE (type) == ARRAY_TYPE)
2818 /* Allow 'restrict' on arrays of pointers.
2819 FIXME currently we just ignore it. */
2820 type = TREE_TYPE (type);
2822 || !POINTER_TYPE_P (type)
2823 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2824 error ("invalid use of `restrict'");
2825 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2826 /* Indicate we need to make a unique alias set for this pointer.
2827 We can't do it here because it might be pointing to an
2829 DECL_POINTER_ALIAS_SET (decl) = -2;
2833 /* Return the typed-based alias set for T, which may be an expression
2834 or a type. Return -1 if we don't do anything special. */
2837 c_common_get_alias_set (tree t)
2841 /* Permit type-punning when accessing a union, provided the access
2842 is directly through the union. For example, this code does not
2843 permit taking the address of a union member and then storing
2844 through it. Even the type-punning allowed here is a GCC
2845 extension, albeit a common and useful one; the C standard says
2846 that such accesses have implementation-defined behavior. */
2848 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2849 u = TREE_OPERAND (u, 0))
2850 if (TREE_CODE (u) == COMPONENT_REF
2851 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2854 /* That's all the expressions we handle specially. */
2858 /* The C standard guarantees that any object may be accessed via an
2859 lvalue that has character type. */
2860 if (t == char_type_node
2861 || t == signed_char_type_node
2862 || t == unsigned_char_type_node)
2865 /* If it has the may_alias attribute, it can alias anything. */
2866 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2869 /* The C standard specifically allows aliasing between signed and
2870 unsigned variants of the same type. We treat the signed
2871 variant as canonical. */
2872 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2874 tree t1 = c_common_signed_type (t);
2876 /* t1 == t can happen for boolean nodes which are always unsigned. */
2878 return get_alias_set (t1);
2880 else if (POINTER_TYPE_P (t))
2884 /* Unfortunately, there is no canonical form of a pointer type.
2885 In particular, if we have `typedef int I', then `int *', and
2886 `I *' are different types. So, we have to pick a canonical
2887 representative. We do this below.
2889 Technically, this approach is actually more conservative that
2890 it needs to be. In particular, `const int *' and `int *'
2891 should be in different alias sets, according to the C and C++
2892 standard, since their types are not the same, and so,
2893 technically, an `int **' and `const int **' cannot point at
2896 But, the standard is wrong. In particular, this code is
2901 const int* const* cipp = &ipp;
2903 And, it doesn't make sense for that to be legal unless you
2904 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2905 the pointed-to types. This issue has been reported to the
2907 t1 = build_type_no_quals (t);
2909 return get_alias_set (t1);
2915 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2916 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2917 flag controls whether we should diagnose possibly ill-formed
2918 constructs or not. */
2920 c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2922 const char *op_name;
2924 enum tree_code type_code = TREE_CODE (type);
2926 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
2927 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2929 if (type_code == FUNCTION_TYPE)
2931 if (op == SIZEOF_EXPR)
2933 if (complain && (pedantic || warn_pointer_arith))
2934 pedwarn ("invalid application of `sizeof' to a function type");
2935 value = size_one_node;
2938 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2940 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2942 if (type_code == VOID_TYPE
2943 && complain && (pedantic || warn_pointer_arith))
2944 pedwarn ("invalid application of `%s' to a void type", op_name);
2945 value = size_one_node;
2947 else if (!COMPLETE_TYPE_P (type))
2950 error ("invalid application of `%s' to incomplete type `%T' ",
2952 value = size_zero_node;
2956 if (op == SIZEOF_EXPR)
2957 /* Convert in case a char is more than one unit. */
2958 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2959 size_int (TYPE_PRECISION (char_type_node)
2962 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2965 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2966 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2967 never happen. However, this node should really have type
2968 `size_t', which is just a typedef for an ordinary integer type. */
2969 value = fold (build1 (NOP_EXPR, size_type_node, value));
2970 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
2975 /* Implement the __alignof keyword: Return the minimum required
2976 alignment of EXPR, measured in bytes. For VAR_DECL's and
2977 FIELD_DECL's return DECL_ALIGN (which can be set from an
2978 "aligned" __attribute__ specification). */
2981 c_alignof_expr (tree expr)
2985 if (TREE_CODE (expr) == VAR_DECL)
2986 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2988 else if (TREE_CODE (expr) == COMPONENT_REF
2989 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2991 error ("`__alignof' applied to a bit-field");
2994 else if (TREE_CODE (expr) == COMPONENT_REF
2995 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2996 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2998 else if (TREE_CODE (expr) == INDIRECT_REF)
3000 tree t = TREE_OPERAND (expr, 0);
3002 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3004 while (TREE_CODE (t) == NOP_EXPR
3005 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3009 t = TREE_OPERAND (t, 0);
3010 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3011 if (thisalign > bestalign)
3012 best = t, bestalign = thisalign;
3014 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3017 return c_alignof (TREE_TYPE (expr));
3019 return fold (build1 (NOP_EXPR, size_type_node, t));
3022 /* Handle C and C++ default attributes. */
3024 enum built_in_attribute
3026 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3027 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3028 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3029 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3030 #include "builtin-attrs.def"
3031 #undef DEF_ATTR_NULL_TREE
3033 #undef DEF_ATTR_IDENT
3034 #undef DEF_ATTR_TREE_LIST
3038 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3040 static void c_init_attributes (void);
3042 /* Build tree nodes and builtin functions common to both C and C++ language
3046 c_common_nodes_and_builtins (void)
3050 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3051 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3052 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3053 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3054 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3055 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3056 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3057 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3058 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3059 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3060 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3061 #include "builtin-types.def"
3062 #undef DEF_PRIMITIVE_TYPE
3063 #undef DEF_FUNCTION_TYPE_0
3064 #undef DEF_FUNCTION_TYPE_1
3065 #undef DEF_FUNCTION_TYPE_2
3066 #undef DEF_FUNCTION_TYPE_3
3067 #undef DEF_FUNCTION_TYPE_4
3068 #undef DEF_FUNCTION_TYPE_VAR_0
3069 #undef DEF_FUNCTION_TYPE_VAR_1
3070 #undef DEF_FUNCTION_TYPE_VAR_2
3071 #undef DEF_FUNCTION_TYPE_VAR_3
3072 #undef DEF_POINTER_TYPE
3076 typedef enum builtin_type builtin_type;
3078 tree builtin_types[(int) BT_LAST];
3079 int wchar_type_size;
3080 tree array_domain_type;
3081 tree va_list_ref_type_node;
3082 tree va_list_arg_type_node;
3084 /* Define `int' and `char' first so that dbx will output them first. */
3085 record_builtin_type (RID_INT, NULL, integer_type_node);
3086 record_builtin_type (RID_CHAR, "char", char_type_node);
3088 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3089 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3090 but not C. Are the conditionals here needed? */
3091 if (c_dialect_cxx ())
3092 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3093 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3094 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3095 record_builtin_type (RID_MAX, "long unsigned int",
3096 long_unsigned_type_node);
3097 if (c_dialect_cxx ())
3098 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3099 record_builtin_type (RID_MAX, "long long int",
3100 long_long_integer_type_node);
3101 record_builtin_type (RID_MAX, "long long unsigned int",
3102 long_long_unsigned_type_node);
3103 if (c_dialect_cxx ())
3104 record_builtin_type (RID_MAX, "long long unsigned",
3105 long_long_unsigned_type_node);
3106 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3107 record_builtin_type (RID_MAX, "short unsigned int",
3108 short_unsigned_type_node);
3109 if (c_dialect_cxx ())
3110 record_builtin_type (RID_MAX, "unsigned short",
3111 short_unsigned_type_node);
3113 /* Define both `signed char' and `unsigned char'. */
3114 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3115 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3117 /* These are types that c_common_type_for_size and
3118 c_common_type_for_mode use. */
3119 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3121 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3123 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3125 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3127 #if HOST_BITS_PER_WIDE_INT >= 64
3128 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3129 get_identifier ("__int128_t"),
3132 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3133 unsigned_intQI_type_node));
3134 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3135 unsigned_intHI_type_node));
3136 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3137 unsigned_intSI_type_node));
3138 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3139 unsigned_intDI_type_node));
3140 #if HOST_BITS_PER_WIDE_INT >= 64
3141 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3142 get_identifier ("__uint128_t"),
3143 unsigned_intTI_type_node));
3146 /* Create the widest literal types. */
3147 widest_integer_literal_type_node
3148 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3149 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3150 widest_integer_literal_type_node));
3152 widest_unsigned_literal_type_node
3153 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3154 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3155 widest_unsigned_literal_type_node));
3157 /* `unsigned long' is the standard type for sizeof.
3158 Note that stddef.h uses `unsigned long',
3159 and this must agree, even if long and int are the same size. */
3161 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3162 signed_size_type_node = c_common_signed_type (size_type_node);
3163 set_sizetype (size_type_node);
3165 build_common_tree_nodes_2 (flag_short_double);
3167 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3168 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3169 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3171 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3172 get_identifier ("complex int"),
3173 complex_integer_type_node));
3174 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3175 get_identifier ("complex float"),
3176 complex_float_type_node));
3177 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3178 get_identifier ("complex double"),
3179 complex_double_type_node));
3180 (*lang_hooks.decls.pushdecl)
3181 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3182 complex_long_double_type_node));
3184 /* Types which are common to the fortran compiler and libf2c. When
3185 changing these, you also need to be concerned with f/com.h. */
3187 if (TYPE_PRECISION (float_type_node)
3188 == TYPE_PRECISION (long_integer_type_node))
3190 g77_integer_type_node = long_integer_type_node;
3191 g77_uinteger_type_node = long_unsigned_type_node;
3193 else if (TYPE_PRECISION (float_type_node)
3194 == TYPE_PRECISION (integer_type_node))
3196 g77_integer_type_node = integer_type_node;
3197 g77_uinteger_type_node = unsigned_type_node;
3200 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3202 if (g77_integer_type_node != NULL_TREE)
3204 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3205 get_identifier ("__g77_integer"),
3206 g77_integer_type_node));
3207 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3208 get_identifier ("__g77_uinteger"),
3209 g77_uinteger_type_node));
3212 if (TYPE_PRECISION (float_type_node) * 2
3213 == TYPE_PRECISION (long_integer_type_node))
3215 g77_longint_type_node = long_integer_type_node;
3216 g77_ulongint_type_node = long_unsigned_type_node;
3218 else if (TYPE_PRECISION (float_type_node) * 2
3219 == TYPE_PRECISION (long_long_integer_type_node))
3221 g77_longint_type_node = long_long_integer_type_node;
3222 g77_ulongint_type_node = long_long_unsigned_type_node;
3225 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3227 if (g77_longint_type_node != NULL_TREE)
3229 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3230 get_identifier ("__g77_longint"),
3231 g77_longint_type_node));
3232 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3233 get_identifier ("__g77_ulongint"),
3234 g77_ulongint_type_node));
3237 record_builtin_type (RID_VOID, NULL, void_type_node);
3239 void_zero_node = build_int_2 (0, 0);
3240 TREE_TYPE (void_zero_node) = void_type_node;
3242 void_list_node = build_void_list_node ();
3244 /* Make a type to be the domain of a few array types
3245 whose domains don't really matter.
3246 200 is small enough that it always fits in size_t
3247 and large enough that it can hold most function names for the
3248 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3249 array_domain_type = build_index_type (size_int (200));
3251 /* Make a type for arrays of characters.
3252 With luck nothing will ever really depend on the length of this
3254 char_array_type_node
3255 = build_array_type (char_type_node, array_domain_type);
3257 /* Likewise for arrays of ints. */
3259 = build_array_type (integer_type_node, array_domain_type);
3261 string_type_node = build_pointer_type (char_type_node);
3262 const_string_type_node
3263 = build_pointer_type (build_qualified_type
3264 (char_type_node, TYPE_QUAL_CONST));
3266 /* This is special for C++ so functions can be overloaded. */
3267 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3268 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3269 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3270 if (c_dialect_cxx ())
3272 if (TREE_UNSIGNED (wchar_type_node))
3273 wchar_type_node = make_unsigned_type (wchar_type_size);
3275 wchar_type_node = make_signed_type (wchar_type_size);
3276 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3280 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3281 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3284 /* This is for wide string constants. */
3285 wchar_array_type_node
3286 = build_array_type (wchar_type_node, array_domain_type);
3289 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3292 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3294 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3296 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3298 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3299 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3301 (*lang_hooks.decls.pushdecl)
3302 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3303 va_list_type_node));
3305 (*lang_hooks.decls.pushdecl)
3306 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3307 ptrdiff_type_node));
3309 (*lang_hooks.decls.pushdecl)
3310 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3313 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3315 va_list_arg_type_node = va_list_ref_type_node =
3316 build_pointer_type (TREE_TYPE (va_list_type_node));
3320 va_list_arg_type_node = va_list_type_node;
3321 va_list_ref_type_node = build_reference_type (va_list_type_node);
3324 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3325 builtin_types[(int) ENUM] = VALUE;
3326 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3327 builtin_types[(int) ENUM] \
3328 = build_function_type (builtin_types[(int) RETURN], \
3330 #define DEF_FUNCTION_TYPE_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], \
3336 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3337 builtin_types[(int) ENUM] \
3338 = build_function_type \
3339 (builtin_types[(int) RETURN], \
3340 tree_cons (NULL_TREE, \
3341 builtin_types[(int) ARG1], \
3342 tree_cons (NULL_TREE, \
3343 builtin_types[(int) ARG2], \
3345 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3346 builtin_types[(int) ENUM] \
3347 = build_function_type \
3348 (builtin_types[(int) RETURN], \
3349 tree_cons (NULL_TREE, \
3350 builtin_types[(int) ARG1], \
3351 tree_cons (NULL_TREE, \
3352 builtin_types[(int) ARG2], \
3353 tree_cons (NULL_TREE, \
3354 builtin_types[(int) ARG3], \
3356 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3357 builtin_types[(int) ENUM] \
3358 = build_function_type \
3359 (builtin_types[(int) RETURN], \
3360 tree_cons (NULL_TREE, \
3361 builtin_types[(int) ARG1], \
3362 tree_cons (NULL_TREE, \
3363 builtin_types[(int) ARG2], \
3366 builtin_types[(int) ARG3], \
3367 tree_cons (NULL_TREE, \
3368 builtin_types[(int) ARG4], \
3369 void_list_node)))));
3370 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3371 builtin_types[(int) ENUM] \
3372 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3373 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3374 builtin_types[(int) ENUM] \
3375 = build_function_type (builtin_types[(int) RETURN], \
3376 tree_cons (NULL_TREE, \
3377 builtin_types[(int) ARG1], \
3380 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3381 builtin_types[(int) ENUM] \
3382 = build_function_type \
3383 (builtin_types[(int) RETURN], \
3384 tree_cons (NULL_TREE, \
3385 builtin_types[(int) ARG1], \
3386 tree_cons (NULL_TREE, \
3387 builtin_types[(int) ARG2], \
3390 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3391 builtin_types[(int) ENUM] \
3392 = build_function_type \
3393 (builtin_types[(int) RETURN], \
3394 tree_cons (NULL_TREE, \
3395 builtin_types[(int) ARG1], \
3396 tree_cons (NULL_TREE, \
3397 builtin_types[(int) ARG2], \
3398 tree_cons (NULL_TREE, \
3399 builtin_types[(int) ARG3], \
3402 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3403 builtin_types[(int) ENUM] \
3404 = build_pointer_type (builtin_types[(int) TYPE]);
3405 #include "builtin-types.def"
3406 #undef DEF_PRIMITIVE_TYPE
3407 #undef DEF_FUNCTION_TYPE_1
3408 #undef DEF_FUNCTION_TYPE_2
3409 #undef DEF_FUNCTION_TYPE_3
3410 #undef DEF_FUNCTION_TYPE_4
3411 #undef DEF_FUNCTION_TYPE_VAR_0
3412 #undef DEF_FUNCTION_TYPE_VAR_1
3413 #undef DEF_FUNCTION_TYPE_VAR_2
3414 #undef DEF_FUNCTION_TYPE_VAR_3
3415 #undef DEF_POINTER_TYPE
3417 c_init_attributes ();
3419 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3420 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3425 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3429 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3432 ? (NAME + strlen ("__builtin_")) \
3434 built_in_attributes[(int) ATTRS]); \
3436 decl = builtin_function_2 (NAME, \
3437 NAME + strlen ("__builtin_"), \
3438 builtin_types[TYPE], \
3439 builtin_types[LIBTYPE], \
3444 built_in_attributes[(int) ATTRS]); \
3446 built_in_decls[(int) ENUM] = decl; \
3448 implicit_built_in_decls[(int) ENUM] = decl; \
3450 #include "builtins.def"
3453 (*targetm.init_builtins) ();
3455 main_identifier_node = get_identifier ("main");
3459 build_va_arg (tree expr, tree type)
3461 return build1 (VA_ARG_EXPR, type, expr);
3465 /* Linked list of disabled built-in functions. */
3467 typedef struct disabled_builtin
3470 struct disabled_builtin *next;
3472 static disabled_builtin *disabled_builtins = NULL;
3474 static bool builtin_function_disabled_p (const char *);
3476 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3477 begins with "__builtin_", give an error. */
3480 disable_builtin_function (const char *name)
3482 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3483 error ("cannot disable built-in function `%s'", name);
3486 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3488 new->next = disabled_builtins;
3489 disabled_builtins = new;
3494 /* Return true if the built-in function NAME has been disabled, false
3498 builtin_function_disabled_p (const char *name)
3500 disabled_builtin *p;
3501 for (p = disabled_builtins; p != NULL; p = p->next)
3503 if (strcmp (name, p->name) == 0)
3510 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3511 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3512 of these may be NULL (though both being NULL is useless).
3513 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3514 TYPE is the type of the function with the ordinary name. These
3515 may differ if the ordinary name is declared with a looser type to avoid
3516 conflicts with headers. FUNCTION_CODE and CLASS are as for
3517 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3518 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3519 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3520 ATTRS is the tree list representing the builtin's function attributes.
3521 Returns the declaration of BUILTIN_NAME, if any, otherwise
3522 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3523 or if NONANSI_P and flag_no_nonansi_builtin. */
3526 builtin_function_2 (const char *builtin_name, const char *name,
3527 tree builtin_type, tree type, int function_code,
3528 enum built_in_class class, int library_name_p,
3529 int nonansi_p, tree attrs)
3531 tree bdecl = NULL_TREE;
3532 tree decl = NULL_TREE;
3534 if (builtin_name != 0)
3535 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3536 class, library_name_p ? name : NULL, attrs);
3538 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3539 && !(nonansi_p && flag_no_nonansi_builtin))
3540 decl = builtin_function (name, type, function_code, class, NULL, attrs);
3542 return (bdecl != 0 ? bdecl : decl);
3545 /* Nonzero if the type T promotes to int. This is (nearly) the
3546 integral promotions defined in ISO C99 6.3.1.1/2. */
3549 c_promoting_integer_type_p (tree t)
3551 switch (TREE_CODE (t))
3554 return (TYPE_MAIN_VARIANT (t) == char_type_node
3555 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3556 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3557 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3558 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3559 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3562 /* ??? Technically all enumerations not larger than an int
3563 promote to an int. But this is used along code paths
3564 that only want to notice a size change. */
3565 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3575 /* Return 1 if PARMS specifies a fixed number of parameters
3576 and none of their types is affected by default promotions. */
3579 self_promoting_args_p (tree parms)
3582 for (t = parms; t; t = TREE_CHAIN (t))
3584 tree type = TREE_VALUE (t);
3586 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3592 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3595 if (c_promoting_integer_type_p (type))
3601 /* Recursively examines the array elements of TYPE, until a non-array
3602 element type is found. */
3605 strip_array_types (tree type)
3607 while (TREE_CODE (type) == ARRAY_TYPE)
3608 type = TREE_TYPE (type);
3613 /* Recursively remove any '*' or '&' operator from TYPE. */
3615 strip_pointer_operator (tree t)
3617 while (POINTER_TYPE_P (t))
3622 static tree expand_unordered_cmp (tree, tree, enum tree_code, enum tree_code);
3624 /* Expand a call to an unordered comparison function such as
3625 __builtin_isgreater(). FUNCTION is the function's declaration and
3626 PARAMS a list of the values passed. For __builtin_isunordered(),
3627 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3628 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3629 that give the opposite of the desired result. UNORDERED_CODE is
3630 used for modes that can hold NaNs and ORDERED_CODE is used for the
3634 expand_unordered_cmp (tree function, tree params,
3635 enum tree_code unordered_code,
3636 enum tree_code ordered_code)
3638 tree arg0, arg1, type;
3639 enum tree_code code0, code1;
3641 /* Check that we have exactly two arguments. */
3642 if (params == 0 || TREE_CHAIN (params) == 0)
3644 error ("too few arguments to function `%s'",
3645 IDENTIFIER_POINTER (DECL_NAME (function)));
3646 return error_mark_node;
3648 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3650 error ("too many arguments to function `%s'",
3651 IDENTIFIER_POINTER (DECL_NAME (function)));
3652 return error_mark_node;
3655 arg0 = TREE_VALUE (params);
3656 arg1 = TREE_VALUE (TREE_CHAIN (params));
3658 code0 = TREE_CODE (TREE_TYPE (arg0));
3659 code1 = TREE_CODE (TREE_TYPE (arg1));
3661 /* Make sure that the arguments have a common type of REAL. */
3663 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3664 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3665 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3667 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3669 error ("non-floating-point argument to function `%s'",
3670 IDENTIFIER_POINTER (DECL_NAME (function)));
3671 return error_mark_node;
3674 if (unordered_code == UNORDERED_EXPR)
3676 if (MODE_HAS_NANS (TYPE_MODE (type)))
3677 return build_binary_op (unordered_code,
3678 convert (type, arg0),
3679 convert (type, arg1),
3682 return integer_zero_node;
3685 return build_unary_op (TRUTH_NOT_EXPR,
3686 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3689 convert (type, arg0),
3690 convert (type, arg1),
3696 /* Recognize certain built-in functions so we can make tree-codes
3697 other than CALL_EXPR. We do this when it enables fold-const.c
3698 to do something useful. */
3699 /* ??? By rights this should go in builtins.c, but only C and C++
3700 implement build_{binary,unary}_op. Not exactly sure what bits
3701 of functionality are actually needed from those functions, or
3702 where the similar functionality exists in the other front ends. */
3705 expand_tree_builtin (tree function, tree params, tree coerced_params)
3707 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3710 switch (DECL_FUNCTION_CODE (function))
3714 case BUILT_IN_LLABS:
3715 case BUILT_IN_IMAXABS:
3717 case BUILT_IN_FABSL:
3718 case BUILT_IN_FABSF:
3719 if (coerced_params == 0)
3720 return integer_zero_node;
3721 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3724 case BUILT_IN_CONJF:
3725 case BUILT_IN_CONJL:
3726 if (coerced_params == 0)
3727 return integer_zero_node;
3728 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3730 case BUILT_IN_CREAL:
3731 case BUILT_IN_CREALF:
3732 case BUILT_IN_CREALL:
3733 if (coerced_params == 0)
3734 return integer_zero_node;
3735 return non_lvalue (build_unary_op (REALPART_EXPR,
3736 TREE_VALUE (coerced_params), 0));
3738 case BUILT_IN_CIMAG:
3739 case BUILT_IN_CIMAGF:
3740 case BUILT_IN_CIMAGL:
3741 if (coerced_params == 0)
3742 return integer_zero_node;
3743 return non_lvalue (build_unary_op (IMAGPART_EXPR,
3744 TREE_VALUE (coerced_params), 0));
3746 case BUILT_IN_ISGREATER:
3747 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3749 case BUILT_IN_ISGREATEREQUAL:
3750 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3752 case BUILT_IN_ISLESS:
3753 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3755 case BUILT_IN_ISLESSEQUAL:
3756 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3758 case BUILT_IN_ISLESSGREATER:
3759 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3761 case BUILT_IN_ISUNORDERED:
3762 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3771 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3772 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3773 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3774 value, the traversal is aborted, and the value returned by FUNC is
3775 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3776 the node being visited are not walked.
3778 We don't need a without_duplicates variant of this one because the
3779 statement tree is a tree, not a graph. */
3782 walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
3784 enum tree_code code;
3789 #define WALK_SUBTREE(NODE) \
3792 result = walk_stmt_tree (&(NODE), func, data); \
3798 /* Skip empty subtrees. */
3802 /* Skip subtrees below non-statement nodes. */
3803 if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
3806 /* Call the function. */
3808 result = (*func) (tp, &walk_subtrees, data);
3810 /* If we found something, return it. */
3814 /* FUNC may have modified the tree, recheck that we're looking at a
3816 code = TREE_CODE (*tp);
3817 if (!STATEMENT_CODE_P (code))
3820 /* Visit the subtrees unless FUNC decided that there was nothing
3821 interesting below this point in the tree. */
3824 /* Walk over all the sub-trees of this operand. Statement nodes
3825 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3826 len = TREE_CODE_LENGTH (code);
3828 /* Go through the subtrees. We need to do this in forward order so
3829 that the scope of a FOR_EXPR is handled properly. */
3830 for (i = 0; i < len; ++i)
3831 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3834 /* Finally visit the chain. This can be tail-recursion optimized if
3835 we write it this way. */
3836 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3841 /* Used to compare case labels. K1 and K2 are actually tree nodes
3842 representing case labels, or NULL_TREE for a `default' label.
3843 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3844 K2, and 0 if K1 and K2 are equal. */
3847 case_compare (splay_tree_key k1, splay_tree_key k2)
3849 /* Consider a NULL key (such as arises with a `default' label) to be
3850 smaller than anything else. */
3856 return tree_int_cst_compare ((tree) k1, (tree) k2);
3859 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3860 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3861 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3862 case label was declared using the usual C/C++ syntax, rather than
3863 the GNU case range extension. CASES is a tree containing all the
3864 case ranges processed so far; COND is the condition for the
3865 switch-statement itself. Returns the CASE_LABEL created, or
3866 ERROR_MARK_NODE if no CASE_LABEL is created. */
3869 c_add_case_label (splay_tree cases, tree cond, tree low_value,
3875 splay_tree_node node;
3877 /* Create the LABEL_DECL itself. */
3878 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3879 DECL_CONTEXT (label) = current_function_decl;
3881 /* If there was an error processing the switch condition, bail now
3882 before we get more confused. */
3883 if (!cond || cond == error_mark_node)
3885 /* Add a label anyhow so that the back-end doesn't think that
3886 the beginning of the switch is unreachable. */
3888 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3889 return error_mark_node;
3892 if ((low_value && TREE_TYPE (low_value)
3893 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3894 || (high_value && TREE_TYPE (high_value)
3895 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3896 error ("pointers are not permitted as case values");
3898 /* Case ranges are a GNU extension. */
3899 if (high_value && pedantic)
3900 pedwarn ("range expressions in switch statements are non-standard");
3902 type = TREE_TYPE (cond);
3905 low_value = check_case_value (low_value);
3906 low_value = convert_and_check (type, low_value);
3910 high_value = check_case_value (high_value);
3911 high_value = convert_and_check (type, high_value);
3914 /* If an error has occurred, bail out now. */
3915 if (low_value == error_mark_node || high_value == error_mark_node)
3918 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3919 return error_mark_node;
3922 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3923 really a case range, even though it was written that way. Remove
3924 the HIGH_VALUE to simplify later processing. */
3925 if (tree_int_cst_equal (low_value, high_value))
3926 high_value = NULL_TREE;
3927 if (low_value && high_value
3928 && !tree_int_cst_lt (low_value, high_value))
3929 warning ("empty range specified");
3931 /* Look up the LOW_VALUE in the table of case labels we already
3933 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3934 /* If there was not an exact match, check for overlapping ranges.
3935 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3936 that's a `default' label and the only overlap is an exact match. */
3937 if (!node && (low_value || high_value))
3939 splay_tree_node low_bound;
3940 splay_tree_node high_bound;
3942 /* Even though there wasn't an exact match, there might be an
3943 overlap between this case range and another case range.
3944 Since we've (inductively) not allowed any overlapping case
3945 ranges, we simply need to find the greatest low case label
3946 that is smaller that LOW_VALUE, and the smallest low case
3947 label that is greater than LOW_VALUE. If there is an overlap
3948 it will occur in one of these two ranges. */
3949 low_bound = splay_tree_predecessor (cases,
3950 (splay_tree_key) low_value);
3951 high_bound = splay_tree_successor (cases,
3952 (splay_tree_key) low_value);
3954 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3955 the LOW_VALUE, so there is no need to check unless the
3956 LOW_BOUND is in fact itself a case range. */
3958 && CASE_HIGH ((tree) low_bound->value)
3959 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3962 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3963 range is bigger than the low end of the current range, so we
3964 are only interested if the current range is a real range, and
3965 not an ordinary case label. */
3968 && (tree_int_cst_compare ((tree) high_bound->key,
3973 /* If there was an overlap, issue an error. */
3976 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3980 error ("duplicate (or overlapping) case value");
3981 error ("%Jthis is the first entry overlapping that value", duplicate);
3985 error ("duplicate case value") ;
3986 error ("%Jpreviously used here", duplicate);
3990 error ("multiple default labels in one switch");
3991 error ("%Jthis is the first default label", duplicate);
3994 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3997 /* Add a CASE_LABEL to the statement-tree. */
3998 case_label = add_stmt (build_case_label (low_value, high_value, label));
3999 /* Register this case label in the splay tree. */
4000 splay_tree_insert (cases,
4001 (splay_tree_key) low_value,
4002 (splay_tree_value) case_label);
4007 /* Finish an expression taking the address of LABEL (an
4008 IDENTIFIER_NODE). Returns an expression for the address. */
4011 finish_label_address_expr (tree label)
4016 pedwarn ("taking the address of a label is non-standard");
4018 if (label == error_mark_node)
4019 return error_mark_node;
4021 label = lookup_label (label);
4022 if (label == NULL_TREE)
4023 result = null_pointer_node;
4026 TREE_USED (label) = 1;
4027 result = build1 (ADDR_EXPR, ptr_type_node, label);
4028 TREE_CONSTANT (result) = 1;
4029 /* The current function in not necessarily uninlinable.
4030 Computed gotos are incompatible with inlining, but the value
4031 here could be used only in a diagnostic, for example. */
4037 /* Hook used by expand_expr to expand language-specific tree codes. */
4040 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4041 int modifier /* Actually enum_modifier. */,
4044 switch (TREE_CODE (exp))
4050 bool preserve_result = false;
4052 if (STMT_EXPR_WARN_UNUSED_RESULT (exp) && target == const0_rtx)
4054 tree stmt = STMT_EXPR_STMT (exp);
4057 for (scope = COMPOUND_BODY (stmt);
4058 scope && TREE_CODE (scope) != SCOPE_STMT;
4059 scope = TREE_CHAIN (scope));
4061 if (scope && SCOPE_STMT_BLOCK (scope))
4062 warning ("%Hignoring return value of `%D', "
4063 "declared with attribute warn_unused_result",
4064 &expr_wfl_stack->location,
4065 BLOCK_ABSTRACT_ORIGIN (SCOPE_STMT_BLOCK (scope)));
4067 warning ("%Hignoring return value of function "
4068 "declared with attribute warn_unused_result",
4069 &expr_wfl_stack->location);
4072 /* Since expand_expr_stmt calls free_temp_slots after every
4073 expression statement, we must call push_temp_slots here.
4074 Otherwise, any temporaries in use now would be considered
4075 out-of-scope after the first EXPR_STMT from within the
4078 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4080 /* If we want the result of this expression, find the last
4081 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4082 if (target != const0_rtx
4083 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4084 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4086 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4087 tree last = TREE_CHAIN (expr);
4089 while (TREE_CHAIN (last))
4092 last = TREE_CHAIN (last);
4095 if (TREE_CODE (last) == SCOPE_STMT
4096 && TREE_CODE (expr) == EXPR_STMT)
4098 /* Otherwise, note that we want the value from the last
4100 TREE_ADDRESSABLE (expr) = 1;
4101 preserve_result = true;
4105 expand_stmt (STMT_EXPR_STMT (exp));
4106 expand_end_stmt_expr (rtl_expr);
4108 result = expand_expr_real (rtl_expr, target, tmode, modifier, alt_rtl);
4109 if (preserve_result && GET_CODE (result) == MEM)
4111 if (GET_MODE (result) != BLKmode)
4112 result = copy_to_reg (result);
4114 preserve_temp_slots (result);
4117 /* If the statment-expression does not have a scope, then the
4118 new temporaries we created within it must live beyond the
4119 statement-expression. */
4120 if (STMT_EXPR_NO_SCOPE (exp))
4121 preserve_temp_slots (NULL_RTX);
4128 case COMPOUND_LITERAL_EXPR:
4130 /* Initialize the anonymous variable declared in the compound
4131 literal, then return the variable. */
4132 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4133 emit_local_var (decl);
4134 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4145 /* Hook used by safe_from_p to handle language-specific tree codes. */
4148 c_safe_from_p (rtx target, tree exp)
4150 /* We can see statements here when processing the body of a
4151 statement-expression. For a declaration statement declaring a
4152 variable, look at the variable's initializer. */
4153 if (TREE_CODE (exp) == DECL_STMT)
4155 tree decl = DECL_STMT_DECL (exp);
4157 if (TREE_CODE (decl) == VAR_DECL
4158 && DECL_INITIAL (decl)
4159 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4163 /* For any statement, we must follow the statement-chain. */
4164 if (STATEMENT_CODE_P (TREE_CODE (exp)) && TREE_CHAIN (exp))
4165 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4167 /* Assume everything else is safe. */
4171 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4174 c_common_unsafe_for_reeval (tree exp)
4176 /* Statement expressions may not be reevaluated, likewise compound
4178 if (TREE_CODE (exp) == STMT_EXPR
4179 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4182 /* Walk all other expressions. */
4186 /* Hook used by staticp to handle language-specific tree codes. */
4189 c_staticp (tree exp)
4191 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4192 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4198 /* Given a boolean expression ARG, return a tree representing an increment
4199 or decrement (as indicated by CODE) of ARG. The front end must check for
4200 invalid cases (e.g., decrement in C++). */
4202 boolean_increment (enum tree_code code, tree arg)
4205 tree true_res = boolean_true_node;
4207 arg = stabilize_reference (arg);
4210 case PREINCREMENT_EXPR:
4211 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4213 case POSTINCREMENT_EXPR:
4214 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4215 arg = save_expr (arg);
4216 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4217 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4219 case PREDECREMENT_EXPR:
4220 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4222 case POSTDECREMENT_EXPR:
4223 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4224 arg = save_expr (arg);
4225 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4226 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4231 TREE_SIDE_EFFECTS (val) = 1;
4235 /* Built-in macros for stddef.h, that require macros defined in this
4238 c_stddef_cpp_builtins(void)
4240 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4241 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4242 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4243 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4247 c_init_attributes (void)
4249 /* Fill in the built_in_attributes array. */
4250 #define DEF_ATTR_NULL_TREE(ENUM) \
4251 built_in_attributes[(int) ENUM] = NULL_TREE;
4252 #define DEF_ATTR_INT(ENUM, VALUE) \
4253 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4254 #define DEF_ATTR_IDENT(ENUM, STRING) \
4255 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4256 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4257 built_in_attributes[(int) ENUM] \
4258 = tree_cons (built_in_attributes[(int) PURPOSE], \
4259 built_in_attributes[(int) VALUE], \
4260 built_in_attributes[(int) CHAIN]);
4261 #include "builtin-attrs.def"
4262 #undef DEF_ATTR_NULL_TREE
4264 #undef DEF_ATTR_IDENT
4265 #undef DEF_ATTR_TREE_LIST
4268 /* Attribute handlers common to C front ends. */
4270 /* Handle a "packed" attribute; arguments as in
4271 struct attribute_spec.handler. */
4274 handle_packed_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4275 int flags, bool *no_add_attrs)
4279 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4280 *node = build_type_copy (*node);
4281 TYPE_PACKED (*node) = 1;
4282 if (TYPE_MAIN_VARIANT (*node) == *node)
4284 /* If it is the main variant, then pack the other variants
4285 too. This happens in,
4288 struct Foo const *ptr; // creates a variant w/o packed flag
4289 } __ attribute__((packed)); // packs it now.
4293 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
4294 TYPE_PACKED (probe) = 1;
4298 else if (TREE_CODE (*node) == FIELD_DECL)
4299 DECL_PACKED (*node) = 1;
4300 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4301 used for DECL_REGISTER. It wouldn't mean anything anyway.
4302 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4303 that changes what the typedef is typing. */
4306 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4307 *no_add_attrs = true;
4313 /* Handle a "nocommon" attribute; arguments as in
4314 struct attribute_spec.handler. */
4317 handle_nocommon_attribute (tree *node, tree name,
4318 tree args ATTRIBUTE_UNUSED,
4319 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4321 if (TREE_CODE (*node) == VAR_DECL)
4322 DECL_COMMON (*node) = 0;
4325 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4326 *no_add_attrs = true;
4332 /* Handle a "common" attribute; arguments as in
4333 struct attribute_spec.handler. */
4336 handle_common_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4337 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4339 if (TREE_CODE (*node) == VAR_DECL)
4340 DECL_COMMON (*node) = 1;
4343 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4344 *no_add_attrs = true;
4350 /* Handle a "noreturn" attribute; arguments as in
4351 struct attribute_spec.handler. */
4354 handle_noreturn_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4355 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4357 tree type = TREE_TYPE (*node);
4359 /* See FIXME comment in c_common_attribute_table. */
4360 if (TREE_CODE (*node) == FUNCTION_DECL)
4361 TREE_THIS_VOLATILE (*node) = 1;
4362 else if (TREE_CODE (type) == POINTER_TYPE
4363 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4365 = build_pointer_type
4366 (build_type_variant (TREE_TYPE (type),
4367 TREE_READONLY (TREE_TYPE (type)), 1));
4370 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4371 *no_add_attrs = true;
4377 /* Handle a "noinline" attribute; arguments as in
4378 struct attribute_spec.handler. */
4381 handle_noinline_attribute (tree *node, tree name,
4382 tree args ATTRIBUTE_UNUSED,
4383 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4385 if (TREE_CODE (*node) == FUNCTION_DECL)
4386 DECL_UNINLINABLE (*node) = 1;
4389 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4390 *no_add_attrs = true;
4396 /* Handle a "always_inline" attribute; arguments as in
4397 struct attribute_spec.handler. */
4400 handle_always_inline_attribute (tree *node, tree name,
4401 tree args ATTRIBUTE_UNUSED,
4402 int flags ATTRIBUTE_UNUSED,
4405 if (TREE_CODE (*node) == FUNCTION_DECL)
4407 /* Do nothing else, just set the attribute. We'll get at
4408 it later with lookup_attribute. */
4412 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4413 *no_add_attrs = true;
4419 /* Handle a "used" attribute; arguments as in
4420 struct attribute_spec.handler. */
4423 handle_used_attribute (tree *pnode, tree name, tree args ATTRIBUTE_UNUSED,
4424 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4428 if (TREE_CODE (node) == FUNCTION_DECL
4429 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4431 TREE_USED (node) = 1;
4435 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4436 *no_add_attrs = true;
4442 /* Handle a "unused" attribute; arguments as in
4443 struct attribute_spec.handler. */
4446 handle_unused_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4447 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4453 if (TREE_CODE (decl) == PARM_DECL
4454 || TREE_CODE (decl) == VAR_DECL
4455 || TREE_CODE (decl) == FUNCTION_DECL
4456 || TREE_CODE (decl) == LABEL_DECL
4457 || TREE_CODE (decl) == TYPE_DECL)
4458 TREE_USED (decl) = 1;
4461 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4462 *no_add_attrs = true;
4467 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4468 *node = build_type_copy (*node);
4469 TREE_USED (*node) = 1;
4475 /* Handle a "const" attribute; arguments as in
4476 struct attribute_spec.handler. */
4479 handle_const_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4480 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4482 tree type = TREE_TYPE (*node);
4484 /* See FIXME comment on noreturn in c_common_attribute_table. */
4485 if (TREE_CODE (*node) == FUNCTION_DECL)
4486 TREE_READONLY (*node) = 1;
4487 else if (TREE_CODE (type) == POINTER_TYPE
4488 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4490 = build_pointer_type
4491 (build_type_variant (TREE_TYPE (type), 1,
4492 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4495 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4496 *no_add_attrs = true;
4502 /* Handle a "transparent_union" attribute; arguments as in
4503 struct attribute_spec.handler. */
4506 handle_transparent_union_attribute (tree *node, tree name,
4507 tree args ATTRIBUTE_UNUSED, int flags,
4510 tree decl = NULL_TREE;
4517 type = &TREE_TYPE (decl);
4518 is_type = TREE_CODE (*node) == TYPE_DECL;
4520 else if (TYPE_P (*node))
4521 type = node, is_type = 1;
4524 && TREE_CODE (*type) == UNION_TYPE
4526 || (TYPE_FIELDS (*type) != 0
4527 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4529 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4530 *type = build_type_copy (*type);
4531 TYPE_TRANSPARENT_UNION (*type) = 1;
4533 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4534 && TREE_CODE (*type) == UNION_TYPE
4535 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4536 DECL_TRANSPARENT_UNION (decl) = 1;
4539 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4540 *no_add_attrs = true;
4546 /* Handle a "constructor" attribute; arguments as in
4547 struct attribute_spec.handler. */
4550 handle_constructor_attribute (tree *node, tree name,
4551 tree args ATTRIBUTE_UNUSED,
4552 int flags ATTRIBUTE_UNUSED,
4556 tree type = TREE_TYPE (decl);
4558 if (TREE_CODE (decl) == FUNCTION_DECL
4559 && TREE_CODE (type) == FUNCTION_TYPE
4560 && decl_function_context (decl) == 0)
4562 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4563 TREE_USED (decl) = 1;
4567 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4568 *no_add_attrs = true;
4574 /* Handle a "destructor" attribute; arguments as in
4575 struct attribute_spec.handler. */
4578 handle_destructor_attribute (tree *node, tree name,
4579 tree args ATTRIBUTE_UNUSED,
4580 int flags ATTRIBUTE_UNUSED,
4584 tree type = TREE_TYPE (decl);
4586 if (TREE_CODE (decl) == FUNCTION_DECL
4587 && TREE_CODE (type) == FUNCTION_TYPE
4588 && decl_function_context (decl) == 0)
4590 DECL_STATIC_DESTRUCTOR (decl) = 1;
4591 TREE_USED (decl) = 1;
4595 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4596 *no_add_attrs = true;
4602 /* Handle a "mode" attribute; arguments as in
4603 struct attribute_spec.handler. */
4606 handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4607 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4611 *no_add_attrs = true;
4613 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4614 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4618 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4619 int len = strlen (p);
4620 enum machine_mode mode = VOIDmode;
4624 if (len > 4 && p[0] == '_' && p[1] == '_'
4625 && p[len - 1] == '_' && p[len - 2] == '_')
4627 char *newp = alloca (len - 1);
4629 strcpy (newp, &p[2]);
4630 newp[len - 4] = '\0';
4634 /* Change this type to have a type with the specified mode.
4635 First check for the special modes. */
4636 if (! strcmp (p, "byte"))
4638 else if (!strcmp (p, "word"))
4640 else if (! strcmp (p, "pointer"))
4643 for (j = 0; j < NUM_MACHINE_MODES; j++)
4644 if (!strcmp (p, GET_MODE_NAME (j)))
4646 mode = (enum machine_mode) j;
4650 if (mode == VOIDmode)
4651 error ("unknown machine mode `%s'", p);
4652 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
4653 (mode, TREE_UNSIGNED (type))))
4654 error ("no data type for mode `%s'", p);
4655 else if ((TREE_CODE (type) == POINTER_TYPE
4656 || TREE_CODE (type) == REFERENCE_TYPE)
4657 && !(*targetm.valid_pointer_mode) (mode))
4658 error ("invalid pointer mode `%s'", p);
4661 /* If this is a vector, make sure we either have hardware
4662 support, or we can emulate it. */
4663 if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
4665 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
4669 if (TREE_CODE (type) == POINTER_TYPE)
4671 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
4675 else if (TREE_CODE (type) == REFERENCE_TYPE)
4677 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
4681 else if (VECTOR_MODE_P (mode)
4682 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4683 : TREE_CODE (type) != TREE_CODE (typefm))
4686 error ("mode `%s' applied to inappropriate type", p);
4692 /* No need to layout the type here. The caller should do this. */
4699 /* Handle a "section" attribute; arguments as in
4700 struct attribute_spec.handler. */
4703 handle_section_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4704 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4708 if (targetm.have_named_sections)
4710 if ((TREE_CODE (decl) == FUNCTION_DECL
4711 || TREE_CODE (decl) == VAR_DECL)
4712 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4714 if (TREE_CODE (decl) == VAR_DECL
4715 && current_function_decl != NULL_TREE
4716 && ! TREE_STATIC (decl))
4718 error ("%Jsection attribute cannot be specified for "
4719 "local variables", decl);
4720 *no_add_attrs = true;
4723 /* The decl may have already been given a section attribute
4724 from a previous declaration. Ensure they match. */
4725 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4726 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4727 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4729 error ("%Jsection of '%D' conflicts with previous declaration",
4731 *no_add_attrs = true;
4734 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4738 error ("%Jsection attribute not allowed for '%D'", *node, *node);
4739 *no_add_attrs = true;
4744 error ("%Jsection attributes are not supported for this target", *node);
4745 *no_add_attrs = true;
4751 /* Handle a "aligned" attribute; arguments as in
4752 struct attribute_spec.handler. */
4755 handle_aligned_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4756 int flags, bool *no_add_attrs)
4758 tree decl = NULL_TREE;
4761 tree align_expr = (args ? TREE_VALUE (args)
4762 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4768 type = &TREE_TYPE (decl);
4769 is_type = TREE_CODE (*node) == TYPE_DECL;
4771 else if (TYPE_P (*node))
4772 type = node, is_type = 1;
4774 /* Strip any NOPs of any kind. */
4775 while (TREE_CODE (align_expr) == NOP_EXPR
4776 || TREE_CODE (align_expr) == CONVERT_EXPR
4777 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4778 align_expr = TREE_OPERAND (align_expr, 0);
4780 if (TREE_CODE (align_expr) != INTEGER_CST)
4782 error ("requested alignment is not a constant");
4783 *no_add_attrs = true;
4785 else if ((i = tree_log2 (align_expr)) == -1)
4787 error ("requested alignment is not a power of 2");
4788 *no_add_attrs = true;
4790 else if (i > HOST_BITS_PER_INT - 2)
4792 error ("requested alignment is too large");
4793 *no_add_attrs = true;
4797 /* If we have a TYPE_DECL, then copy the type, so that we
4798 don't accidentally modify a builtin type. See pushdecl. */
4799 if (decl && TREE_TYPE (decl) != error_mark_node
4800 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4802 tree tt = TREE_TYPE (decl);
4803 *type = build_type_copy (*type);
4804 DECL_ORIGINAL_TYPE (decl) = tt;
4805 TYPE_NAME (*type) = decl;
4806 TREE_USED (*type) = TREE_USED (decl);
4807 TREE_TYPE (decl) = *type;
4809 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4810 *type = build_type_copy (*type);
4812 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4813 TYPE_USER_ALIGN (*type) = 1;
4815 else if (TREE_CODE (decl) != VAR_DECL
4816 && TREE_CODE (decl) != FIELD_DECL)
4818 error ("%Jalignment may not be specified for '%D'", decl, decl);
4819 *no_add_attrs = true;
4823 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4824 DECL_USER_ALIGN (decl) = 1;
4830 /* Handle a "weak" attribute; arguments as in
4831 struct attribute_spec.handler. */
4834 handle_weak_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
4835 tree args ATTRIBUTE_UNUSED,
4836 int flags ATTRIBUTE_UNUSED,
4837 bool *no_add_attrs ATTRIBUTE_UNUSED)
4839 declare_weak (*node);
4844 /* Handle an "alias" attribute; arguments as in
4845 struct attribute_spec.handler. */
4848 handle_alias_attribute (tree *node, tree name, tree args,
4849 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4853 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4854 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
4856 error ("%J'%D' defined both normally and as an alias", decl, decl);
4857 *no_add_attrs = true;
4859 else if (decl_function_context (decl) == 0)
4863 id = TREE_VALUE (args);
4864 if (TREE_CODE (id) != STRING_CST)
4866 error ("alias arg not a string");
4867 *no_add_attrs = true;
4870 id = get_identifier (TREE_STRING_POINTER (id));
4871 /* This counts as a use of the object pointed to. */
4874 if (TREE_CODE (decl) == FUNCTION_DECL)
4875 DECL_INITIAL (decl) = error_mark_node;
4877 DECL_EXTERNAL (decl) = 0;
4881 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4882 *no_add_attrs = true;
4888 /* Handle an "visibility" attribute; arguments as in
4889 struct attribute_spec.handler. */
4892 handle_visibility_attribute (tree *node, tree name, tree args,
4893 int flags ATTRIBUTE_UNUSED,
4897 tree id = TREE_VALUE (args);
4899 *no_add_attrs = true;
4901 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
4903 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4907 if (TREE_CODE (id) != STRING_CST)
4909 error ("visibility arg not a string");
4913 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4914 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4915 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4916 DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4917 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4918 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4919 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4920 DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4922 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4927 /* Handle an "tls_model" attribute; arguments as in
4928 struct attribute_spec.handler. */
4931 handle_tls_model_attribute (tree *node, tree name, tree args,
4932 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4936 if (! DECL_THREAD_LOCAL (decl))
4938 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4939 *no_add_attrs = true;
4945 id = TREE_VALUE (args);
4946 if (TREE_CODE (id) != STRING_CST)
4948 error ("tls_model arg not a string");
4949 *no_add_attrs = true;
4952 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
4953 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
4954 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
4955 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4957 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4958 *no_add_attrs = true;
4966 /* Handle a "no_instrument_function" attribute; arguments as in
4967 struct attribute_spec.handler. */
4970 handle_no_instrument_function_attribute (tree *node, tree name,
4971 tree args ATTRIBUTE_UNUSED,
4972 int flags ATTRIBUTE_UNUSED,
4977 if (TREE_CODE (decl) != FUNCTION_DECL)
4979 error ("%J'%E' attribute applies only to functions", decl, name);
4980 *no_add_attrs = true;
4982 else if (DECL_INITIAL (decl))
4984 error ("%Jcan't set '%E' attribute after definition", decl, name);
4985 *no_add_attrs = true;
4988 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
4993 /* Handle a "malloc" attribute; arguments as in
4994 struct attribute_spec.handler. */
4997 handle_malloc_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4998 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5000 if (TREE_CODE (*node) == FUNCTION_DECL)
5001 DECL_IS_MALLOC (*node) = 1;
5002 /* ??? TODO: Support types. */
5005 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5006 *no_add_attrs = true;
5012 /* Handle a "no_limit_stack" attribute; arguments as in
5013 struct attribute_spec.handler. */
5016 handle_no_limit_stack_attribute (tree *node, tree name,
5017 tree args ATTRIBUTE_UNUSED,
5018 int flags ATTRIBUTE_UNUSED,
5023 if (TREE_CODE (decl) != FUNCTION_DECL)
5025 error ("%J'%E' attribute applies only to functions", decl, name);
5026 *no_add_attrs = true;
5028 else if (DECL_INITIAL (decl))
5030 error ("%Jcan't set '%E' attribute after definition", decl, name);
5031 *no_add_attrs = true;
5034 DECL_NO_LIMIT_STACK (decl) = 1;
5039 /* Handle a "pure" attribute; arguments as in
5040 struct attribute_spec.handler. */
5043 handle_pure_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5044 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5046 if (TREE_CODE (*node) == FUNCTION_DECL)
5047 DECL_IS_PURE (*node) = 1;
5048 /* ??? TODO: Support types. */
5051 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5052 *no_add_attrs = true;
5058 /* Handle a "deprecated" attribute; arguments as in
5059 struct attribute_spec.handler. */
5062 handle_deprecated_attribute (tree *node, tree name,
5063 tree args ATTRIBUTE_UNUSED, int flags,
5066 tree type = NULL_TREE;
5068 const char *what = NULL;
5073 type = TREE_TYPE (decl);
5075 if (TREE_CODE (decl) == TYPE_DECL
5076 || TREE_CODE (decl) == PARM_DECL
5077 || TREE_CODE (decl) == VAR_DECL
5078 || TREE_CODE (decl) == FUNCTION_DECL
5079 || TREE_CODE (decl) == FIELD_DECL)
5080 TREE_DEPRECATED (decl) = 1;
5084 else if (TYPE_P (*node))
5086 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5087 *node = build_type_copy (*node);
5088 TREE_DEPRECATED (*node) = 1;
5096 *no_add_attrs = true;
5097 if (type && TYPE_NAME (type))
5099 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5100 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5101 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5102 && DECL_NAME (TYPE_NAME (type)))
5103 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5106 warning ("`%s' attribute ignored for `%s'",
5107 IDENTIFIER_POINTER (name), what);
5109 warning ("`%s' attribute ignored",
5110 IDENTIFIER_POINTER (name));
5116 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5117 to prevent us from duplicating type nodes unnecessarily.
5118 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5119 since we want to distinguish types that are essentially identical (except
5120 for their debug representation), we use a local list here. */
5121 static GTY(()) tree vector_type_node_list = 0;
5123 /* Handle a "vector_size" attribute; arguments as in
5124 struct attribute_spec.handler. */
5127 handle_vector_size_attribute (tree *node, tree name, tree args,
5128 int flags ATTRIBUTE_UNUSED,
5131 unsigned HOST_WIDE_INT vecsize, nunits;
5132 enum machine_mode mode, orig_mode, new_mode;
5133 tree type = *node, new_type = NULL_TREE;
5134 tree type_list_node;
5136 *no_add_attrs = true;
5138 if (! host_integerp (TREE_VALUE (args), 1))
5140 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5144 /* Get the vector size (in bytes). */
5145 vecsize = tree_low_cst (TREE_VALUE (args), 1);
5147 /* We need to provide for vector pointers, vector arrays, and
5148 functions returning vectors. For example:
5150 __attribute__((vector_size(16))) short *foo;
5152 In this case, the mode is SI, but the type being modified is
5153 HI, so we need to look further. */
5155 while (POINTER_TYPE_P (type)
5156 || TREE_CODE (type) == FUNCTION_TYPE
5157 || TREE_CODE (type) == METHOD_TYPE
5158 || TREE_CODE (type) == ARRAY_TYPE)
5159 type = TREE_TYPE (type);
5161 /* Get the mode of the type being modified. */
5162 orig_mode = TYPE_MODE (type);
5164 if (TREE_CODE (type) == RECORD_TYPE
5165 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5166 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5167 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5169 error ("invalid vector type for attribute `%s'",
5170 IDENTIFIER_POINTER (name));
5174 /* Calculate how many units fit in the vector. */
5175 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5177 /* Find a suitably sized vector. */
5178 new_mode = VOIDmode;
5179 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5181 : MODE_VECTOR_FLOAT);
5183 mode = GET_MODE_WIDER_MODE (mode))
5184 if (vecsize == GET_MODE_SIZE (mode)
5185 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5191 if (new_mode == VOIDmode)
5193 error ("no vector mode with the size and type specified could be found");
5197 for (type_list_node = vector_type_node_list; type_list_node;
5198 type_list_node = TREE_CHAIN (type_list_node))
5200 tree other_type = TREE_VALUE (type_list_node);
5201 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
5202 tree fields = TYPE_FIELDS (record);
5203 tree field_type = TREE_TYPE (fields);
5204 tree array_type = TREE_TYPE (field_type);
5205 if (TREE_CODE (fields) != FIELD_DECL
5206 || TREE_CODE (field_type) != ARRAY_TYPE)
5209 if (TYPE_MODE (other_type) == mode && type == array_type)
5211 new_type = other_type;
5216 if (new_type == NULL_TREE)
5218 tree index, array, rt, list_node;
5220 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
5221 TREE_UNSIGNED (type));
5225 error ("no vector mode with the size and type specified could be found");
5229 new_type = build_type_copy (new_type);
5231 /* If this is a vector, make sure we either have hardware
5232 support, or we can emulate it. */
5233 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5234 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5235 && !vector_mode_valid_p (mode))
5237 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5241 /* Set the debug information here, because this is the only
5242 place where we know the underlying type for a vector made
5243 with vector_size. For debugging purposes we pretend a vector
5244 is an array within a structure. */
5245 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
5246 array = build_array_type (type, build_index_type (index));
5247 rt = make_node (RECORD_TYPE);
5249 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
5250 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
5252 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
5254 list_node = build_tree_list (NULL, new_type);
5255 TREE_CHAIN (list_node) = vector_type_node_list;
5256 vector_type_node_list = list_node;
5259 /* Build back pointers if needed. */
5260 *node = reconstruct_complex_type (*node, new_type);
5265 /* Handle the "nonnull" attribute. */
5267 handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
5268 tree args, int flags ATTRIBUTE_UNUSED,
5272 unsigned HOST_WIDE_INT attr_arg_num;
5274 /* If no arguments are specified, all pointer arguments should be
5275 non-null. Verify a full prototype is given so that the arguments
5276 will have the correct types when we actually check them later. */
5279 if (! TYPE_ARG_TYPES (type))
5281 error ("nonnull attribute without arguments on a non-prototype");
5282 *no_add_attrs = true;
5287 /* Argument list specified. Verify that each argument number references
5288 a pointer argument. */
5289 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5292 unsigned HOST_WIDE_INT arg_num, ck_num;
5294 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5296 error ("nonnull argument has invalid operand number (arg %lu)",
5297 (unsigned long) attr_arg_num);
5298 *no_add_attrs = true;
5302 argument = TYPE_ARG_TYPES (type);
5305 for (ck_num = 1; ; ck_num++)
5307 if (! argument || ck_num == arg_num)
5309 argument = TREE_CHAIN (argument);
5313 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5315 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5316 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5317 *no_add_attrs = true;
5321 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5323 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5324 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5325 *no_add_attrs = true;
5334 /* Check the argument list of a function call for null in argument slots
5335 that are marked as requiring a non-null pointer argument. */
5338 check_function_nonnull (tree attrs, tree params)
5340 tree a, args, param;
5343 for (a = attrs; a; a = TREE_CHAIN (a))
5345 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5347 args = TREE_VALUE (a);
5349 /* Walk the argument list. If we encounter an argument number we
5350 should check for non-null, do it. If the attribute has no args,
5351 then every pointer argument is checked (in which case the check
5352 for pointer type is done in check_nonnull_arg). */
5353 for (param = params, param_num = 1; ;
5354 param_num++, param = TREE_CHAIN (param))
5358 if (! args || nonnull_check_p (args, param_num))
5359 check_function_arguments_recurse (check_nonnull_arg, NULL,
5367 /* Helper for check_function_nonnull; given a list of operands which
5368 must be non-null in ARGS, determine if operand PARAM_NUM should be
5372 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5374 unsigned HOST_WIDE_INT arg_num;
5376 for (; args; args = TREE_CHAIN (args))
5378 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5381 if (arg_num == param_num)
5387 /* Check that the function argument PARAM (which is operand number
5388 PARAM_NUM) is non-null. This is called by check_function_nonnull
5389 via check_function_arguments_recurse. */
5392 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED, tree param,
5393 unsigned HOST_WIDE_INT param_num)
5395 /* Just skip checking the argument if it's not a pointer. This can
5396 happen if the "nonnull" attribute was given without an operand
5397 list (which means to check every pointer argument). */
5399 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5402 if (integer_zerop (param))
5403 warning ("null argument where non-null required (arg %lu)",
5404 (unsigned long) param_num);
5407 /* Helper for nonnull attribute handling; fetch the operand number
5408 from the attribute argument list. */
5411 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5413 /* Strip any conversions from the arg number and verify they
5415 while (TREE_CODE (arg_num_expr) == NOP_EXPR
5416 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
5417 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
5418 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
5420 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5421 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5424 *valp = TREE_INT_CST_LOW (arg_num_expr);
5428 /* Handle a "nothrow" attribute; arguments as in
5429 struct attribute_spec.handler. */
5432 handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5433 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5435 if (TREE_CODE (*node) == FUNCTION_DECL)
5436 TREE_NOTHROW (*node) = 1;
5437 /* ??? TODO: Support types. */
5440 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5441 *no_add_attrs = true;
5447 /* Handle a "cleanup" attribute; arguments as in
5448 struct attribute_spec.handler. */
5451 handle_cleanup_attribute (tree *node, tree name, tree args,
5452 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5455 tree cleanup_id, cleanup_decl;
5457 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5458 for global destructors in C++. This requires infrastructure that
5459 we don't have generically at the moment. It's also not a feature
5460 we'd be missing too much, since we do have attribute constructor. */
5461 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5463 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5464 *no_add_attrs = true;
5468 /* Verify that the argument is a function in scope. */
5469 /* ??? We could support pointers to functions here as well, if
5470 that was considered desirable. */
5471 cleanup_id = TREE_VALUE (args);
5472 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5474 error ("cleanup arg not an identifier");
5475 *no_add_attrs = true;
5478 cleanup_decl = lookup_name (cleanup_id);
5479 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5481 error ("cleanup arg not a function");
5482 *no_add_attrs = true;
5486 /* That the function has proper type is checked with the
5487 eventual call to build_function_call. */
5492 /* Handle a "warn_unused_result" attribute. No special handling. */
5495 handle_warn_unused_result_attribute (tree *node, tree name,
5496 tree args ATTRIBUTE_UNUSED,
5497 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5499 /* Ignore the attribute for functions not returning any value. */
5500 if (VOID_TYPE_P (TREE_TYPE (*node)))
5502 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5503 *no_add_attrs = true;
5509 /* Check for valid arguments being passed to a function. */
5511 check_function_arguments (tree attrs, tree params)
5513 /* Check for null being passed in a pointer argument that must be
5514 non-null. We also need to do this if format checking is enabled. */
5517 check_function_nonnull (attrs, params);
5519 /* Check for errors in format strings. */
5522 check_function_format (NULL, attrs, params);
5525 /* Generic argument checking recursion routine. PARAM is the argument to
5526 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5527 once the argument is resolved. CTX is context for the callback. */
5529 check_function_arguments_recurse (void (*callback)
5530 (void *, tree, unsigned HOST_WIDE_INT),
5531 void *ctx, tree param,
5532 unsigned HOST_WIDE_INT param_num)
5534 if (TREE_CODE (param) == NOP_EXPR)
5536 /* Strip coercion. */
5537 check_function_arguments_recurse (callback, ctx,
5538 TREE_OPERAND (param, 0), param_num);
5542 if (TREE_CODE (param) == CALL_EXPR)
5544 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5546 bool found_format_arg = false;
5548 /* See if this is a call to a known internationalization function
5549 that modifies a format arg. Such a function may have multiple
5550 format_arg attributes (for example, ngettext). */
5552 for (attrs = TYPE_ATTRIBUTES (type);
5554 attrs = TREE_CHAIN (attrs))
5555 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5558 tree format_num_expr;
5562 /* Extract the argument number, which was previously checked
5564 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5565 while (TREE_CODE (format_num_expr) == NOP_EXPR
5566 || TREE_CODE (format_num_expr) == CONVERT_EXPR
5567 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5568 format_num_expr = TREE_OPERAND (format_num_expr, 0);
5570 if (TREE_CODE (format_num_expr) != INTEGER_CST
5571 || TREE_INT_CST_HIGH (format_num_expr) != 0)
5574 format_num = TREE_INT_CST_LOW (format_num_expr);
5576 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5578 inner_args = TREE_CHAIN (inner_args), i++)
5579 if (i == format_num)
5581 check_function_arguments_recurse (callback, ctx,
5582 TREE_VALUE (inner_args),
5584 found_format_arg = true;
5589 /* If we found a format_arg attribute and did a recursive check,
5590 we are done with checking this argument. Otherwise, we continue
5591 and this will be considered a non-literal. */
5592 if (found_format_arg)
5596 if (TREE_CODE (param) == COND_EXPR)
5598 /* Check both halves of the conditional expression. */
5599 check_function_arguments_recurse (callback, ctx,
5600 TREE_OPERAND (param, 1), param_num);
5601 check_function_arguments_recurse (callback, ctx,
5602 TREE_OPERAND (param, 2), param_num);
5606 (*callback) (ctx, param, param_num);
5609 /* Function to help qsort sort FIELD_DECLs by name order. */
5612 field_decl_cmp (const void *x_p, const void *y_p)
5614 const tree *const x = x_p;
5615 const tree *const y = y_p;
5616 if (DECL_NAME (*x) == DECL_NAME (*y))
5617 /* A nontype is "greater" than a type. */
5618 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5619 if (DECL_NAME (*x) == NULL_TREE)
5621 if (DECL_NAME (*y) == NULL_TREE)
5623 if (DECL_NAME (*x) < DECL_NAME (*y))
5629 gt_pointer_operator new_value;
5633 /* This routine compares two fields like field_decl_cmp but using the
5634 pointer operator in resort_data. */
5637 resort_field_decl_cmp (const void *x_p, const void *y_p)
5639 const tree *const x = x_p;
5640 const tree *const y = y_p;
5642 if (DECL_NAME (*x) == DECL_NAME (*y))
5643 /* A nontype is "greater" than a type. */
5644 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5645 if (DECL_NAME (*x) == NULL_TREE)
5647 if (DECL_NAME (*y) == NULL_TREE)
5650 tree d1 = DECL_NAME (*x);
5651 tree d2 = DECL_NAME (*y);
5652 resort_data.new_value (&d1, resort_data.cookie);
5653 resort_data.new_value (&d2, resort_data.cookie);
5660 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5663 resort_sorted_fields (void *obj,
5664 void *orig_obj ATTRIBUTE_UNUSED ,
5665 gt_pointer_operator new_value,
5668 struct sorted_fields_type *sf = obj;
5669 resort_data.new_value = new_value;
5670 resort_data.cookie = cookie;
5671 qsort (&sf->elts[0], sf->len, sizeof (tree),
5672 resort_field_decl_cmp);
5675 /* Used by estimate_num_insns. Estimate number of instructions seen
5676 by given statement. */
5678 c_estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
5683 if (TYPE_P (x) || DECL_P (x))
5688 /* Assume that constants and references counts nothing. These should
5689 be majorized by amount of operations among them we count later
5690 and are common target of CSE and similar optimizations. */
5691 if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
5692 || TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
5694 switch (TREE_CODE (x))
5696 /* Recognize assignments of large structures and constructors of
5703 size = int_size_in_bytes (TREE_TYPE (x));
5705 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
5708 *count += ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
5713 tree decl = get_callee_fndecl (x);
5715 if (decl && DECL_BUILT_IN (decl))
5716 switch (DECL_FUNCTION_CODE (decl))
5718 case BUILT_IN_CONSTANT_P:
5721 case BUILT_IN_EXPECT:
5729 /* Few special cases of expensive operations. This is usefull
5730 to avoid inlining on functions having too many of these. */
5731 case TRUNC_DIV_EXPR:
5733 case FLOOR_DIV_EXPR:
5734 case ROUND_DIV_EXPR:
5735 case TRUNC_MOD_EXPR:
5737 case FLOOR_MOD_EXPR:
5738 case ROUND_MOD_EXPR:
5742 /* Various containers that will produce no code themselves. */
5749 case IDENTIFIER_NODE:
5750 case PLACEHOLDER_EXPR:
5751 case WITH_CLEANUP_EXPR:
5752 case CLEANUP_POINT_EXPR:
5754 case VIEW_CONVERT_EXPR:
5760 case TRY_CATCH_EXPR:
5761 case TRY_FINALLY_EXPR:
5764 case LABELED_BLOCK_EXPR:
5765 case EXIT_BLOCK_EXPR:
5766 case EXPR_WITH_FILE_LOCATION:
5783 /* Do not account static initializers. */
5784 if (TREE_STATIC (TREE_OPERAND (x, 0)))
5793 /* Estimate number of instructions that will be created by expanding the body. */
5795 c_estimate_num_insns (tree decl)
5798 walk_tree_without_duplicates (&DECL_SAVED_TREE (decl), c_estimate_num_insns_1, &num);
5802 /* Used by c_decl_uninit to find where expressions like x = x + 1; */
5805 c_decl_uninit_1 (tree *t, int *walk_sub_trees, void *x)
5807 /* If x = EXP(&x)EXP, then do not warn about the use of x. */
5808 if (TREE_CODE (*t) == ADDR_EXPR && TREE_OPERAND (*t, 0) == x)
5810 *walk_sub_trees = 0;
5818 /* Find out if a variable is uninitialized based on DECL_INITIAL. */
5821 c_decl_uninit (tree t)
5823 /* int x = x; is GCC extension to turn off this warning, only if warn_init_self is zero. */
5824 if (DECL_INITIAL (t) == t)
5825 return warn_init_self ? true : false;
5827 /* Walk the trees looking for the variable itself. */
5828 if (walk_tree_without_duplicates (&DECL_INITIAL (t), c_decl_uninit_1, t))
5833 /* Issue the error given by MSGID, indicating that it occurred before
5834 TOKEN, which had the associated VALUE. */
5837 c_parse_error (const char *msgid, enum cpp_ttype token, tree value)
5839 const char *string = _(msgid);
5841 if (token == CPP_EOF)
5842 error ("%s at end of input", string);
5843 else if (token == CPP_CHAR || token == CPP_WCHAR)
5845 unsigned int val = TREE_INT_CST_LOW (value);
5846 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5847 if (val <= UCHAR_MAX && ISGRAPH (val))
5848 error ("%s before %s'%c'", string, ell, val);
5850 error ("%s before %s'\\x%x'", string, ell, val);
5852 else if (token == CPP_STRING
5853 || token == CPP_WSTRING)
5854 error ("%s before string constant", string);
5855 else if (token == CPP_NUMBER)
5856 error ("%s before numeric constant", string);
5857 else if (token == CPP_NAME)
5858 error ("%s before \"%s\"", string, IDENTIFIER_POINTER (value));
5859 else if (token < N_TTYPES)
5860 error ("%s before '%s' token", string, cpp_type2name (token));
5862 error ("%s", string);
5865 #include "gt-c-common.h"