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 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;
350 /* C/ObjC language option variables. */
353 /* Nonzero means message about use of implicit function declarations;
354 1 means warning; 2 means error. */
356 int mesg_implicit_function_declaration = -1;
358 /* Nonzero means allow type mismatches in conditional expressions;
359 just make their values `void'. */
361 int flag_cond_mismatch;
363 /* Nonzero means enable C89 Amendment 1 features. */
367 /* Nonzero means use the ISO C99 dialect of C. */
371 /* Nonzero means that we have builtin functions, and main is an int */
375 /* Nonzero means warn when casting a function call to a type that does
376 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
377 when there is no previous declaration of sqrt or malloc. */
379 int warn_bad_function_cast;
381 /* Warn about traditional constructs whose meanings changed in ANSI C. */
383 int warn_traditional;
385 /* Nonzero means warn for a declaration found after a statement. */
387 int warn_declaration_after_statement;
389 /* Nonzero means warn for non-prototype function decls
390 or non-prototyped defs without previous prototype. */
392 int warn_strict_prototypes;
394 /* Nonzero means warn for any global function def
395 without separate previous decl. */
397 int warn_missing_declarations;
399 /* Nonzero means warn about declarations of objects not at
400 file-scope level and about *all* declarations of functions (whether
401 or static) not at file-scope level. Note that we exclude
402 implicit function declarations. To get warnings about those, use
405 int warn_nested_externs;
407 /* Warn if main is suspicious. */
411 /* Nonzero means warn about possible violations of sequence point rules. */
413 int warn_sequence_point;
415 /* Nonzero means warn about uninitialized variable when it is initialized with itself.
416 For example: int i = i;, GCC will not warn about this when warn_init_self is nonzero. */
420 /* Nonzero means to warn about compile-time division by zero. */
421 int warn_div_by_zero = 1;
423 /* Nonzero means warn about use of implicit int. */
425 int warn_implicit_int;
427 /* Warn about NULL being passed to argument slots marked as requiring
432 /* Warn about old-style parameter declaration. */
434 int warn_old_style_definition;
437 /* ObjC language option variables. */
440 /* Open and close the file for outputting class declarations, if
443 int flag_gen_declaration;
445 /* Generate code for GNU or NeXT runtime environment. */
447 #ifdef NEXT_OBJC_RUNTIME
448 int flag_next_runtime = 1;
450 int flag_next_runtime = 0;
453 /* Tells the compiler that this is a special run. Do not perform any
454 compiling, instead we are to test some platform dependent features
455 and output a C header file with appropriate definitions. */
457 int print_struct_values;
459 /* ???. Undocumented. */
461 const char *constant_string_class_name;
463 /* Warn if multiple methods are seen for the same selector, but with
464 different argument types. Performs the check on the whole selector
465 table at the end of compilation. */
469 /* Warn if a @selector() is found, and no method with that selector
470 has been previously declared. The check is done on each
471 @selector() as soon as it is found - so it warns about forward
474 int warn_undeclared_selector;
476 /* Warn if methods required by a protocol are not implemented in the
477 class adopting it. When turned off, methods inherited to that
478 class are also considered implemented. */
480 int warn_protocol = 1;
483 /* C++ language option variables. */
486 /* Nonzero means don't recognize any extension keywords. */
488 int flag_no_gnu_keywords;
490 /* Nonzero means do emit exported implementations of functions even if
491 they can be inlined. */
493 int flag_implement_inlines = 1;
495 /* Nonzero means do emit exported implementations of templates, instead of
496 multiple static copies in each file that needs a definition. */
498 int flag_external_templates;
500 /* Nonzero means that the decision to emit or not emit the implementation of a
501 template depends on where the template is instantiated, rather than where
504 int flag_alt_external_templates;
506 /* Nonzero means that implicit instantiations will be emitted if needed. */
508 int flag_implicit_templates = 1;
510 /* Nonzero means that implicit instantiations of inline templates will be
511 emitted if needed, even if instantiations of non-inline templates
514 int flag_implicit_inline_templates = 1;
516 /* Nonzero means generate separate instantiation control files and
517 juggle them at link time. */
519 int flag_use_repository;
521 /* Nonzero if we want to issue diagnostics that the standard says are not
524 int flag_optional_diags = 1;
526 /* Nonzero means we should attempt to elide constructors when possible. */
528 int flag_elide_constructors = 1;
530 /* Nonzero means that member functions defined in class scope are
531 inline by default. */
533 int flag_default_inline = 1;
535 /* Controls whether compiler generates 'type descriptor' that give
536 run-time type information. */
540 /* Nonzero if we want to conserve space in the .o files. We do this
541 by putting uninitialized data and runtime initialized data into
542 .common instead of .data at the expense of not flagging multiple
545 int flag_conserve_space;
547 /* Nonzero if we want to obey access control semantics. */
549 int flag_access_control = 1;
551 /* Nonzero if we want to check the return value of new and avoid calling
552 constructors if it is a null pointer. */
556 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
557 initialization variables.
558 0: Old rules, set by -fno-for-scope.
559 2: New ISO rules, set by -ffor-scope.
560 1: Try to implement new ISO rules, but with backup compatibility
561 (and warnings). This is the default, for now. */
563 int flag_new_for_scope = 1;
565 /* Nonzero if we want to emit defined symbols with common-like linkage as
566 weak symbols where possible, in order to conform to C++ semantics.
567 Otherwise, emit them as local symbols. */
571 /* 0 means we want the preprocessor to not emit line directives for
572 the current working directory. 1 means we want it to do it. -1
573 means we should decide depending on whether debugging information
574 is being emitted or not. */
576 int flag_working_directory = -1;
578 /* Nonzero to use __cxa_atexit, rather than atexit, to register
579 destructors for local statics and global objects. */
581 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
583 /* Nonzero means make the default pedwarns warnings instead of errors.
584 The value of this flag is ignored if -pedantic is specified. */
588 /* Nonzero means to implement standard semantics for exception
589 specifications, calling unexpected if an exception is thrown that
590 doesn't match the specification. Zero means to treat them as
591 assertions and optimize accordingly, but not check them. */
593 int flag_enforce_eh_specs = 1;
595 /* The version of the C++ ABI in use. The following values are
598 0: The version of the ABI believed most conformant with the
599 C++ ABI specification. This ABI may change as bugs are
600 discovered and fixed. Therefore, 0 will not necessarily
601 indicate the same ABI in different versions of G++.
603 1: The version of the ABI first used in G++ 3.2.
605 Additional positive integers will be assigned as new versions of
606 the ABI become the default version of the ABI. */
608 int flag_abi_version = 1;
610 /* Nonzero means warn about things that will change when compiling
611 with an ABI-compliant compiler. */
615 /* Nonzero means warn about invalid uses of offsetof. */
617 int warn_invalid_offsetof = 1;
619 /* Nonzero means warn about implicit declarations. */
621 int warn_implicit = 1;
623 /* Nonzero means warn when all ctors or dtors are private, and the class
626 int warn_ctor_dtor_privacy = 0;
628 /* Nonzero means warn in function declared in derived class has the
629 same name as a virtual in the base class, but fails to match the
630 type signature of any virtual function in the base class. */
632 int warn_overloaded_virtual;
634 /* Nonzero means warn when declaring a class that has a non virtual
635 destructor, when it really ought to have a virtual one. */
639 /* Nonzero means warn when the compiler will reorder code. */
643 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
647 /* Nonzero means warn when we convert a pointer to member function
648 into a pointer to (void or function). */
650 int warn_pmf2ptr = 1;
652 /* Nonzero means warn about violation of some Effective C++ style rules. */
656 /* Nonzero means warn where overload resolution chooses a promotion from
657 unsigned to signed over a conversion to an unsigned of the same size. */
661 /* Nonzero means warn when an old-style cast is used. */
663 int warn_old_style_cast;
665 /* Nonzero means warn when non-templatized friend functions are
666 declared within a template */
668 int warn_nontemplate_friend = 1;
670 /* Nonzero means complain about deprecated features. */
672 int warn_deprecated = 1;
674 /* Maximum template instantiation depth. This limit is rather
675 arbitrary, but it exists to limit the time it takes to notice
676 infinite template instantiations. */
678 int max_tinst_depth = 500;
682 /* The elements of `ridpointers' are identifier nodes for the reserved
683 type names and storage classes. It is indexed by a RID_... value. */
686 tree (*make_fname_decl) (tree, int);
688 /* If non-NULL, the address of a language-specific function that takes
689 any action required right before expand_function_end is called. */
690 void (*lang_expand_function_end) (void);
692 /* Nonzero means the expression being parsed will never be evaluated.
693 This is a count, since unevaluated expressions can nest. */
696 /* Information about how a function name is generated. */
699 tree *const decl; /* pointer to the VAR_DECL. */
700 const unsigned rid; /* RID number for the identifier. */
701 const int pretty; /* How pretty is it? */
704 /* The three ways of getting then name of the current function. */
706 const struct fname_var_t fname_vars[] =
708 /* C99 compliant __func__, must be first. */
709 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
710 /* GCC __FUNCTION__ compliant. */
711 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
712 /* GCC __PRETTY_FUNCTION__ compliant. */
713 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
717 static int constant_fits_type_p (tree, tree);
719 /* Keep a stack of if statements. We record the number of compound
720 statements seen up to the if keyword, as well as the line number
721 and file of the if. If a potentially ambiguous else is seen, that
722 fact is recorded; the warning is issued when we can be sure that
723 the enclosing if statement does not have an else branch. */
732 static if_elt *if_stack;
734 /* Amount of space in the if statement stack. */
735 static int if_stack_space = 0;
738 static int if_stack_pointer = 0;
740 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
741 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
742 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
743 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
744 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
745 static tree handle_always_inline_attribute (tree *, tree, tree, int,
747 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
748 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
749 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
750 static tree handle_transparent_union_attribute (tree *, tree, tree,
752 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
753 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
754 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
755 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
756 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
757 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
758 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
759 static tree handle_visibility_attribute (tree *, tree, tree, int,
761 static tree handle_tls_model_attribute (tree *, tree, tree, int,
763 static tree handle_no_instrument_function_attribute (tree *, tree,
765 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
766 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
768 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
769 static tree handle_deprecated_attribute (tree *, tree, tree, int,
771 static tree handle_vector_size_attribute (tree *, tree, tree, int,
773 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
774 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
775 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
776 static tree vector_size_helper (tree, tree);
778 static void check_function_nonnull (tree, tree);
779 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
780 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
781 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
782 static int resort_field_decl_cmp (const void *, const void *);
784 /* Table of machine-independent attributes common to all C-like languages. */
785 const struct attribute_spec c_common_attribute_table[] =
787 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
788 { "packed", 0, 0, false, false, false,
789 handle_packed_attribute },
790 { "nocommon", 0, 0, true, false, false,
791 handle_nocommon_attribute },
792 { "common", 0, 0, true, false, false,
793 handle_common_attribute },
794 /* FIXME: logically, noreturn attributes should be listed as
795 "false, true, true" and apply to function types. But implementing this
796 would require all the places in the compiler that use TREE_THIS_VOLATILE
797 on a decl to identify non-returning functions to be located and fixed
798 to check the function type instead. */
799 { "noreturn", 0, 0, true, false, false,
800 handle_noreturn_attribute },
801 { "volatile", 0, 0, true, false, false,
802 handle_noreturn_attribute },
803 { "noinline", 0, 0, true, false, false,
804 handle_noinline_attribute },
805 { "always_inline", 0, 0, true, false, false,
806 handle_always_inline_attribute },
807 { "used", 0, 0, true, false, false,
808 handle_used_attribute },
809 { "unused", 0, 0, false, false, false,
810 handle_unused_attribute },
811 /* The same comments as for noreturn attributes apply to const ones. */
812 { "const", 0, 0, true, false, false,
813 handle_const_attribute },
814 { "transparent_union", 0, 0, false, false, false,
815 handle_transparent_union_attribute },
816 { "constructor", 0, 0, true, false, false,
817 handle_constructor_attribute },
818 { "destructor", 0, 0, true, false, false,
819 handle_destructor_attribute },
820 { "mode", 1, 1, false, true, false,
821 handle_mode_attribute },
822 { "section", 1, 1, true, false, false,
823 handle_section_attribute },
824 { "aligned", 0, 1, false, false, false,
825 handle_aligned_attribute },
826 { "weak", 0, 0, true, false, false,
827 handle_weak_attribute },
828 { "alias", 1, 1, true, false, false,
829 handle_alias_attribute },
830 { "no_instrument_function", 0, 0, true, false, false,
831 handle_no_instrument_function_attribute },
832 { "malloc", 0, 0, true, false, false,
833 handle_malloc_attribute },
834 { "no_stack_limit", 0, 0, true, false, false,
835 handle_no_limit_stack_attribute },
836 { "pure", 0, 0, true, false, false,
837 handle_pure_attribute },
838 { "deprecated", 0, 0, false, false, false,
839 handle_deprecated_attribute },
840 { "vector_size", 1, 1, false, true, false,
841 handle_vector_size_attribute },
842 { "visibility", 1, 1, true, false, false,
843 handle_visibility_attribute },
844 { "tls_model", 1, 1, true, false, false,
845 handle_tls_model_attribute },
846 { "nonnull", 0, -1, false, true, true,
847 handle_nonnull_attribute },
848 { "nothrow", 0, 0, true, false, false,
849 handle_nothrow_attribute },
850 { "may_alias", 0, 0, false, true, false, NULL },
851 { "cleanup", 1, 1, true, false, false,
852 handle_cleanup_attribute },
853 { NULL, 0, 0, false, false, false, NULL }
856 /* Give the specifications for the format attributes, used by C and all
859 const struct attribute_spec c_common_format_attribute_table[] =
861 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
862 { "format", 3, 3, false, true, true,
863 handle_format_attribute },
864 { "format_arg", 1, 1, false, true, true,
865 handle_format_arg_attribute },
866 { NULL, 0, 0, false, false, false, NULL }
869 /* Record the start of an if-then, and record the start of it
870 for ambiguous else detection.
872 COND is the condition for the if-then statement.
874 IF_STMT is the statement node that has already been created for
875 this if-then statement. It is created before parsing the
876 condition to keep line number information accurate. */
879 c_expand_start_cond (tree cond, int compstmt_count, tree if_stmt)
881 /* Make sure there is enough space on the stack. */
882 if (if_stack_space == 0)
885 if_stack = xmalloc (10 * sizeof (if_elt));
887 else if (if_stack_space == if_stack_pointer)
889 if_stack_space += 10;
890 if_stack = xrealloc (if_stack, if_stack_space * sizeof (if_elt));
893 IF_COND (if_stmt) = cond;
896 /* Record this if statement. */
897 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
898 if_stack[if_stack_pointer].locus = input_location;
899 if_stack[if_stack_pointer].needs_warning = 0;
900 if_stack[if_stack_pointer].if_stmt = if_stmt;
904 /* Called after the then-clause for an if-statement is processed. */
909 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
910 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
913 /* Record the end of an if-then. Optionally warn if a nested
914 if statement had an ambiguous else clause. */
917 c_expand_end_cond (void)
920 if (if_stack[if_stack_pointer].needs_warning)
921 warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
922 &if_stack[if_stack_pointer].locus);
923 last_expr_type = NULL_TREE;
926 /* Called between the then-clause and the else-clause
927 of an if-then-else. */
930 c_expand_start_else (void)
932 /* An ambiguous else warning must be generated for the enclosing if
933 statement, unless we see an else branch for that one, too. */
935 && if_stack_pointer > 1
936 && (if_stack[if_stack_pointer - 1].compstmt_count
937 == if_stack[if_stack_pointer - 2].compstmt_count))
938 if_stack[if_stack_pointer - 2].needs_warning = 1;
940 /* Even if a nested if statement had an else branch, it can't be
941 ambiguous if this one also has an else. So don't warn in that
942 case. Also don't warn for any if statements nested in this else. */
943 if_stack[if_stack_pointer - 1].needs_warning = 0;
944 if_stack[if_stack_pointer - 1].compstmt_count--;
947 /* Called after the else-clause for an if-statement is processed. */
952 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
953 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
956 /* Begin an if-statement. Returns a newly created IF_STMT if
959 Unlike the C++ front-end, we do not call add_stmt here; it is
960 probably safe to do so, but I am not very familiar with this
961 code so I am being extra careful not to change its behavior
962 beyond what is strictly necessary for correctness. */
965 c_begin_if_stmt (void)
968 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
972 /* Begin a while statement. Returns a newly created WHILE_STMT if
975 Unlike the C++ front-end, we do not call add_stmt here; it is
976 probably safe to do so, but I am not very familiar with this
977 code so I am being extra careful not to change its behavior
978 beyond what is strictly necessary for correctness. */
981 c_begin_while_stmt (void)
984 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
989 c_finish_while_stmt_cond (tree cond, tree while_stmt)
991 WHILE_COND (while_stmt) = cond;
994 /* Push current bindings for the function name VAR_DECLS. */
997 start_fname_decls (void)
1000 tree saved = NULL_TREE;
1002 for (ix = 0; fname_vars[ix].decl; ix++)
1004 tree decl = *fname_vars[ix].decl;
1008 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
1009 *fname_vars[ix].decl = NULL_TREE;
1012 if (saved || saved_function_name_decls)
1013 /* Normally they'll have been NULL, so only push if we've got a
1014 stack, or they are non-NULL. */
1015 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1016 saved_function_name_decls);
1019 /* Finish up the current bindings, adding them into the
1020 current function's statement tree. This is done by wrapping the
1021 function's body in a COMPOUND_STMT containing these decls too. This
1022 must be done _before_ finish_stmt_tree is called. If there is no
1023 current function, we must be at file scope and no statements are
1024 involved. Pop the previous bindings. */
1027 finish_fname_decls (void)
1030 tree body = NULL_TREE;
1031 tree stack = saved_function_name_decls;
1033 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1034 body = chainon (TREE_VALUE (stack), body);
1038 /* They were called into existence, so add to statement tree. Add
1039 the DECL_STMTs inside the outermost scope. */
1040 tree *p = &DECL_SAVED_TREE (current_function_decl);
1041 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1042 while (TREE_CODE (*p) != COMPOUND_STMT)
1043 p = &TREE_CHAIN (*p);
1044 p = &COMPOUND_BODY (*p);
1045 if (TREE_CODE (*p) == SCOPE_STMT)
1046 p = &TREE_CHAIN (*p);
1048 body = chainon (body, *p);
1052 for (ix = 0; fname_vars[ix].decl; ix++)
1053 *fname_vars[ix].decl = NULL_TREE;
1057 /* We had saved values, restore them. */
1060 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1062 tree decl = TREE_PURPOSE (saved);
1063 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1065 *fname_vars[ix].decl = decl;
1067 stack = TREE_CHAIN (stack);
1069 saved_function_name_decls = stack;
1072 /* Return the text name of the current function, suitably prettified
1076 fname_as_string (int pretty_p)
1078 const char *name = "top level";
1087 if (current_function_decl)
1088 name = (*lang_hooks.decl_printable_name) (current_function_decl, vrb);
1093 /* Return the VAR_DECL for a const char array naming the current
1094 function. If the VAR_DECL has not yet been created, create it
1095 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1096 ID is its name (unfortunately C and C++ hold the RID values of
1097 keywords in different places, so we can't derive RID from ID in
1098 this language independent code. */
1101 fname_decl (unsigned int rid, tree id)
1104 tree decl = NULL_TREE;
1106 for (ix = 0; fname_vars[ix].decl; ix++)
1107 if (fname_vars[ix].rid == rid)
1110 decl = *fname_vars[ix].decl;
1113 tree saved_last_tree = last_tree;
1114 /* If a tree is built here, it would normally have the lineno of
1115 the current statement. Later this tree will be moved to the
1116 beginning of the function and this line number will be wrong.
1117 To avoid this problem set the lineno to 0 here; that prevents
1118 it from appearing in the RTL. */
1119 int saved_lineno = input_line;
1122 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1123 if (last_tree != saved_last_tree)
1125 /* We created some statement tree for the decl. This belongs
1126 at the start of the function, so remove it now and reinsert
1127 it after the function is complete. */
1128 tree stmts = TREE_CHAIN (saved_last_tree);
1130 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1131 last_tree = saved_last_tree;
1132 saved_function_name_decls = tree_cons (decl, stmts,
1133 saved_function_name_decls);
1135 *fname_vars[ix].decl = decl;
1136 input_line = saved_lineno;
1138 if (!ix && !current_function_decl)
1139 pedwarn ("%H'%D' is not defined outside of function scope",
1140 &DECL_SOURCE_LOCATION (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 /* Return a data type that has machine mode MODE.
1811 If the mode is an integer,
1812 then UNSIGNEDP selects between signed and unsigned types. */
1815 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1817 if (mode == TYPE_MODE (integer_type_node))
1818 return unsignedp ? unsigned_type_node : integer_type_node;
1820 if (mode == TYPE_MODE (signed_char_type_node))
1821 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1823 if (mode == TYPE_MODE (short_integer_type_node))
1824 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1826 if (mode == TYPE_MODE (long_integer_type_node))
1827 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1829 if (mode == TYPE_MODE (long_long_integer_type_node))
1830 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1832 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1833 return unsignedp ? widest_unsigned_literal_type_node
1834 : widest_integer_literal_type_node;
1837 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1840 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1843 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1846 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1848 #if HOST_BITS_PER_WIDE_INT >= 64
1849 if (mode == TYPE_MODE (intTI_type_node))
1850 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1853 if (mode == TYPE_MODE (float_type_node))
1854 return float_type_node;
1856 if (mode == TYPE_MODE (double_type_node))
1857 return double_type_node;
1859 if (mode == TYPE_MODE (long_double_type_node))
1860 return long_double_type_node;
1862 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1863 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1865 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1866 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1871 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1873 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1875 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1877 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
1879 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1881 return unsignedp ? unsigned_V2HI_type_node : V2HI_type_node;
1883 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1885 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1887 return unsignedp ? unsigned_V1DI_type_node : V1DI_type_node;
1889 return V16SF_type_node;
1891 return V4SF_type_node;
1893 return V2SF_type_node;
1895 return V2DF_type_node;
1897 return V4DF_type_node;
1905 /* Return an unsigned type the same as TYPE in other respects. */
1907 c_common_unsigned_type (tree type)
1909 tree type1 = TYPE_MAIN_VARIANT (type);
1910 if (type1 == signed_char_type_node || type1 == char_type_node)
1911 return unsigned_char_type_node;
1912 if (type1 == integer_type_node)
1913 return unsigned_type_node;
1914 if (type1 == short_integer_type_node)
1915 return short_unsigned_type_node;
1916 if (type1 == long_integer_type_node)
1917 return long_unsigned_type_node;
1918 if (type1 == long_long_integer_type_node)
1919 return long_long_unsigned_type_node;
1920 if (type1 == widest_integer_literal_type_node)
1921 return widest_unsigned_literal_type_node;
1922 #if HOST_BITS_PER_WIDE_INT >= 64
1923 if (type1 == intTI_type_node)
1924 return unsigned_intTI_type_node;
1926 if (type1 == intDI_type_node)
1927 return unsigned_intDI_type_node;
1928 if (type1 == intSI_type_node)
1929 return unsigned_intSI_type_node;
1930 if (type1 == intHI_type_node)
1931 return unsigned_intHI_type_node;
1932 if (type1 == intQI_type_node)
1933 return unsigned_intQI_type_node;
1935 return c_common_signed_or_unsigned_type (1, type);
1938 /* Return a signed type the same as TYPE in other respects. */
1941 c_common_signed_type (tree type)
1943 tree type1 = TYPE_MAIN_VARIANT (type);
1944 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1945 return signed_char_type_node;
1946 if (type1 == unsigned_type_node)
1947 return integer_type_node;
1948 if (type1 == short_unsigned_type_node)
1949 return short_integer_type_node;
1950 if (type1 == long_unsigned_type_node)
1951 return long_integer_type_node;
1952 if (type1 == long_long_unsigned_type_node)
1953 return long_long_integer_type_node;
1954 if (type1 == widest_unsigned_literal_type_node)
1955 return widest_integer_literal_type_node;
1956 #if HOST_BITS_PER_WIDE_INT >= 64
1957 if (type1 == unsigned_intTI_type_node)
1958 return intTI_type_node;
1960 if (type1 == unsigned_intDI_type_node)
1961 return intDI_type_node;
1962 if (type1 == unsigned_intSI_type_node)
1963 return intSI_type_node;
1964 if (type1 == unsigned_intHI_type_node)
1965 return intHI_type_node;
1966 if (type1 == unsigned_intQI_type_node)
1967 return intQI_type_node;
1969 return c_common_signed_or_unsigned_type (0, type);
1972 /* Return a type the same as TYPE except unsigned or
1973 signed according to UNSIGNEDP. */
1976 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1978 if (! INTEGRAL_TYPE_P (type)
1979 || TREE_UNSIGNED (type) == unsignedp)
1982 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1983 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1984 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1985 return unsignedp ? unsigned_type_node : integer_type_node;
1986 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1987 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1988 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1989 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1990 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1991 return (unsignedp ? long_long_unsigned_type_node
1992 : long_long_integer_type_node);
1993 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
1994 return (unsignedp ? widest_unsigned_literal_type_node
1995 : widest_integer_literal_type_node);
1997 #if HOST_BITS_PER_WIDE_INT >= 64
1998 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
1999 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2001 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2002 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2003 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2004 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2005 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2006 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2007 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2008 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2013 /* The C version of the register_builtin_type langhook. */
2016 c_register_builtin_type (tree type, const char* name)
2020 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2021 DECL_ARTIFICIAL (decl) = 1;
2022 if (!TYPE_NAME (type))
2023 TYPE_NAME (type) = decl;
2028 /* Return the minimum number of bits needed to represent VALUE in a
2029 signed or unsigned type, UNSIGNEDP says which. */
2032 min_precision (tree value, int unsignedp)
2036 /* If the value is negative, compute its negative minus 1. The latter
2037 adjustment is because the absolute value of the largest negative value
2038 is one larger than the largest positive value. This is equivalent to
2039 a bit-wise negation, so use that operation instead. */
2041 if (tree_int_cst_sgn (value) < 0)
2042 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2044 /* Return the number of bits needed, taking into account the fact
2045 that we need one more bit for a signed than unsigned type. */
2047 if (integer_zerop (value))
2050 log = tree_floor_log2 (value);
2052 return log + 1 + ! unsignedp;
2055 /* Print an error message for invalid operands to arith operation
2056 CODE. NOP_EXPR is used as a special case (see
2057 c_common_truthvalue_conversion). */
2060 binary_op_error (enum tree_code code)
2067 error ("invalid truth-value expression");
2071 opname = "+"; break;
2073 opname = "-"; break;
2075 opname = "*"; break;
2077 opname = "max"; break;
2079 opname = "min"; break;
2081 opname = "=="; break;
2083 opname = "!="; break;
2085 opname = "<="; break;
2087 opname = ">="; break;
2089 opname = "<"; break;
2091 opname = ">"; break;
2093 opname = "<<"; break;
2095 opname = ">>"; break;
2096 case TRUNC_MOD_EXPR:
2097 case FLOOR_MOD_EXPR:
2098 opname = "%"; break;
2099 case TRUNC_DIV_EXPR:
2100 case FLOOR_DIV_EXPR:
2101 opname = "/"; break;
2103 opname = "&"; break;
2105 opname = "|"; break;
2106 case TRUTH_ANDIF_EXPR:
2107 opname = "&&"; break;
2108 case TRUTH_ORIF_EXPR:
2109 opname = "||"; break;
2111 opname = "^"; break;
2114 opname = "rotate"; break;
2116 opname = "unknown"; break;
2118 error ("invalid operands to binary %s", opname);
2121 /* Subroutine of build_binary_op, used for comparison operations.
2122 See if the operands have both been converted from subword integer types
2123 and, if so, perhaps change them both back to their original type.
2124 This function is also responsible for converting the two operands
2125 to the proper common type for comparison.
2127 The arguments of this function are all pointers to local variables
2128 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2129 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2131 If this function returns nonzero, it means that the comparison has
2132 a constant value. What this function returns is an expression for
2136 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2137 enum tree_code *rescode_ptr)
2140 tree op0 = *op0_ptr;
2141 tree op1 = *op1_ptr;
2142 int unsignedp0, unsignedp1;
2144 tree primop0, primop1;
2145 enum tree_code code = *rescode_ptr;
2147 /* Throw away any conversions to wider types
2148 already present in the operands. */
2150 primop0 = get_narrower (op0, &unsignedp0);
2151 primop1 = get_narrower (op1, &unsignedp1);
2153 /* Handle the case that OP0 does not *contain* a conversion
2154 but it *requires* conversion to FINAL_TYPE. */
2156 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2157 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2158 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2159 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2161 /* If one of the operands must be floated, we cannot optimize. */
2162 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2163 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2165 /* If first arg is constant, swap the args (changing operation
2166 so value is preserved), for canonicalization. Don't do this if
2167 the second arg is 0. */
2169 if (TREE_CONSTANT (primop0)
2170 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2173 int temi = unsignedp0;
2181 unsignedp0 = unsignedp1;
2204 *rescode_ptr = code;
2207 /* If comparing an integer against a constant more bits wide,
2208 maybe we can deduce a value of 1 or 0 independent of the data.
2209 Or else truncate the constant now
2210 rather than extend the variable at run time.
2212 This is only interesting if the constant is the wider arg.
2213 Also, it is not safe if the constant is unsigned and the
2214 variable arg is signed, since in this case the variable
2215 would be sign-extended and then regarded as unsigned.
2216 Our technique fails in this case because the lowest/highest
2217 possible unsigned results don't follow naturally from the
2218 lowest/highest possible values of the variable operand.
2219 For just EQ_EXPR and NE_EXPR there is another technique that
2220 could be used: see if the constant can be faithfully represented
2221 in the other operand's type, by truncating it and reextending it
2222 and see if that preserves the constant's value. */
2224 if (!real1 && !real2
2225 && TREE_CODE (primop1) == INTEGER_CST
2226 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2228 int min_gt, max_gt, min_lt, max_lt;
2229 tree maxval, minval;
2230 /* 1 if comparison is nominally unsigned. */
2231 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2234 type = c_common_signed_or_unsigned_type (unsignedp0,
2235 TREE_TYPE (primop0));
2237 /* In C, if TYPE is an enumeration, then we need to get its
2238 min/max values from it's underlying integral type, not the
2239 enumerated type itself. In C++, TYPE_MAX_VALUE and
2240 TYPE_MIN_VALUE have already been set correctly on the
2241 enumeration type. */
2242 if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
2243 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2245 maxval = TYPE_MAX_VALUE (type);
2246 minval = TYPE_MIN_VALUE (type);
2248 if (unsignedp && !unsignedp0)
2249 *restype_ptr = c_common_signed_type (*restype_ptr);
2251 if (TREE_TYPE (primop1) != *restype_ptr)
2252 primop1 = convert (*restype_ptr, primop1);
2253 if (type != *restype_ptr)
2255 minval = convert (*restype_ptr, minval);
2256 maxval = convert (*restype_ptr, maxval);
2259 if (unsignedp && unsignedp0)
2261 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2262 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2263 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2264 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2268 min_gt = INT_CST_LT (primop1, minval);
2269 max_gt = INT_CST_LT (primop1, maxval);
2270 min_lt = INT_CST_LT (minval, primop1);
2271 max_lt = INT_CST_LT (maxval, primop1);
2275 /* This used to be a switch, but Genix compiler can't handle that. */
2276 if (code == NE_EXPR)
2278 if (max_lt || min_gt)
2279 val = truthvalue_true_node;
2281 else if (code == EQ_EXPR)
2283 if (max_lt || min_gt)
2284 val = truthvalue_false_node;
2286 else if (code == LT_EXPR)
2289 val = truthvalue_true_node;
2291 val = truthvalue_false_node;
2293 else if (code == GT_EXPR)
2296 val = truthvalue_true_node;
2298 val = truthvalue_false_node;
2300 else if (code == LE_EXPR)
2303 val = truthvalue_true_node;
2305 val = truthvalue_false_node;
2307 else if (code == GE_EXPR)
2310 val = truthvalue_true_node;
2312 val = truthvalue_false_node;
2315 /* If primop0 was sign-extended and unsigned comparison specd,
2316 we did a signed comparison above using the signed type bounds.
2317 But the comparison we output must be unsigned.
2319 Also, for inequalities, VAL is no good; but if the signed
2320 comparison had *any* fixed result, it follows that the
2321 unsigned comparison just tests the sign in reverse
2322 (positive values are LE, negative ones GE).
2323 So we can generate an unsigned comparison
2324 against an extreme value of the signed type. */
2326 if (unsignedp && !unsignedp0)
2333 primop1 = TYPE_MIN_VALUE (type);
2339 primop1 = TYPE_MAX_VALUE (type);
2346 type = c_common_unsigned_type (type);
2349 if (TREE_CODE (primop0) != INTEGER_CST)
2351 if (val == truthvalue_false_node)
2352 warning ("comparison is always false due to limited range of data type");
2353 if (val == truthvalue_true_node)
2354 warning ("comparison is always true due to limited range of data type");
2359 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2360 if (TREE_SIDE_EFFECTS (primop0))
2361 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2365 /* Value is not predetermined, but do the comparison
2366 in the type of the operand that is not constant.
2367 TYPE is already properly set. */
2369 else if (real1 && real2
2370 && (TYPE_PRECISION (TREE_TYPE (primop0))
2371 == TYPE_PRECISION (TREE_TYPE (primop1))))
2372 type = TREE_TYPE (primop0);
2374 /* If args' natural types are both narrower than nominal type
2375 and both extend in the same manner, compare them
2376 in the type of the wider arg.
2377 Otherwise must actually extend both to the nominal
2378 common type lest different ways of extending
2380 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2382 else if (unsignedp0 == unsignedp1 && real1 == real2
2383 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2384 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2386 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2387 type = c_common_signed_or_unsigned_type (unsignedp0
2388 || TREE_UNSIGNED (*restype_ptr),
2390 /* Make sure shorter operand is extended the right way
2391 to match the longer operand. */
2393 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2394 TREE_TYPE (primop0)),
2397 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2398 TREE_TYPE (primop1)),
2403 /* Here we must do the comparison on the nominal type
2404 using the args exactly as we received them. */
2405 type = *restype_ptr;
2409 if (!real1 && !real2 && integer_zerop (primop1)
2410 && TREE_UNSIGNED (*restype_ptr))
2416 /* All unsigned values are >= 0, so we warn if extra warnings
2417 are requested. However, if OP0 is a constant that is
2418 >= 0, the signedness of the comparison isn't an issue,
2419 so suppress the warning. */
2420 if (extra_warnings && !in_system_header
2421 && ! (TREE_CODE (primop0) == INTEGER_CST
2422 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2424 warning ("comparison of unsigned expression >= 0 is always true");
2425 value = truthvalue_true_node;
2429 if (extra_warnings && !in_system_header
2430 && ! (TREE_CODE (primop0) == INTEGER_CST
2431 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2433 warning ("comparison of unsigned expression < 0 is always false");
2434 value = truthvalue_false_node;
2443 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2444 if (TREE_SIDE_EFFECTS (primop0))
2445 return build (COMPOUND_EXPR, TREE_TYPE (value),
2452 *op0_ptr = convert (type, primop0);
2453 *op1_ptr = convert (type, primop1);
2455 *restype_ptr = truthvalue_type_node;
2460 /* Return a tree for the sum or difference (RESULTCODE says which)
2461 of pointer PTROP and integer INTOP. */
2464 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2471 /* The result is a pointer of the same type that is being added. */
2473 tree result_type = TREE_TYPE (ptrop);
2475 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2477 if (pedantic || warn_pointer_arith)
2478 pedwarn ("pointer of type `void *' used in arithmetic");
2479 size_exp = integer_one_node;
2481 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2483 if (pedantic || warn_pointer_arith)
2484 pedwarn ("pointer to a function used in arithmetic");
2485 size_exp = integer_one_node;
2487 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2489 if (pedantic || warn_pointer_arith)
2490 pedwarn ("pointer to member function used in arithmetic");
2491 size_exp = integer_one_node;
2493 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2495 if (pedantic || warn_pointer_arith)
2496 pedwarn ("pointer to a member used in arithmetic");
2497 size_exp = integer_one_node;
2500 size_exp = size_in_bytes (TREE_TYPE (result_type));
2502 /* If what we are about to multiply by the size of the elements
2503 contains a constant term, apply distributive law
2504 and multiply that constant term separately.
2505 This helps produce common subexpressions. */
2507 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2508 && ! TREE_CONSTANT (intop)
2509 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2510 && TREE_CONSTANT (size_exp)
2511 /* If the constant comes from pointer subtraction,
2512 skip this optimization--it would cause an error. */
2513 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2514 /* If the constant is unsigned, and smaller than the pointer size,
2515 then we must skip this optimization. This is because it could cause
2516 an overflow error if the constant is negative but INTOP is not. */
2517 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2518 || (TYPE_PRECISION (TREE_TYPE (intop))
2519 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2521 enum tree_code subcode = resultcode;
2522 tree int_type = TREE_TYPE (intop);
2523 if (TREE_CODE (intop) == MINUS_EXPR)
2524 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2525 /* Convert both subexpression types to the type of intop,
2526 because weird cases involving pointer arithmetic
2527 can result in a sum or difference with different type args. */
2528 ptrop = build_binary_op (subcode, ptrop,
2529 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2530 intop = convert (int_type, TREE_OPERAND (intop, 0));
2533 /* Convert the integer argument to a type the same size as sizetype
2534 so the multiply won't overflow spuriously. */
2536 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2537 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2538 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2539 TREE_UNSIGNED (sizetype)), intop);
2541 /* Replace the integer argument with a suitable product by the object size.
2542 Do this multiplication as signed, then convert to the appropriate
2543 pointer type (actually unsigned integral). */
2545 intop = convert (result_type,
2546 build_binary_op (MULT_EXPR, intop,
2547 convert (TREE_TYPE (intop), size_exp), 1));
2549 /* Create the sum or difference. */
2551 result = build (resultcode, result_type, ptrop, intop);
2553 folded = fold (result);
2554 if (folded == result)
2555 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2559 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2560 or validate its data type for an `if' or `while' statement or ?..: exp.
2562 This preparation consists of taking the ordinary
2563 representation of an expression expr and producing a valid tree
2564 boolean expression describing whether expr is nonzero. We could
2565 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2566 but we optimize comparisons, &&, ||, and !.
2568 The resulting type should always be `truthvalue_type_node'. */
2571 c_common_truthvalue_conversion (tree expr)
2573 if (TREE_CODE (expr) == ERROR_MARK)
2576 #if 0 /* This appears to be wrong for C++. */
2577 /* These really should return error_mark_node after 2.4 is stable.
2578 But not all callers handle ERROR_MARK properly. */
2579 switch (TREE_CODE (TREE_TYPE (expr)))
2582 error ("struct type value used where scalar is required");
2583 return truthvalue_false_node;
2586 error ("union type value used where scalar is required");
2587 return truthvalue_false_node;
2590 error ("array type value used where scalar is required");
2591 return truthvalue_false_node;
2598 switch (TREE_CODE (expr))
2601 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2602 case TRUTH_ANDIF_EXPR:
2603 case TRUTH_ORIF_EXPR:
2604 case TRUTH_AND_EXPR:
2606 case TRUTH_XOR_EXPR:
2607 case TRUTH_NOT_EXPR:
2608 TREE_TYPE (expr) = truthvalue_type_node;
2615 return integer_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2618 return real_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2621 /* If we are taking the address of an external decl, it might be zero
2622 if it is weak, so we cannot optimize. */
2623 if (DECL_P (TREE_OPERAND (expr, 0))
2624 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2627 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2628 return build (COMPOUND_EXPR, truthvalue_type_node,
2629 TREE_OPERAND (expr, 0), truthvalue_true_node);
2631 return truthvalue_true_node;
2634 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2635 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2636 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2637 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2645 /* These don't change whether an object is nonzero or zero. */
2646 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2650 /* These don't change whether an object is zero or nonzero, but
2651 we can't ignore them if their second arg has side-effects. */
2652 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2653 return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1),
2654 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2656 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2659 /* Distribute the conversion into the arms of a COND_EXPR. */
2660 return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0),
2661 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2662 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2665 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2666 since that affects how `default_conversion' will behave. */
2667 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2668 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2670 /* Fall through.... */
2672 /* If this is widening the argument, we can ignore it. */
2673 if (TYPE_PRECISION (TREE_TYPE (expr))
2674 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2675 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2679 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2680 aren't guaranteed to the be same for modes that can represent
2681 infinity, since if x and y are both +infinity, or both
2682 -infinity, then x - y is not a number.
2684 Note that this transformation is safe when x or y is NaN.
2685 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2687 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2689 /* Fall through.... */
2691 /* This and MINUS_EXPR can be changed into a comparison of the
2693 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2694 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2695 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2696 TREE_OPERAND (expr, 1), 1);
2697 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2698 fold (build1 (NOP_EXPR,
2699 TREE_TYPE (TREE_OPERAND (expr, 0)),
2700 TREE_OPERAND (expr, 1))), 1);
2703 if (integer_onep (TREE_OPERAND (expr, 1))
2704 && TREE_TYPE (expr) != truthvalue_type_node)
2705 /* Using convert here would cause infinite recursion. */
2706 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2710 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2711 warning ("suggest parentheses around assignment used as truth value");
2718 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2720 tree t = save_expr (expr);
2721 return (build_binary_op
2722 ((TREE_SIDE_EFFECTS (expr)
2723 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2724 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2725 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2729 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2732 static tree builtin_function_2 (const char *, const char *, tree, tree,
2733 int, enum built_in_class, int, int,
2736 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2737 down to the element type of an array. */
2740 c_build_qualified_type (tree type, int type_quals)
2742 /* A restrict-qualified pointer type must be a pointer to object or
2743 incomplete type. Note that the use of POINTER_TYPE_P also allows
2744 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2745 the C++ front-end also use POINTER_TYPE for pointer-to-member
2746 values, so even though it should be illegal to use `restrict'
2747 with such an entity we don't flag that here. Thus, special case
2748 code for that case is required in the C++ front-end. */
2749 if ((type_quals & TYPE_QUAL_RESTRICT)
2750 && (!POINTER_TYPE_P (type)
2751 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2753 error ("invalid use of `restrict'");
2754 type_quals &= ~TYPE_QUAL_RESTRICT;
2757 if (TREE_CODE (type) == ARRAY_TYPE)
2758 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2760 TYPE_DOMAIN (type));
2761 return build_qualified_type (type, type_quals);
2764 /* Apply the TYPE_QUALS to the new DECL. */
2767 c_apply_type_quals_to_decl (int type_quals, tree decl)
2769 if ((type_quals & TYPE_QUAL_CONST)
2770 || (TREE_TYPE (decl)
2771 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2772 TREE_READONLY (decl) = 1;
2773 if (type_quals & TYPE_QUAL_VOLATILE)
2775 TREE_SIDE_EFFECTS (decl) = 1;
2776 TREE_THIS_VOLATILE (decl) = 1;
2778 if (type_quals & TYPE_QUAL_RESTRICT)
2780 if (!TREE_TYPE (decl)
2781 || !POINTER_TYPE_P (TREE_TYPE (decl))
2782 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2783 error ("invalid use of `restrict'");
2784 else if (flag_strict_aliasing)
2785 /* Indicate we need to make a unique alias set for this pointer.
2786 We can't do it here because it might be pointing to an
2788 DECL_POINTER_ALIAS_SET (decl) = -2;
2792 /* Return the typed-based alias set for T, which may be an expression
2793 or a type. Return -1 if we don't do anything special. */
2796 c_common_get_alias_set (tree t)
2800 /* Permit type-punning when accessing a union, provided the access
2801 is directly through the union. For example, this code does not
2802 permit taking the address of a union member and then storing
2803 through it. Even the type-punning allowed here is a GCC
2804 extension, albeit a common and useful one; the C standard says
2805 that such accesses have implementation-defined behavior. */
2807 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2808 u = TREE_OPERAND (u, 0))
2809 if (TREE_CODE (u) == COMPONENT_REF
2810 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2813 /* That's all the expressions we handle specially. */
2817 /* The C standard guarantees that any object may be accessed via an
2818 lvalue that has character type. */
2819 if (t == char_type_node
2820 || t == signed_char_type_node
2821 || t == unsigned_char_type_node)
2824 /* If it has the may_alias attribute, it can alias anything. */
2825 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2828 /* The C standard specifically allows aliasing between signed and
2829 unsigned variants of the same type. We treat the signed
2830 variant as canonical. */
2831 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2833 tree t1 = c_common_signed_type (t);
2835 /* t1 == t can happen for boolean nodes which are always unsigned. */
2837 return get_alias_set (t1);
2839 else if (POINTER_TYPE_P (t))
2843 /* Unfortunately, there is no canonical form of a pointer type.
2844 In particular, if we have `typedef int I', then `int *', and
2845 `I *' are different types. So, we have to pick a canonical
2846 representative. We do this below.
2848 Technically, this approach is actually more conservative that
2849 it needs to be. In particular, `const int *' and `int *'
2850 should be in different alias sets, according to the C and C++
2851 standard, since their types are not the same, and so,
2852 technically, an `int **' and `const int **' cannot point at
2855 But, the standard is wrong. In particular, this code is
2860 const int* const* cipp = &ipp;
2862 And, it doesn't make sense for that to be legal unless you
2863 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2864 the pointed-to types. This issue has been reported to the
2866 t1 = build_type_no_quals (t);
2868 return get_alias_set (t1);
2874 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2875 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2876 flag controls whether we should diagnose possibly ill-formed
2877 constructs or not. */
2879 c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2881 const char *op_name;
2883 enum tree_code type_code = TREE_CODE (type);
2885 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
2886 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2888 if (type_code == FUNCTION_TYPE)
2890 if (op == SIZEOF_EXPR)
2892 if (complain && (pedantic || warn_pointer_arith))
2893 pedwarn ("invalid application of `sizeof' to a function type");
2894 value = size_one_node;
2897 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2899 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2901 if (type_code == VOID_TYPE
2902 && complain && (pedantic || warn_pointer_arith))
2903 pedwarn ("invalid application of `%s' to a void type", op_name);
2904 value = size_one_node;
2906 else if (!COMPLETE_TYPE_P (type))
2909 error ("invalid application of `%s' to an incomplete type", op_name);
2910 value = size_zero_node;
2914 if (op == SIZEOF_EXPR)
2915 /* Convert in case a char is more than one unit. */
2916 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2917 size_int (TYPE_PRECISION (char_type_node)
2920 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2923 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2924 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2925 never happen. However, this node should really have type
2926 `size_t', which is just a typedef for an ordinary integer type. */
2927 value = fold (build1 (NOP_EXPR, size_type_node, value));
2928 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
2933 /* Implement the __alignof keyword: Return the minimum required
2934 alignment of EXPR, measured in bytes. For VAR_DECL's and
2935 FIELD_DECL's return DECL_ALIGN (which can be set from an
2936 "aligned" __attribute__ specification). */
2939 c_alignof_expr (tree expr)
2943 if (TREE_CODE (expr) == VAR_DECL)
2944 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2946 else if (TREE_CODE (expr) == COMPONENT_REF
2947 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2949 error ("`__alignof' applied to a bit-field");
2952 else if (TREE_CODE (expr) == COMPONENT_REF
2953 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2954 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2956 else if (TREE_CODE (expr) == INDIRECT_REF)
2958 tree t = TREE_OPERAND (expr, 0);
2960 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2962 while (TREE_CODE (t) == NOP_EXPR
2963 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2967 t = TREE_OPERAND (t, 0);
2968 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2969 if (thisalign > bestalign)
2970 best = t, bestalign = thisalign;
2972 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2975 return c_alignof (TREE_TYPE (expr));
2977 return fold (build1 (NOP_EXPR, size_type_node, t));
2980 /* Handle C and C++ default attributes. */
2982 enum built_in_attribute
2984 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2985 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2986 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2987 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2988 #include "builtin-attrs.def"
2989 #undef DEF_ATTR_NULL_TREE
2991 #undef DEF_ATTR_IDENT
2992 #undef DEF_ATTR_TREE_LIST
2996 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
2998 static void c_init_attributes (void);
3000 /* Build tree nodes and builtin functions common to both C and C++ language
3004 c_common_nodes_and_builtins (void)
3008 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3009 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3010 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3011 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3012 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3013 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3014 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3015 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3016 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3017 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3018 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3019 #include "builtin-types.def"
3020 #undef DEF_PRIMITIVE_TYPE
3021 #undef DEF_FUNCTION_TYPE_0
3022 #undef DEF_FUNCTION_TYPE_1
3023 #undef DEF_FUNCTION_TYPE_2
3024 #undef DEF_FUNCTION_TYPE_3
3025 #undef DEF_FUNCTION_TYPE_4
3026 #undef DEF_FUNCTION_TYPE_VAR_0
3027 #undef DEF_FUNCTION_TYPE_VAR_1
3028 #undef DEF_FUNCTION_TYPE_VAR_2
3029 #undef DEF_FUNCTION_TYPE_VAR_3
3030 #undef DEF_POINTER_TYPE
3034 typedef enum builtin_type builtin_type;
3036 tree builtin_types[(int) BT_LAST];
3037 int wchar_type_size;
3038 tree array_domain_type;
3039 tree va_list_ref_type_node;
3040 tree va_list_arg_type_node;
3042 /* Define `int' and `char' first so that dbx will output them first. */
3043 record_builtin_type (RID_INT, NULL, integer_type_node);
3044 record_builtin_type (RID_CHAR, "char", char_type_node);
3046 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3047 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3048 but not C. Are the conditionals here needed? */
3049 if (c_dialect_cxx ())
3050 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3051 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3052 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3053 record_builtin_type (RID_MAX, "long unsigned int",
3054 long_unsigned_type_node);
3055 if (c_dialect_cxx ())
3056 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3057 record_builtin_type (RID_MAX, "long long int",
3058 long_long_integer_type_node);
3059 record_builtin_type (RID_MAX, "long long unsigned int",
3060 long_long_unsigned_type_node);
3061 if (c_dialect_cxx ())
3062 record_builtin_type (RID_MAX, "long long unsigned",
3063 long_long_unsigned_type_node);
3064 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3065 record_builtin_type (RID_MAX, "short unsigned int",
3066 short_unsigned_type_node);
3067 if (c_dialect_cxx ())
3068 record_builtin_type (RID_MAX, "unsigned short",
3069 short_unsigned_type_node);
3071 /* Define both `signed char' and `unsigned char'. */
3072 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3073 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3075 /* These are types that c_common_type_for_size and
3076 c_common_type_for_mode use. */
3077 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3079 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3081 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3083 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3085 #if HOST_BITS_PER_WIDE_INT >= 64
3086 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3087 get_identifier ("__int128_t"),
3090 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3091 unsigned_intQI_type_node));
3092 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3093 unsigned_intHI_type_node));
3094 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3095 unsigned_intSI_type_node));
3096 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3097 unsigned_intDI_type_node));
3098 #if HOST_BITS_PER_WIDE_INT >= 64
3099 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3100 get_identifier ("__uint128_t"),
3101 unsigned_intTI_type_node));
3104 /* Create the widest literal types. */
3105 widest_integer_literal_type_node
3106 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3107 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3108 widest_integer_literal_type_node));
3110 widest_unsigned_literal_type_node
3111 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3112 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3113 widest_unsigned_literal_type_node));
3115 /* `unsigned long' is the standard type for sizeof.
3116 Note that stddef.h uses `unsigned long',
3117 and this must agree, even if long and int are the same size. */
3119 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3120 signed_size_type_node = c_common_signed_type (size_type_node);
3121 set_sizetype (size_type_node);
3123 build_common_tree_nodes_2 (flag_short_double);
3125 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3126 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3127 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3129 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3130 get_identifier ("complex int"),
3131 complex_integer_type_node));
3132 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3133 get_identifier ("complex float"),
3134 complex_float_type_node));
3135 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3136 get_identifier ("complex double"),
3137 complex_double_type_node));
3138 (*lang_hooks.decls.pushdecl)
3139 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3140 complex_long_double_type_node));
3142 /* Types which are common to the fortran compiler and libf2c. When
3143 changing these, you also need to be concerned with f/com.h. */
3145 if (TYPE_PRECISION (float_type_node)
3146 == TYPE_PRECISION (long_integer_type_node))
3148 g77_integer_type_node = long_integer_type_node;
3149 g77_uinteger_type_node = long_unsigned_type_node;
3151 else if (TYPE_PRECISION (float_type_node)
3152 == TYPE_PRECISION (integer_type_node))
3154 g77_integer_type_node = integer_type_node;
3155 g77_uinteger_type_node = unsigned_type_node;
3158 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3160 if (g77_integer_type_node != NULL_TREE)
3162 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3163 get_identifier ("__g77_integer"),
3164 g77_integer_type_node));
3165 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3166 get_identifier ("__g77_uinteger"),
3167 g77_uinteger_type_node));
3170 if (TYPE_PRECISION (float_type_node) * 2
3171 == TYPE_PRECISION (long_integer_type_node))
3173 g77_longint_type_node = long_integer_type_node;
3174 g77_ulongint_type_node = long_unsigned_type_node;
3176 else if (TYPE_PRECISION (float_type_node) * 2
3177 == TYPE_PRECISION (long_long_integer_type_node))
3179 g77_longint_type_node = long_long_integer_type_node;
3180 g77_ulongint_type_node = long_long_unsigned_type_node;
3183 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3185 if (g77_longint_type_node != NULL_TREE)
3187 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3188 get_identifier ("__g77_longint"),
3189 g77_longint_type_node));
3190 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3191 get_identifier ("__g77_ulongint"),
3192 g77_ulongint_type_node));
3195 record_builtin_type (RID_VOID, NULL, void_type_node);
3197 void_zero_node = build_int_2 (0, 0);
3198 TREE_TYPE (void_zero_node) = void_type_node;
3200 void_list_node = build_void_list_node ();
3202 /* Make a type to be the domain of a few array types
3203 whose domains don't really matter.
3204 200 is small enough that it always fits in size_t
3205 and large enough that it can hold most function names for the
3206 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3207 array_domain_type = build_index_type (size_int (200));
3209 /* Make a type for arrays of characters.
3210 With luck nothing will ever really depend on the length of this
3212 char_array_type_node
3213 = build_array_type (char_type_node, array_domain_type);
3215 /* Likewise for arrays of ints. */
3217 = build_array_type (integer_type_node, array_domain_type);
3219 string_type_node = build_pointer_type (char_type_node);
3220 const_string_type_node
3221 = build_pointer_type (build_qualified_type
3222 (char_type_node, TYPE_QUAL_CONST));
3224 /* This is special for C++ so functions can be overloaded. */
3225 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3226 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3227 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3228 if (c_dialect_cxx ())
3230 if (TREE_UNSIGNED (wchar_type_node))
3231 wchar_type_node = make_unsigned_type (wchar_type_size);
3233 wchar_type_node = make_signed_type (wchar_type_size);
3234 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3238 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3239 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3242 /* This is for wide string constants. */
3243 wchar_array_type_node
3244 = build_array_type (wchar_type_node, array_domain_type);
3247 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3250 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3252 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3254 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3256 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3257 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3259 (*lang_hooks.decls.pushdecl)
3260 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3261 va_list_type_node));
3263 (*lang_hooks.decls.pushdecl)
3264 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3265 ptrdiff_type_node));
3267 (*lang_hooks.decls.pushdecl)
3268 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3271 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3273 va_list_arg_type_node = va_list_ref_type_node =
3274 build_pointer_type (TREE_TYPE (va_list_type_node));
3278 va_list_arg_type_node = va_list_type_node;
3279 va_list_ref_type_node = build_reference_type (va_list_type_node);
3282 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3283 builtin_types[(int) ENUM] = VALUE;
3284 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3285 builtin_types[(int) ENUM] \
3286 = build_function_type (builtin_types[(int) RETURN], \
3288 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3289 builtin_types[(int) ENUM] \
3290 = build_function_type (builtin_types[(int) RETURN], \
3291 tree_cons (NULL_TREE, \
3292 builtin_types[(int) ARG1], \
3294 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3295 builtin_types[(int) ENUM] \
3296 = build_function_type \
3297 (builtin_types[(int) RETURN], \
3298 tree_cons (NULL_TREE, \
3299 builtin_types[(int) ARG1], \
3300 tree_cons (NULL_TREE, \
3301 builtin_types[(int) ARG2], \
3303 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3304 builtin_types[(int) ENUM] \
3305 = build_function_type \
3306 (builtin_types[(int) RETURN], \
3307 tree_cons (NULL_TREE, \
3308 builtin_types[(int) ARG1], \
3309 tree_cons (NULL_TREE, \
3310 builtin_types[(int) ARG2], \
3311 tree_cons (NULL_TREE, \
3312 builtin_types[(int) ARG3], \
3314 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3315 builtin_types[(int) ENUM] \
3316 = build_function_type \
3317 (builtin_types[(int) RETURN], \
3318 tree_cons (NULL_TREE, \
3319 builtin_types[(int) ARG1], \
3320 tree_cons (NULL_TREE, \
3321 builtin_types[(int) ARG2], \
3324 builtin_types[(int) ARG3], \
3325 tree_cons (NULL_TREE, \
3326 builtin_types[(int) ARG4], \
3327 void_list_node)))));
3328 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3329 builtin_types[(int) ENUM] \
3330 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3331 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3332 builtin_types[(int) ENUM] \
3333 = build_function_type (builtin_types[(int) RETURN], \
3334 tree_cons (NULL_TREE, \
3335 builtin_types[(int) ARG1], \
3338 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3339 builtin_types[(int) ENUM] \
3340 = build_function_type \
3341 (builtin_types[(int) RETURN], \
3342 tree_cons (NULL_TREE, \
3343 builtin_types[(int) ARG1], \
3344 tree_cons (NULL_TREE, \
3345 builtin_types[(int) ARG2], \
3348 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3349 builtin_types[(int) ENUM] \
3350 = build_function_type \
3351 (builtin_types[(int) RETURN], \
3352 tree_cons (NULL_TREE, \
3353 builtin_types[(int) ARG1], \
3354 tree_cons (NULL_TREE, \
3355 builtin_types[(int) ARG2], \
3356 tree_cons (NULL_TREE, \
3357 builtin_types[(int) ARG3], \
3360 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3361 builtin_types[(int) ENUM] \
3362 = build_pointer_type (builtin_types[(int) TYPE]);
3363 #include "builtin-types.def"
3364 #undef DEF_PRIMITIVE_TYPE
3365 #undef DEF_FUNCTION_TYPE_1
3366 #undef DEF_FUNCTION_TYPE_2
3367 #undef DEF_FUNCTION_TYPE_3
3368 #undef DEF_FUNCTION_TYPE_4
3369 #undef DEF_FUNCTION_TYPE_VAR_0
3370 #undef DEF_FUNCTION_TYPE_VAR_1
3371 #undef DEF_FUNCTION_TYPE_VAR_2
3372 #undef DEF_FUNCTION_TYPE_VAR_3
3373 #undef DEF_POINTER_TYPE
3375 c_init_attributes ();
3377 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3378 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3383 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3387 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3390 ? (NAME + strlen ("__builtin_")) \
3392 built_in_attributes[(int) ATTRS]); \
3394 decl = builtin_function_2 (NAME, \
3395 NAME + strlen ("__builtin_"), \
3396 builtin_types[TYPE], \
3397 builtin_types[LIBTYPE], \
3402 built_in_attributes[(int) ATTRS]); \
3404 built_in_decls[(int) ENUM] = decl; \
3406 implicit_built_in_decls[(int) ENUM] = decl; \
3408 #include "builtins.def"
3411 (*targetm.init_builtins) ();
3413 main_identifier_node = get_identifier ("main");
3417 build_va_arg (tree expr, tree type)
3419 return build1 (VA_ARG_EXPR, type, expr);
3423 /* Linked list of disabled built-in functions. */
3425 typedef struct disabled_builtin
3428 struct disabled_builtin *next;
3430 static disabled_builtin *disabled_builtins = NULL;
3432 static bool builtin_function_disabled_p (const char *);
3434 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3435 begins with "__builtin_", give an error. */
3438 disable_builtin_function (const char *name)
3440 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3441 error ("cannot disable built-in function `%s'", name);
3444 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3446 new->next = disabled_builtins;
3447 disabled_builtins = new;
3452 /* Return true if the built-in function NAME has been disabled, false
3456 builtin_function_disabled_p (const char *name)
3458 disabled_builtin *p;
3459 for (p = disabled_builtins; p != NULL; p = p->next)
3461 if (strcmp (name, p->name) == 0)
3468 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3469 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3470 of these may be NULL (though both being NULL is useless).
3471 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3472 TYPE is the type of the function with the ordinary name. These
3473 may differ if the ordinary name is declared with a looser type to avoid
3474 conflicts with headers. FUNCTION_CODE and CLASS are as for
3475 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3476 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3477 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3478 ATTRS is the tree list representing the builtin's function attributes.
3479 Returns the declaration of BUILTIN_NAME, if any, otherwise
3480 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3481 or if NONANSI_P and flag_no_nonansi_builtin. */
3484 builtin_function_2 (const char *builtin_name, const char *name,
3485 tree builtin_type, tree type, int function_code,
3486 enum built_in_class class, int library_name_p,
3487 int nonansi_p, tree attrs)
3489 tree bdecl = NULL_TREE;
3490 tree decl = NULL_TREE;
3492 if (builtin_name != 0)
3493 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3494 class, library_name_p ? name : NULL, attrs);
3496 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3497 && !(nonansi_p && flag_no_nonansi_builtin))
3498 decl = builtin_function (name, type, function_code, class, NULL, attrs);
3500 return (bdecl != 0 ? bdecl : decl);
3503 /* Nonzero if the type T promotes to int. This is (nearly) the
3504 integral promotions defined in ISO C99 6.3.1.1/2. */
3507 c_promoting_integer_type_p (tree t)
3509 switch (TREE_CODE (t))
3512 return (TYPE_MAIN_VARIANT (t) == char_type_node
3513 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3514 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3515 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3516 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3517 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3520 /* ??? Technically all enumerations not larger than an int
3521 promote to an int. But this is used along code paths
3522 that only want to notice a size change. */
3523 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3533 /* Return 1 if PARMS specifies a fixed number of parameters
3534 and none of their types is affected by default promotions. */
3537 self_promoting_args_p (tree parms)
3540 for (t = parms; t; t = TREE_CHAIN (t))
3542 tree type = TREE_VALUE (t);
3544 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3550 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3553 if (c_promoting_integer_type_p (type))
3559 /* Recursively examines the array elements of TYPE, until a non-array
3560 element type is found. */
3563 strip_array_types (tree type)
3565 while (TREE_CODE (type) == ARRAY_TYPE)
3566 type = TREE_TYPE (type);
3571 /* Recursively remove any '*' or '&' operator from TYPE. */
3573 strip_pointer_operator (tree t)
3575 while (POINTER_TYPE_P (t))
3580 static tree expand_unordered_cmp (tree, tree, enum tree_code, enum tree_code);
3582 /* Expand a call to an unordered comparison function such as
3583 __builtin_isgreater(). FUNCTION is the function's declaration and
3584 PARAMS a list of the values passed. For __builtin_isunordered(),
3585 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3586 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3587 that give the opposite of the desired result. UNORDERED_CODE is
3588 used for modes that can hold NaNs and ORDERED_CODE is used for the
3592 expand_unordered_cmp (tree function, tree params,
3593 enum tree_code unordered_code,
3594 enum tree_code ordered_code)
3596 tree arg0, arg1, type;
3597 enum tree_code code0, code1;
3599 /* Check that we have exactly two arguments. */
3600 if (params == 0 || TREE_CHAIN (params) == 0)
3602 error ("too few arguments to function `%s'",
3603 IDENTIFIER_POINTER (DECL_NAME (function)));
3604 return error_mark_node;
3606 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3608 error ("too many arguments to function `%s'",
3609 IDENTIFIER_POINTER (DECL_NAME (function)));
3610 return error_mark_node;
3613 arg0 = TREE_VALUE (params);
3614 arg1 = TREE_VALUE (TREE_CHAIN (params));
3616 code0 = TREE_CODE (TREE_TYPE (arg0));
3617 code1 = TREE_CODE (TREE_TYPE (arg1));
3619 /* Make sure that the arguments have a common type of REAL. */
3621 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3622 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3623 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3625 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3627 error ("non-floating-point argument to function `%s'",
3628 IDENTIFIER_POINTER (DECL_NAME (function)));
3629 return error_mark_node;
3632 if (unordered_code == UNORDERED_EXPR)
3634 if (MODE_HAS_NANS (TYPE_MODE (type)))
3635 return build_binary_op (unordered_code,
3636 convert (type, arg0),
3637 convert (type, arg1),
3640 return integer_zero_node;
3643 return build_unary_op (TRUTH_NOT_EXPR,
3644 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3647 convert (type, arg0),
3648 convert (type, arg1),
3654 /* Recognize certain built-in functions so we can make tree-codes
3655 other than CALL_EXPR. We do this when it enables fold-const.c
3656 to do something useful. */
3657 /* ??? By rights this should go in builtins.c, but only C and C++
3658 implement build_{binary,unary}_op. Not exactly sure what bits
3659 of functionality are actually needed from those functions, or
3660 where the similar functionality exists in the other front ends. */
3663 expand_tree_builtin (tree function, tree params, tree coerced_params)
3665 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3668 switch (DECL_FUNCTION_CODE (function))
3672 case BUILT_IN_LLABS:
3673 case BUILT_IN_IMAXABS:
3675 case BUILT_IN_FABSL:
3676 case BUILT_IN_FABSF:
3677 if (coerced_params == 0)
3678 return integer_zero_node;
3679 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3682 case BUILT_IN_CONJF:
3683 case BUILT_IN_CONJL:
3684 if (coerced_params == 0)
3685 return integer_zero_node;
3686 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3688 case BUILT_IN_CREAL:
3689 case BUILT_IN_CREALF:
3690 case BUILT_IN_CREALL:
3691 if (coerced_params == 0)
3692 return integer_zero_node;
3693 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3695 case BUILT_IN_CIMAG:
3696 case BUILT_IN_CIMAGF:
3697 case BUILT_IN_CIMAGL:
3698 if (coerced_params == 0)
3699 return integer_zero_node;
3700 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3702 case BUILT_IN_ISGREATER:
3703 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3705 case BUILT_IN_ISGREATEREQUAL:
3706 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3708 case BUILT_IN_ISLESS:
3709 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3711 case BUILT_IN_ISLESSEQUAL:
3712 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3714 case BUILT_IN_ISLESSGREATER:
3715 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3717 case BUILT_IN_ISUNORDERED:
3718 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3727 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3728 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3729 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3730 value, the traversal is aborted, and the value returned by FUNC is
3731 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3732 the node being visited are not walked.
3734 We don't need a without_duplicates variant of this one because the
3735 statement tree is a tree, not a graph. */
3738 walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
3740 enum tree_code code;
3745 #define WALK_SUBTREE(NODE) \
3748 result = walk_stmt_tree (&(NODE), func, data); \
3754 /* Skip empty subtrees. */
3758 /* Skip subtrees below non-statement nodes. */
3759 if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
3762 /* Call the function. */
3764 result = (*func) (tp, &walk_subtrees, data);
3766 /* If we found something, return it. */
3770 /* FUNC may have modified the tree, recheck that we're looking at a
3772 code = TREE_CODE (*tp);
3773 if (!STATEMENT_CODE_P (code))
3776 /* Visit the subtrees unless FUNC decided that there was nothing
3777 interesting below this point in the tree. */
3780 /* Walk over all the sub-trees of this operand. Statement nodes
3781 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3782 len = TREE_CODE_LENGTH (code);
3784 /* Go through the subtrees. We need to do this in forward order so
3785 that the scope of a FOR_EXPR is handled properly. */
3786 for (i = 0; i < len; ++i)
3787 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3790 /* Finally visit the chain. This can be tail-recursion optimized if
3791 we write it this way. */
3792 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3797 /* Used to compare case labels. K1 and K2 are actually tree nodes
3798 representing case labels, or NULL_TREE for a `default' label.
3799 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3800 K2, and 0 if K1 and K2 are equal. */
3803 case_compare (splay_tree_key k1, splay_tree_key k2)
3805 /* Consider a NULL key (such as arises with a `default' label) to be
3806 smaller than anything else. */
3812 return tree_int_cst_compare ((tree) k1, (tree) k2);
3815 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3816 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3817 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3818 case label was declared using the usual C/C++ syntax, rather than
3819 the GNU case range extension. CASES is a tree containing all the
3820 case ranges processed so far; COND is the condition for the
3821 switch-statement itself. Returns the CASE_LABEL created, or
3822 ERROR_MARK_NODE if no CASE_LABEL is created. */
3825 c_add_case_label (splay_tree cases, tree cond, tree low_value,
3831 splay_tree_node node;
3833 /* Create the LABEL_DECL itself. */
3834 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3835 DECL_CONTEXT (label) = current_function_decl;
3837 /* If there was an error processing the switch condition, bail now
3838 before we get more confused. */
3839 if (!cond || cond == error_mark_node)
3841 /* Add a label anyhow so that the back-end doesn't think that
3842 the beginning of the switch is unreachable. */
3844 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3845 return error_mark_node;
3848 if ((low_value && TREE_TYPE (low_value)
3849 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3850 || (high_value && TREE_TYPE (high_value)
3851 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3852 error ("pointers are not permitted as case values");
3854 /* Case ranges are a GNU extension. */
3855 if (high_value && pedantic)
3856 pedwarn ("range expressions in switch statements are non-standard");
3858 type = TREE_TYPE (cond);
3861 low_value = check_case_value (low_value);
3862 low_value = convert_and_check (type, low_value);
3866 high_value = check_case_value (high_value);
3867 high_value = convert_and_check (type, high_value);
3870 /* If an error has occurred, bail out now. */
3871 if (low_value == error_mark_node || high_value == error_mark_node)
3874 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3875 return error_mark_node;
3878 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3879 really a case range, even though it was written that way. Remove
3880 the HIGH_VALUE to simplify later processing. */
3881 if (tree_int_cst_equal (low_value, high_value))
3882 high_value = NULL_TREE;
3883 if (low_value && high_value
3884 && !tree_int_cst_lt (low_value, high_value))
3885 warning ("empty range specified");
3887 /* Look up the LOW_VALUE in the table of case labels we already
3889 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3890 /* If there was not an exact match, check for overlapping ranges.
3891 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3892 that's a `default' label and the only overlap is an exact match. */
3893 if (!node && (low_value || high_value))
3895 splay_tree_node low_bound;
3896 splay_tree_node high_bound;
3898 /* Even though there wasn't an exact match, there might be an
3899 overlap between this case range and another case range.
3900 Since we've (inductively) not allowed any overlapping case
3901 ranges, we simply need to find the greatest low case label
3902 that is smaller that LOW_VALUE, and the smallest low case
3903 label that is greater than LOW_VALUE. If there is an overlap
3904 it will occur in one of these two ranges. */
3905 low_bound = splay_tree_predecessor (cases,
3906 (splay_tree_key) low_value);
3907 high_bound = splay_tree_successor (cases,
3908 (splay_tree_key) low_value);
3910 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3911 the LOW_VALUE, so there is no need to check unless the
3912 LOW_BOUND is in fact itself a case range. */
3914 && CASE_HIGH ((tree) low_bound->value)
3915 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3918 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3919 range is bigger than the low end of the current range, so we
3920 are only interested if the current range is a real range, and
3921 not an ordinary case label. */
3924 && (tree_int_cst_compare ((tree) high_bound->key,
3929 /* If there was an overlap, issue an error. */
3932 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3936 error ("duplicate (or overlapping) case value");
3937 error ("%Hthis is the first entry overlapping that value",
3938 &DECL_SOURCE_LOCATION (duplicate));
3942 error ("duplicate case value") ;
3943 error ("%Hpreviously used here", &DECL_SOURCE_LOCATION (duplicate));
3947 error ("multiple default labels in one switch");
3948 error ("%Hthis is the first default label",
3949 &DECL_SOURCE_LOCATION (duplicate));
3952 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3955 /* Add a CASE_LABEL to the statement-tree. */
3956 case_label = add_stmt (build_case_label (low_value, high_value, label));
3957 /* Register this case label in the splay tree. */
3958 splay_tree_insert (cases,
3959 (splay_tree_key) low_value,
3960 (splay_tree_value) case_label);
3965 /* Finish an expression taking the address of LABEL (an
3966 IDENTIFIER_NODE). Returns an expression for the address. */
3969 finish_label_address_expr (tree label)
3974 pedwarn ("taking the address of a label is non-standard");
3976 if (label == error_mark_node)
3977 return error_mark_node;
3979 label = lookup_label (label);
3980 if (label == NULL_TREE)
3981 result = null_pointer_node;
3984 TREE_USED (label) = 1;
3985 result = build1 (ADDR_EXPR, ptr_type_node, label);
3986 TREE_CONSTANT (result) = 1;
3987 /* The current function in not necessarily uninlinable.
3988 Computed gotos are incompatible with inlining, but the value
3989 here could be used only in a diagnostic, for example. */
3995 /* Hook used by expand_expr to expand language-specific tree codes. */
3998 c_expand_expr (tree exp, rtx target, enum machine_mode tmode, int modifier)
3999 /* Actually enum_modifier. */
4001 switch (TREE_CODE (exp))
4007 bool preserve_result = false;
4008 bool return_target = false;
4010 /* Since expand_expr_stmt calls free_temp_slots after every
4011 expression statement, we must call push_temp_slots here.
4012 Otherwise, any temporaries in use now would be considered
4013 out-of-scope after the first EXPR_STMT from within the
4016 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4018 /* If we want the result of this expression, find the last
4019 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4020 if (target != const0_rtx
4021 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4022 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4024 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4025 tree last = TREE_CHAIN (expr);
4027 while (TREE_CHAIN (last))
4030 last = TREE_CHAIN (last);
4033 if (TREE_CODE (last) == SCOPE_STMT
4034 && TREE_CODE (expr) == EXPR_STMT)
4036 if (target && TREE_CODE (EXPR_STMT_EXPR (expr)) == VAR_DECL
4037 && DECL_RTL_IF_SET (EXPR_STMT_EXPR (expr)) == target)
4038 /* If the last expression is a variable whose RTL is the
4039 same as our target, just return the target; if it
4040 isn't valid expanding the decl would produce different
4041 RTL, and store_expr would try to do a copy. */
4042 return_target = true;
4045 /* Otherwise, note that we want the value from the last
4047 TREE_ADDRESSABLE (expr) = 1;
4048 preserve_result = true;
4053 expand_stmt (STMT_EXPR_STMT (exp));
4054 expand_end_stmt_expr (rtl_expr);
4056 result = expand_expr (rtl_expr, target, tmode, modifier);
4059 else if (preserve_result && GET_CODE (result) == MEM)
4061 if (GET_MODE (result) != BLKmode)
4062 result = copy_to_reg (result);
4064 preserve_temp_slots (result);
4067 /* If the statment-expression does not have a scope, then the
4068 new temporaries we created within it must live beyond the
4069 statement-expression. */
4070 if (STMT_EXPR_NO_SCOPE (exp))
4071 preserve_temp_slots (NULL_RTX);
4078 case COMPOUND_LITERAL_EXPR:
4080 /* Initialize the anonymous variable declared in the compound
4081 literal, then return the variable. */
4082 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4083 emit_local_var (decl);
4084 return expand_expr (decl, target, tmode, modifier);
4095 /* Hook used by safe_from_p to handle language-specific tree codes. */
4098 c_safe_from_p (rtx target, tree exp)
4100 /* We can see statements here when processing the body of a
4101 statement-expression. For a declaration statement declaring a
4102 variable, look at the variable's initializer. */
4103 if (TREE_CODE (exp) == DECL_STMT)
4105 tree decl = DECL_STMT_DECL (exp);
4107 if (TREE_CODE (decl) == VAR_DECL
4108 && DECL_INITIAL (decl)
4109 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4113 /* For any statement, we must follow the statement-chain. */
4114 if (STATEMENT_CODE_P (TREE_CODE (exp)) && TREE_CHAIN (exp))
4115 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4117 /* Assume everything else is safe. */
4121 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4124 c_common_unsafe_for_reeval (tree exp)
4126 /* Statement expressions may not be reevaluated, likewise compound
4128 if (TREE_CODE (exp) == STMT_EXPR
4129 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4132 /* Walk all other expressions. */
4136 /* Hook used by staticp to handle language-specific tree codes. */
4139 c_staticp (tree exp)
4141 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4142 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4148 /* Given a boolean expression ARG, return a tree representing an increment
4149 or decrement (as indicated by CODE) of ARG. The front end must check for
4150 invalid cases (e.g., decrement in C++). */
4152 boolean_increment (enum tree_code code, tree arg)
4155 tree true_res = boolean_true_node;
4157 arg = stabilize_reference (arg);
4160 case PREINCREMENT_EXPR:
4161 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4163 case POSTINCREMENT_EXPR:
4164 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4165 arg = save_expr (arg);
4166 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4167 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4169 case PREDECREMENT_EXPR:
4170 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4172 case POSTDECREMENT_EXPR:
4173 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4174 arg = save_expr (arg);
4175 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4176 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4181 TREE_SIDE_EFFECTS (val) = 1;
4185 /* Built-in macros for stddef.h, that require macros defined in this
4188 c_stddef_cpp_builtins(void)
4190 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4191 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4192 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4193 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4197 c_init_attributes (void)
4199 /* Fill in the built_in_attributes array. */
4200 #define DEF_ATTR_NULL_TREE(ENUM) \
4201 built_in_attributes[(int) ENUM] = NULL_TREE;
4202 #define DEF_ATTR_INT(ENUM, VALUE) \
4203 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4204 #define DEF_ATTR_IDENT(ENUM, STRING) \
4205 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4206 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4207 built_in_attributes[(int) ENUM] \
4208 = tree_cons (built_in_attributes[(int) PURPOSE], \
4209 built_in_attributes[(int) VALUE], \
4210 built_in_attributes[(int) CHAIN]);
4211 #include "builtin-attrs.def"
4212 #undef DEF_ATTR_NULL_TREE
4214 #undef DEF_ATTR_IDENT
4215 #undef DEF_ATTR_TREE_LIST
4218 /* Output a -Wshadow warning MSGCODE about NAME, and give the location
4219 of the previous declaration DECL. */
4221 shadow_warning (enum sw_kind msgcode, const char *name, tree decl)
4223 static const char *const msgs[] = {
4224 /* SW_PARAM */ N_("declaration of \"%s\" shadows a parameter"),
4225 /* SW_LOCAL */ N_("declaration of \"%s\" shadows a previous local"),
4226 /* SW_GLOBAL */ N_("declaration of \"%s\" shadows a global declaration")
4229 warning (msgs[msgcode], name);
4230 warning ("%Hshadowed declaration is here", &DECL_SOURCE_LOCATION (decl));
4233 /* Attribute handlers common to C front ends. */
4235 /* Handle a "packed" attribute; arguments as in
4236 struct attribute_spec.handler. */
4239 handle_packed_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4240 int flags, bool *no_add_attrs)
4244 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4245 *node = build_type_copy (*node);
4246 TYPE_PACKED (*node) = 1;
4247 if (TYPE_MAIN_VARIANT (*node) == *node)
4249 /* If it is the main variant, then pack the other variants
4250 too. This happens in,
4253 struct Foo const *ptr; // creates a variant w/o packed flag
4254 } __ attribute__((packed)); // packs it now.
4258 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
4259 TYPE_PACKED (probe) = 1;
4263 else if (TREE_CODE (*node) == FIELD_DECL)
4264 DECL_PACKED (*node) = 1;
4265 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4266 used for DECL_REGISTER. It wouldn't mean anything anyway.
4267 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4268 that changes what the typedef is typing. */
4271 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4272 *no_add_attrs = true;
4278 /* Handle a "nocommon" attribute; arguments as in
4279 struct attribute_spec.handler. */
4282 handle_nocommon_attribute (tree *node, tree name,
4283 tree args ATTRIBUTE_UNUSED,
4284 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4286 if (TREE_CODE (*node) == VAR_DECL)
4287 DECL_COMMON (*node) = 0;
4290 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4291 *no_add_attrs = true;
4297 /* Handle a "common" attribute; arguments as in
4298 struct attribute_spec.handler. */
4301 handle_common_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4302 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4304 if (TREE_CODE (*node) == VAR_DECL)
4305 DECL_COMMON (*node) = 1;
4308 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4309 *no_add_attrs = true;
4315 /* Handle a "noreturn" attribute; arguments as in
4316 struct attribute_spec.handler. */
4319 handle_noreturn_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4320 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4322 tree type = TREE_TYPE (*node);
4324 /* See FIXME comment in c_common_attribute_table. */
4325 if (TREE_CODE (*node) == FUNCTION_DECL)
4326 TREE_THIS_VOLATILE (*node) = 1;
4327 else if (TREE_CODE (type) == POINTER_TYPE
4328 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4330 = build_pointer_type
4331 (build_type_variant (TREE_TYPE (type),
4332 TREE_READONLY (TREE_TYPE (type)), 1));
4335 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4336 *no_add_attrs = true;
4342 /* Handle a "noinline" attribute; arguments as in
4343 struct attribute_spec.handler. */
4346 handle_noinline_attribute (tree *node, tree name,
4347 tree args ATTRIBUTE_UNUSED,
4348 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4350 if (TREE_CODE (*node) == FUNCTION_DECL)
4351 DECL_UNINLINABLE (*node) = 1;
4354 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4355 *no_add_attrs = true;
4361 /* Handle a "always_inline" attribute; arguments as in
4362 struct attribute_spec.handler. */
4365 handle_always_inline_attribute (tree *node, tree name,
4366 tree args ATTRIBUTE_UNUSED,
4367 int flags ATTRIBUTE_UNUSED,
4370 if (TREE_CODE (*node) == FUNCTION_DECL)
4372 /* Do nothing else, just set the attribute. We'll get at
4373 it later with lookup_attribute. */
4377 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4378 *no_add_attrs = true;
4384 /* Handle a "used" attribute; arguments as in
4385 struct attribute_spec.handler. */
4388 handle_used_attribute (tree *pnode, tree name, tree args ATTRIBUTE_UNUSED,
4389 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4393 if (TREE_CODE (node) == FUNCTION_DECL
4394 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4396 TREE_USED (node) = 1;
4400 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4401 *no_add_attrs = true;
4407 /* Handle a "unused" attribute; arguments as in
4408 struct attribute_spec.handler. */
4411 handle_unused_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4412 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4418 if (TREE_CODE (decl) == PARM_DECL
4419 || TREE_CODE (decl) == VAR_DECL
4420 || TREE_CODE (decl) == FUNCTION_DECL
4421 || TREE_CODE (decl) == LABEL_DECL
4422 || TREE_CODE (decl) == TYPE_DECL)
4423 TREE_USED (decl) = 1;
4426 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4427 *no_add_attrs = true;
4432 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4433 *node = build_type_copy (*node);
4434 TREE_USED (*node) = 1;
4440 /* Handle a "const" attribute; arguments as in
4441 struct attribute_spec.handler. */
4444 handle_const_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4445 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4447 tree type = TREE_TYPE (*node);
4449 /* See FIXME comment on noreturn in c_common_attribute_table. */
4450 if (TREE_CODE (*node) == FUNCTION_DECL)
4451 TREE_READONLY (*node) = 1;
4452 else if (TREE_CODE (type) == POINTER_TYPE
4453 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4455 = build_pointer_type
4456 (build_type_variant (TREE_TYPE (type), 1,
4457 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4460 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4461 *no_add_attrs = true;
4467 /* Handle a "transparent_union" attribute; arguments as in
4468 struct attribute_spec.handler. */
4471 handle_transparent_union_attribute (tree *node, tree name,
4472 tree args ATTRIBUTE_UNUSED, int flags,
4475 tree decl = NULL_TREE;
4482 type = &TREE_TYPE (decl);
4483 is_type = TREE_CODE (*node) == TYPE_DECL;
4485 else if (TYPE_P (*node))
4486 type = node, is_type = 1;
4489 && TREE_CODE (*type) == UNION_TYPE
4491 || (TYPE_FIELDS (*type) != 0
4492 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4494 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4495 *type = build_type_copy (*type);
4496 TYPE_TRANSPARENT_UNION (*type) = 1;
4498 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4499 && TREE_CODE (*type) == UNION_TYPE
4500 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4501 DECL_TRANSPARENT_UNION (decl) = 1;
4504 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4505 *no_add_attrs = true;
4511 /* Handle a "constructor" attribute; arguments as in
4512 struct attribute_spec.handler. */
4515 handle_constructor_attribute (tree *node, tree name,
4516 tree args ATTRIBUTE_UNUSED,
4517 int flags ATTRIBUTE_UNUSED,
4521 tree type = TREE_TYPE (decl);
4523 if (TREE_CODE (decl) == FUNCTION_DECL
4524 && TREE_CODE (type) == FUNCTION_TYPE
4525 && decl_function_context (decl) == 0)
4527 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4528 TREE_USED (decl) = 1;
4532 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4533 *no_add_attrs = true;
4539 /* Handle a "destructor" attribute; arguments as in
4540 struct attribute_spec.handler. */
4543 handle_destructor_attribute (tree *node, tree name,
4544 tree args ATTRIBUTE_UNUSED,
4545 int flags ATTRIBUTE_UNUSED,
4549 tree type = TREE_TYPE (decl);
4551 if (TREE_CODE (decl) == FUNCTION_DECL
4552 && TREE_CODE (type) == FUNCTION_TYPE
4553 && decl_function_context (decl) == 0)
4555 DECL_STATIC_DESTRUCTOR (decl) = 1;
4556 TREE_USED (decl) = 1;
4560 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4561 *no_add_attrs = true;
4567 /* Handle a "mode" attribute; arguments as in
4568 struct attribute_spec.handler. */
4571 handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4572 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4576 *no_add_attrs = true;
4578 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4579 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4583 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4584 int len = strlen (p);
4585 enum machine_mode mode = VOIDmode;
4589 if (len > 4 && p[0] == '_' && p[1] == '_'
4590 && p[len - 1] == '_' && p[len - 2] == '_')
4592 char *newp = alloca (len - 1);
4594 strcpy (newp, &p[2]);
4595 newp[len - 4] = '\0';
4599 /* Change this type to have a type with the specified mode.
4600 First check for the special modes. */
4601 if (! strcmp (p, "byte"))
4603 else if (!strcmp (p, "word"))
4605 else if (! strcmp (p, "pointer"))
4608 for (j = 0; j < NUM_MACHINE_MODES; j++)
4609 if (!strcmp (p, GET_MODE_NAME (j)))
4610 mode = (enum machine_mode) j;
4612 if (mode == VOIDmode)
4613 error ("unknown machine mode `%s'", p);
4614 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
4615 (mode, TREE_UNSIGNED (type))))
4616 error ("no data type for mode `%s'", p);
4617 else if ((TREE_CODE (type) == POINTER_TYPE
4618 || TREE_CODE (type) == REFERENCE_TYPE)
4619 && !(*targetm.valid_pointer_mode) (mode))
4620 error ("invalid pointer mode `%s'", p);
4623 /* If this is a vector, make sure we either have hardware
4624 support, or we can emulate it. */
4625 if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
4627 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
4631 if (TREE_CODE (type) == POINTER_TYPE)
4633 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
4637 else if (TREE_CODE (type) == REFERENCE_TYPE)
4639 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
4645 /* No need to layout the type here. The caller should do this. */
4652 /* Handle a "section" attribute; arguments as in
4653 struct attribute_spec.handler. */
4656 handle_section_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4657 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4661 if (targetm.have_named_sections)
4663 if ((TREE_CODE (decl) == FUNCTION_DECL
4664 || TREE_CODE (decl) == VAR_DECL)
4665 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4667 if (TREE_CODE (decl) == VAR_DECL
4668 && current_function_decl != NULL_TREE
4669 && ! TREE_STATIC (decl))
4671 error ("%Hsection attribute cannot be specified for "
4672 "local variables", &DECL_SOURCE_LOCATION (decl));
4673 *no_add_attrs = true;
4676 /* The decl may have already been given a section attribute
4677 from a previous declaration. Ensure they match. */
4678 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4679 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4680 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4682 error ("%Hsection of '%D' conflicts with previous declaration",
4683 &DECL_SOURCE_LOCATION (*node), *node);
4684 *no_add_attrs = true;
4687 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4691 error ("%Hsection attribute not allowed for '%D'",
4692 &DECL_SOURCE_LOCATION (*node), *node);
4693 *no_add_attrs = true;
4698 error ("%Hsection attributes are not supported for this target",
4699 &DECL_SOURCE_LOCATION (*node));
4700 *no_add_attrs = true;
4706 /* Handle a "aligned" attribute; arguments as in
4707 struct attribute_spec.handler. */
4710 handle_aligned_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4711 int flags, bool *no_add_attrs)
4713 tree decl = NULL_TREE;
4716 tree align_expr = (args ? TREE_VALUE (args)
4717 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4723 type = &TREE_TYPE (decl);
4724 is_type = TREE_CODE (*node) == TYPE_DECL;
4726 else if (TYPE_P (*node))
4727 type = node, is_type = 1;
4729 /* Strip any NOPs of any kind. */
4730 while (TREE_CODE (align_expr) == NOP_EXPR
4731 || TREE_CODE (align_expr) == CONVERT_EXPR
4732 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4733 align_expr = TREE_OPERAND (align_expr, 0);
4735 if (TREE_CODE (align_expr) != INTEGER_CST)
4737 error ("requested alignment is not a constant");
4738 *no_add_attrs = true;
4740 else if ((i = tree_log2 (align_expr)) == -1)
4742 error ("requested alignment is not a power of 2");
4743 *no_add_attrs = true;
4745 else if (i > HOST_BITS_PER_INT - 2)
4747 error ("requested alignment is too large");
4748 *no_add_attrs = true;
4752 /* If we have a TYPE_DECL, then copy the type, so that we
4753 don't accidentally modify a builtin type. See pushdecl. */
4754 if (decl && TREE_TYPE (decl) != error_mark_node
4755 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4757 tree tt = TREE_TYPE (decl);
4758 *type = build_type_copy (*type);
4759 DECL_ORIGINAL_TYPE (decl) = tt;
4760 TYPE_NAME (*type) = decl;
4761 TREE_USED (*type) = TREE_USED (decl);
4762 TREE_TYPE (decl) = *type;
4764 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4765 *type = build_type_copy (*type);
4767 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4768 TYPE_USER_ALIGN (*type) = 1;
4770 else if (TREE_CODE (decl) != VAR_DECL
4771 && TREE_CODE (decl) != FIELD_DECL)
4773 error ("%Halignment may not be specified for '%D'",
4774 &DECL_SOURCE_LOCATION (decl), decl);
4775 *no_add_attrs = true;
4779 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4780 DECL_USER_ALIGN (decl) = 1;
4786 /* Handle a "weak" attribute; arguments as in
4787 struct attribute_spec.handler. */
4790 handle_weak_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
4791 tree args ATTRIBUTE_UNUSED,
4792 int flags ATTRIBUTE_UNUSED,
4793 bool *no_add_attrs ATTRIBUTE_UNUSED)
4795 declare_weak (*node);
4800 /* Handle an "alias" attribute; arguments as in
4801 struct attribute_spec.handler. */
4804 handle_alias_attribute (tree *node, tree name, tree args,
4805 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4809 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4810 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
4812 error ("%H'%D' defined both normally and as an alias",
4813 &DECL_SOURCE_LOCATION (decl), decl);
4814 *no_add_attrs = true;
4816 else if (decl_function_context (decl) == 0)
4820 id = TREE_VALUE (args);
4821 if (TREE_CODE (id) != STRING_CST)
4823 error ("alias arg not a string");
4824 *no_add_attrs = true;
4827 id = get_identifier (TREE_STRING_POINTER (id));
4828 /* This counts as a use of the object pointed to. */
4831 if (TREE_CODE (decl) == FUNCTION_DECL)
4832 DECL_INITIAL (decl) = error_mark_node;
4834 DECL_EXTERNAL (decl) = 0;
4838 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4839 *no_add_attrs = true;
4845 /* Handle an "visibility" attribute; arguments as in
4846 struct attribute_spec.handler. */
4849 handle_visibility_attribute (tree *node, tree name, tree args,
4850 int flags ATTRIBUTE_UNUSED,
4855 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
4857 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4858 *no_add_attrs = true;
4864 id = TREE_VALUE (args);
4865 if (TREE_CODE (id) != STRING_CST)
4867 error ("visibility arg not a string");
4868 *no_add_attrs = true;
4871 if (strcmp (TREE_STRING_POINTER (id), "hidden")
4872 && strcmp (TREE_STRING_POINTER (id), "protected")
4873 && strcmp (TREE_STRING_POINTER (id), "internal")
4874 && strcmp (TREE_STRING_POINTER (id), "default"))
4876 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4877 *no_add_attrs = true;
4885 /* Handle an "tls_model" attribute; arguments as in
4886 struct attribute_spec.handler. */
4889 handle_tls_model_attribute (tree *node, tree name, tree args,
4890 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4894 if (! DECL_THREAD_LOCAL (decl))
4896 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4897 *no_add_attrs = true;
4903 id = TREE_VALUE (args);
4904 if (TREE_CODE (id) != STRING_CST)
4906 error ("tls_model arg not a string");
4907 *no_add_attrs = true;
4910 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
4911 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
4912 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
4913 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4915 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4916 *no_add_attrs = true;
4924 /* Handle a "no_instrument_function" attribute; arguments as in
4925 struct attribute_spec.handler. */
4928 handle_no_instrument_function_attribute (tree *node, tree name,
4929 tree args ATTRIBUTE_UNUSED,
4930 int flags ATTRIBUTE_UNUSED,
4935 if (TREE_CODE (decl) != FUNCTION_DECL)
4937 error ("%H'%E' attribute applies only to functions",
4938 &DECL_SOURCE_LOCATION (decl), name);
4939 *no_add_attrs = true;
4941 else if (DECL_INITIAL (decl))
4943 error ("%Hcan't set '%E' attribute after definition",
4944 &DECL_SOURCE_LOCATION (decl), name);
4945 *no_add_attrs = true;
4948 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
4953 /* Handle a "malloc" attribute; arguments as in
4954 struct attribute_spec.handler. */
4957 handle_malloc_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4958 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4960 if (TREE_CODE (*node) == FUNCTION_DECL)
4961 DECL_IS_MALLOC (*node) = 1;
4962 /* ??? TODO: Support types. */
4965 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4966 *no_add_attrs = true;
4972 /* Handle a "no_limit_stack" attribute; arguments as in
4973 struct attribute_spec.handler. */
4976 handle_no_limit_stack_attribute (tree *node, tree name,
4977 tree args ATTRIBUTE_UNUSED,
4978 int flags ATTRIBUTE_UNUSED,
4983 if (TREE_CODE (decl) != FUNCTION_DECL)
4985 error ("%H'%E' attribute applies only to functions",
4986 &DECL_SOURCE_LOCATION (decl), name);
4987 *no_add_attrs = true;
4989 else if (DECL_INITIAL (decl))
4991 error ("%Hcan't set '%E' attribute after definition",
4992 &DECL_SOURCE_LOCATION (decl), name);
4993 *no_add_attrs = true;
4996 DECL_NO_LIMIT_STACK (decl) = 1;
5001 /* Handle a "pure" attribute; arguments as in
5002 struct attribute_spec.handler. */
5005 handle_pure_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5006 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5008 if (TREE_CODE (*node) == FUNCTION_DECL)
5009 DECL_IS_PURE (*node) = 1;
5010 /* ??? TODO: Support types. */
5013 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5014 *no_add_attrs = true;
5020 /* Handle a "deprecated" attribute; arguments as in
5021 struct attribute_spec.handler. */
5024 handle_deprecated_attribute (tree *node, tree name,
5025 tree args ATTRIBUTE_UNUSED, int flags,
5028 tree type = NULL_TREE;
5030 const char *what = NULL;
5035 type = TREE_TYPE (decl);
5037 if (TREE_CODE (decl) == TYPE_DECL
5038 || TREE_CODE (decl) == PARM_DECL
5039 || TREE_CODE (decl) == VAR_DECL
5040 || TREE_CODE (decl) == FUNCTION_DECL
5041 || TREE_CODE (decl) == FIELD_DECL)
5042 TREE_DEPRECATED (decl) = 1;
5046 else if (TYPE_P (*node))
5048 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5049 *node = build_type_copy (*node);
5050 TREE_DEPRECATED (*node) = 1;
5058 *no_add_attrs = true;
5059 if (type && TYPE_NAME (type))
5061 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5062 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5063 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5064 && DECL_NAME (TYPE_NAME (type)))
5065 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5068 warning ("`%s' attribute ignored for `%s'",
5069 IDENTIFIER_POINTER (name), what);
5071 warning ("`%s' attribute ignored",
5072 IDENTIFIER_POINTER (name));
5078 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5079 to prevent us from duplicating type nodes unnecessarily.
5080 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5081 since we want to distinguish types that are essentially identical (except
5082 for their debug representation), we use a local list here. */
5083 static GTY(()) tree vector_type_node_list = 0;
5085 /* Handle a "vector_size" attribute; arguments as in
5086 struct attribute_spec.handler. */
5089 handle_vector_size_attribute (tree *node, tree name, tree args,
5090 int flags ATTRIBUTE_UNUSED,
5093 unsigned HOST_WIDE_INT vecsize, nunits;
5094 enum machine_mode mode, orig_mode, new_mode;
5095 tree type = *node, new_type = NULL_TREE;
5096 tree type_list_node;
5098 *no_add_attrs = true;
5100 if (! host_integerp (TREE_VALUE (args), 1))
5102 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5106 /* Get the vector size (in bytes). */
5107 vecsize = tree_low_cst (TREE_VALUE (args), 1);
5109 /* We need to provide for vector pointers, vector arrays, and
5110 functions returning vectors. For example:
5112 __attribute__((vector_size(16))) short *foo;
5114 In this case, the mode is SI, but the type being modified is
5115 HI, so we need to look further. */
5117 while (POINTER_TYPE_P (type)
5118 || TREE_CODE (type) == FUNCTION_TYPE
5119 || TREE_CODE (type) == METHOD_TYPE
5120 || TREE_CODE (type) == ARRAY_TYPE)
5121 type = TREE_TYPE (type);
5123 /* Get the mode of the type being modified. */
5124 orig_mode = TYPE_MODE (type);
5126 if (TREE_CODE (type) == RECORD_TYPE
5127 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5128 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5129 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5131 error ("invalid vector type for attribute `%s'",
5132 IDENTIFIER_POINTER (name));
5136 /* Calculate how many units fit in the vector. */
5137 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5139 /* Find a suitably sized vector. */
5140 new_mode = VOIDmode;
5141 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5143 : MODE_VECTOR_FLOAT);
5145 mode = GET_MODE_WIDER_MODE (mode))
5146 if (vecsize == GET_MODE_SIZE (mode)
5147 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5153 if (new_mode == VOIDmode)
5155 error ("no vector mode with the size and type specified could be found");
5159 for (type_list_node = vector_type_node_list; type_list_node;
5160 type_list_node = TREE_CHAIN (type_list_node))
5162 tree other_type = TREE_VALUE (type_list_node);
5163 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
5164 tree fields = TYPE_FIELDS (record);
5165 tree field_type = TREE_TYPE (fields);
5166 tree array_type = TREE_TYPE (field_type);
5167 if (TREE_CODE (fields) != FIELD_DECL
5168 || TREE_CODE (field_type) != ARRAY_TYPE)
5171 if (TYPE_MODE (other_type) == mode && type == array_type)
5173 new_type = other_type;
5178 if (new_type == NULL_TREE)
5180 tree index, array, rt, list_node;
5182 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
5183 TREE_UNSIGNED (type));
5187 error ("no vector mode with the size and type specified could be found");
5191 new_type = build_type_copy (new_type);
5193 /* If this is a vector, make sure we either have hardware
5194 support, or we can emulate it. */
5195 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5196 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5197 && !vector_mode_valid_p (mode))
5199 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5203 /* Set the debug information here, because this is the only
5204 place where we know the underlying type for a vector made
5205 with vector_size. For debugging purposes we pretend a vector
5206 is an array within a structure. */
5207 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
5208 array = build_array_type (type, build_index_type (index));
5209 rt = make_node (RECORD_TYPE);
5211 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
5212 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
5214 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
5216 list_node = build_tree_list (NULL, new_type);
5217 TREE_CHAIN (list_node) = vector_type_node_list;
5218 vector_type_node_list = list_node;
5221 /* Build back pointers if needed. */
5222 *node = vector_size_helper (*node, new_type);
5227 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
5230 If we requested a pointer to a vector, build up the pointers that
5231 we stripped off while looking for the inner type. Similarly for
5232 return values from functions.
5234 The argument "type" is the top of the chain, and "bottom" is the
5235 new type which we will point to. */
5238 vector_size_helper (tree type, tree bottom)
5242 if (POINTER_TYPE_P (type))
5244 inner = vector_size_helper (TREE_TYPE (type), bottom);
5245 outer = build_pointer_type (inner);
5247 else if (TREE_CODE (type) == ARRAY_TYPE)
5249 inner = vector_size_helper (TREE_TYPE (type), bottom);
5250 outer = build_array_type (inner, TYPE_DOMAIN (type));
5252 else if (TREE_CODE (type) == FUNCTION_TYPE)
5254 inner = vector_size_helper (TREE_TYPE (type), bottom);
5255 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
5257 else if (TREE_CODE (type) == METHOD_TYPE)
5259 inner = vector_size_helper (TREE_TYPE (type), bottom);
5260 outer = build_method_type_directly (TYPE_METHOD_BASETYPE (type),
5262 TYPE_ARG_TYPES (type));
5267 TREE_READONLY (outer) = TREE_READONLY (type);
5268 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
5273 /* Handle the "nonnull" attribute. */
5275 handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
5276 tree args, int flags ATTRIBUTE_UNUSED,
5280 unsigned HOST_WIDE_INT attr_arg_num;
5282 /* If no arguments are specified, all pointer arguments should be
5283 non-null. Verify a full prototype is given so that the arguments
5284 will have the correct types when we actually check them later. */
5287 if (! TYPE_ARG_TYPES (type))
5289 error ("nonnull attribute without arguments on a non-prototype");
5290 *no_add_attrs = true;
5295 /* Argument list specified. Verify that each argument number references
5296 a pointer argument. */
5297 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5300 unsigned HOST_WIDE_INT arg_num, ck_num;
5302 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5304 error ("nonnull argument has invalid operand number (arg %lu)",
5305 (unsigned long) attr_arg_num);
5306 *no_add_attrs = true;
5310 argument = TYPE_ARG_TYPES (type);
5313 for (ck_num = 1; ; ck_num++)
5315 if (! argument || ck_num == arg_num)
5317 argument = TREE_CHAIN (argument);
5321 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5323 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5324 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5325 *no_add_attrs = true;
5329 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5331 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5332 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5333 *no_add_attrs = true;
5342 /* Check the argument list of a function call for null in argument slots
5343 that are marked as requiring a non-null pointer argument. */
5346 check_function_nonnull (tree attrs, tree params)
5348 tree a, args, param;
5351 for (a = attrs; a; a = TREE_CHAIN (a))
5353 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5355 args = TREE_VALUE (a);
5357 /* Walk the argument list. If we encounter an argument number we
5358 should check for non-null, do it. If the attribute has no args,
5359 then every pointer argument is checked (in which case the check
5360 for pointer type is done in check_nonnull_arg). */
5361 for (param = params, param_num = 1; ;
5362 param_num++, param = TREE_CHAIN (param))
5366 if (! args || nonnull_check_p (args, param_num))
5367 check_function_arguments_recurse (check_nonnull_arg, NULL,
5375 /* Helper for check_function_nonnull; given a list of operands which
5376 must be non-null in ARGS, determine if operand PARAM_NUM should be
5380 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5382 unsigned HOST_WIDE_INT arg_num;
5384 for (; args; args = TREE_CHAIN (args))
5386 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5389 if (arg_num == param_num)
5395 /* Check that the function argument PARAM (which is operand number
5396 PARAM_NUM) is non-null. This is called by check_function_nonnull
5397 via check_function_arguments_recurse. */
5400 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED, tree param,
5401 unsigned HOST_WIDE_INT param_num)
5403 /* Just skip checking the argument if it's not a pointer. This can
5404 happen if the "nonnull" attribute was given without an operand
5405 list (which means to check every pointer argument). */
5407 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5410 if (integer_zerop (param))
5411 warning ("null argument where non-null required (arg %lu)",
5412 (unsigned long) param_num);
5415 /* Helper for nonnull attribute handling; fetch the operand number
5416 from the attribute argument list. */
5419 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5421 /* Strip any conversions from the arg number and verify they
5423 while (TREE_CODE (arg_num_expr) == NOP_EXPR
5424 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
5425 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
5426 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
5428 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5429 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5432 *valp = TREE_INT_CST_LOW (arg_num_expr);
5436 /* Handle a "nothrow" attribute; arguments as in
5437 struct attribute_spec.handler. */
5440 handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5441 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5443 if (TREE_CODE (*node) == FUNCTION_DECL)
5444 TREE_NOTHROW (*node) = 1;
5445 /* ??? TODO: Support types. */
5448 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5449 *no_add_attrs = true;
5455 /* Handle a "cleanup" attribute; arguments as in
5456 struct attribute_spec.handler. */
5459 handle_cleanup_attribute (tree *node, tree name, tree args,
5460 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5463 tree cleanup_id, cleanup_decl;
5465 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5466 for global destructors in C++. This requires infrastructure that
5467 we don't have generically at the moment. It's also not a feature
5468 we'd be missing too much, since we do have attribute constructor. */
5469 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5471 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5472 *no_add_attrs = true;
5476 /* Verify that the argument is a function in scope. */
5477 /* ??? We could support pointers to functions here as well, if
5478 that was considered desirable. */
5479 cleanup_id = TREE_VALUE (args);
5480 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5482 error ("cleanup arg not an identifier");
5483 *no_add_attrs = true;
5486 cleanup_decl = lookup_name (cleanup_id);
5487 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5489 error ("cleanup arg not a function");
5490 *no_add_attrs = true;
5494 /* That the function has proper type is checked with the
5495 eventual call to build_function_call. */
5500 /* Check for valid arguments being passed to a function. */
5502 check_function_arguments (tree attrs, tree params)
5504 /* Check for null being passed in a pointer argument that must be
5505 non-null. We also need to do this if format checking is enabled. */
5508 check_function_nonnull (attrs, params);
5510 /* Check for errors in format strings. */
5513 check_function_format (NULL, attrs, params);
5516 /* Generic argument checking recursion routine. PARAM is the argument to
5517 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5518 once the argument is resolved. CTX is context for the callback. */
5520 check_function_arguments_recurse (void (*callback)
5521 (void *, tree, unsigned HOST_WIDE_INT),
5522 void *ctx, tree param,
5523 unsigned HOST_WIDE_INT param_num)
5525 if (TREE_CODE (param) == NOP_EXPR)
5527 /* Strip coercion. */
5528 check_function_arguments_recurse (callback, ctx,
5529 TREE_OPERAND (param, 0), param_num);
5533 if (TREE_CODE (param) == CALL_EXPR)
5535 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5537 bool found_format_arg = false;
5539 /* See if this is a call to a known internationalization function
5540 that modifies a format arg. Such a function may have multiple
5541 format_arg attributes (for example, ngettext). */
5543 for (attrs = TYPE_ATTRIBUTES (type);
5545 attrs = TREE_CHAIN (attrs))
5546 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5549 tree format_num_expr;
5553 /* Extract the argument number, which was previously checked
5555 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5556 while (TREE_CODE (format_num_expr) == NOP_EXPR
5557 || TREE_CODE (format_num_expr) == CONVERT_EXPR
5558 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5559 format_num_expr = TREE_OPERAND (format_num_expr, 0);
5561 if (TREE_CODE (format_num_expr) != INTEGER_CST
5562 || TREE_INT_CST_HIGH (format_num_expr) != 0)
5565 format_num = TREE_INT_CST_LOW (format_num_expr);
5567 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5569 inner_args = TREE_CHAIN (inner_args), i++)
5570 if (i == format_num)
5572 check_function_arguments_recurse (callback, ctx,
5573 TREE_VALUE (inner_args),
5575 found_format_arg = true;
5580 /* If we found a format_arg attribute and did a recursive check,
5581 we are done with checking this argument. Otherwise, we continue
5582 and this will be considered a non-literal. */
5583 if (found_format_arg)
5587 if (TREE_CODE (param) == COND_EXPR)
5589 /* Check both halves of the conditional expression. */
5590 check_function_arguments_recurse (callback, ctx,
5591 TREE_OPERAND (param, 1), param_num);
5592 check_function_arguments_recurse (callback, ctx,
5593 TREE_OPERAND (param, 2), param_num);
5597 (*callback) (ctx, param, param_num);
5600 /* Function to help qsort sort FIELD_DECLs by name order. */
5603 field_decl_cmp (const void *x_p, const void *y_p)
5605 const tree *const x = x_p;
5606 const tree *const y = y_p;
5607 if (DECL_NAME (*x) == DECL_NAME (*y))
5608 /* A nontype is "greater" than a type. */
5609 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5610 if (DECL_NAME (*x) == NULL_TREE)
5612 if (DECL_NAME (*y) == NULL_TREE)
5614 if (DECL_NAME (*x) < DECL_NAME (*y))
5620 gt_pointer_operator new_value;
5624 /* This routine compares two fields like field_decl_cmp but using the
5625 pointer operator in resort_data. */
5628 resort_field_decl_cmp (const void *x_p, const void *y_p)
5630 const tree *const x = x_p;
5631 const tree *const y = y_p;
5633 if (DECL_NAME (*x) == DECL_NAME (*y))
5634 /* A nontype is "greater" than a type. */
5635 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5636 if (DECL_NAME (*x) == NULL_TREE)
5638 if (DECL_NAME (*y) == NULL_TREE)
5641 tree d1 = DECL_NAME (*x);
5642 tree d2 = DECL_NAME (*y);
5643 resort_data.new_value (&d1, resort_data.cookie);
5644 resort_data.new_value (&d2, resort_data.cookie);
5651 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5654 resort_sorted_fields (void *obj,
5655 void *orig_obj ATTRIBUTE_UNUSED ,
5656 gt_pointer_operator new_value,
5659 struct sorted_fields_type *sf = obj;
5660 resort_data.new_value = new_value;
5661 resort_data.cookie = cookie;
5662 qsort (&sf->elts[0], sf->len, sizeof (tree),
5663 resort_field_decl_cmp);
5666 /* Used by estimate_num_insns. Estimate number of instructions seen
5667 by given statement. */
5669 c_estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
5674 if (TYPE_P (x) || DECL_P (x))
5679 /* Assume that constants and references counts nothing. These should
5680 be majorized by amount of operations among them we count later
5681 and are common target of CSE and similar optimizations. */
5682 if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
5683 || TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
5685 switch (TREE_CODE (x))
5687 /* Reconginze assignments of large structures and constructors of
5692 int size = int_size_in_bytes (TREE_TYPE (x));
5694 if (!size || size > MOVE_MAX_PIECES)
5697 *count += 2 * (size + MOVE_MAX - 1) / MOVE_MAX;
5701 /* Few special cases of expensive operations. This is usefull
5702 to avoid inlining on functions having too many of these. */
5703 case TRUNC_DIV_EXPR:
5705 case FLOOR_DIV_EXPR:
5706 case ROUND_DIV_EXPR:
5707 case TRUNC_MOD_EXPR:
5709 case FLOOR_MOD_EXPR:
5710 case ROUND_MOD_EXPR:
5715 /* Various containers that will produce no code themselves. */
5722 case IDENTIFIER_NODE:
5723 case PLACEHOLDER_EXPR:
5724 case WITH_CLEANUP_EXPR:
5725 case CLEANUP_POINT_EXPR:
5727 case VIEW_CONVERT_EXPR:
5733 case TRY_CATCH_EXPR:
5734 case TRY_FINALLY_EXPR:
5737 case LABELED_BLOCK_EXPR:
5738 case EXIT_BLOCK_EXPR:
5739 case EXPR_WITH_FILE_LOCATION:
5756 /* Do not account static initializers. */
5757 if (TREE_STATIC (TREE_OPERAND (x, 0)))
5766 /* Estimate number of instructions that will be created by expanding the body. */
5768 c_estimate_num_insns (tree decl)
5771 walk_tree_without_duplicates (&DECL_SAVED_TREE (decl), c_estimate_num_insns_1, &num);
5775 /* Used by c_decl_uninit to find where expressions like x = x + 1; */
5778 c_decl_uninit_1 (tree *t, int *walk_sub_trees, void *x)
5780 /* If x = EXP(&x)EXP, then do not warn about the use of x. */
5781 if (TREE_CODE (*t) == ADDR_EXPR && TREE_OPERAND (*t, 0) == x)
5783 *walk_sub_trees = 0;
5791 /* Find out if a variable is uninitialized based on DECL_INITIAL. */
5794 c_decl_uninit (tree t)
5796 /* int x = x; is GCC extension to turn off this warning, only if warn_init_self is zero. */
5797 if (DECL_INITIAL (t) == t)
5798 return warn_init_self ? true : false;
5800 /* Walk the trees looking for the variable itself. */
5801 if (walk_tree_without_duplicates (&DECL_INITIAL (t), c_decl_uninit_1, t))
5806 #include "gt-c-common.h"