1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 #include "tree-iterator.h"
48 cpp_reader *parse_in; /* Declared in c-pragma.h. */
50 /* We let tm.h override the types used here, to handle trivial differences
51 such as the choice of unsigned int or long unsigned int for size_t.
52 When machines start needing nontrivial differences in the size type,
53 it would be best to do something here to figure out automatically
54 from other information what type to use. */
57 #define SIZE_TYPE "long unsigned int"
61 #define PID_TYPE "int"
65 #define WCHAR_TYPE "int"
68 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
69 #define MODIFIED_WCHAR_TYPE \
70 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
73 #define PTRDIFF_TYPE "long int"
77 #define WINT_TYPE "unsigned int"
81 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
89 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
91 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
92 ? "long unsigned int" \
93 : "long long unsigned int"))
96 /* The following symbols are subsumed in the c_global_trees array, and
97 listed here individually for documentation purposes.
99 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
101 tree short_integer_type_node;
102 tree long_integer_type_node;
103 tree long_long_integer_type_node;
105 tree short_unsigned_type_node;
106 tree long_unsigned_type_node;
107 tree long_long_unsigned_type_node;
109 tree truthvalue_type_node;
110 tree truthvalue_false_node;
111 tree truthvalue_true_node;
113 tree ptrdiff_type_node;
115 tree unsigned_char_type_node;
116 tree signed_char_type_node;
117 tree wchar_type_node;
118 tree signed_wchar_type_node;
119 tree unsigned_wchar_type_node;
121 tree float_type_node;
122 tree double_type_node;
123 tree long_double_type_node;
125 tree complex_integer_type_node;
126 tree complex_float_type_node;
127 tree complex_double_type_node;
128 tree complex_long_double_type_node;
130 tree intQI_type_node;
131 tree intHI_type_node;
132 tree intSI_type_node;
133 tree intDI_type_node;
134 tree intTI_type_node;
136 tree unsigned_intQI_type_node;
137 tree unsigned_intHI_type_node;
138 tree unsigned_intSI_type_node;
139 tree unsigned_intDI_type_node;
140 tree unsigned_intTI_type_node;
142 tree widest_integer_literal_type_node;
143 tree widest_unsigned_literal_type_node;
145 Nodes for types `void *' and `const void *'.
147 tree ptr_type_node, const_ptr_type_node;
149 Nodes for types `char *' and `const char *'.
151 tree string_type_node, const_string_type_node;
153 Type `char[SOMENUMBER]'.
154 Used when an array of char is needed and the size is irrelevant.
156 tree char_array_type_node;
158 Type `int[SOMENUMBER]' or something like it.
159 Used when an array of int needed and the size is irrelevant.
161 tree int_array_type_node;
163 Type `wchar_t[SOMENUMBER]' or something like it.
164 Used when a wide string literal is created.
166 tree wchar_array_type_node;
168 Type `int ()' -- used for implicit declaration of functions.
170 tree default_function_type;
172 A VOID_TYPE node, packaged in a TREE_LIST.
176 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
177 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
178 VAR_DECLS, but C++ does.)
180 tree function_name_decl_node;
181 tree pretty_function_name_decl_node;
182 tree c99_function_name_decl_node;
184 Stack of nested function name VAR_DECLs.
186 tree saved_function_name_decls;
190 tree c_global_trees[CTI_MAX];
192 /* TRUE if a code represents a statement. The front end init
193 langhook should take care of initialization of this array. */
195 bool statement_code_p[MAX_TREE_CODES];
197 /* Switches common to the C front ends. */
199 /* Nonzero if prepreprocessing only. */
201 int flag_preprocess_only;
203 /* Nonzero means don't output line number information. */
205 char flag_no_line_commands;
207 /* Nonzero causes -E output not to be done, but directives such as
208 #define that have side effects are still obeyed. */
212 /* Nonzero means dump macros in some fashion. */
214 char flag_dump_macros;
216 /* Nonzero means pass #include lines through to the output. */
218 char flag_dump_includes;
220 /* The file name to which we should write a precompiled header, or
221 NULL if no header will be written in this compile. */
223 const char *pch_file;
225 /* Nonzero if an ISO standard was selected. It rejects macros in the
229 /* Nonzero if -undef was given. It suppresses target built-in macros
233 /* Nonzero means don't recognize the non-ANSI builtin functions. */
237 /* Nonzero means don't recognize the non-ANSI builtin functions.
240 int flag_no_nonansi_builtin;
242 /* Nonzero means give `double' the same size as `float'. */
244 int flag_short_double;
246 /* Nonzero means give `wchar_t' the same size as `short'. */
248 int flag_short_wchar;
250 /* Nonzero means allow Microsoft extensions without warnings or errors. */
251 int flag_ms_extensions;
253 /* Nonzero means don't recognize the keyword `asm'. */
257 /* Nonzero means give string constants the type `const char *', as mandated
260 int flag_const_strings;
262 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
264 int flag_signed_bitfields = 1;
265 int explicit_flag_signed_bitfields;
267 /* Nonzero means warn about pointer casts that can drop a type qualifier
268 from the pointer target type. */
272 /* Warn about functions which might be candidates for format attributes. */
274 int warn_missing_format_attribute;
276 /* Nonzero means warn about sizeof(function) or addition/subtraction
277 of function pointers. */
279 int warn_pointer_arith;
281 /* Nonzero means warn for any global function def
282 without separate previous prototype decl. */
284 int warn_missing_prototypes;
286 /* Warn if adding () is suggested. */
288 int warn_parentheses;
290 /* Warn if initializer is not completely bracketed. */
292 int warn_missing_braces;
294 /* Warn about comparison of signed and unsigned values.
295 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified
296 (in which case -Wextra gets to decide). */
298 int warn_sign_compare = -1;
300 /* Nonzero means warn about usage of long long when `-pedantic'. */
302 int warn_long_long = 1;
304 /* Nonzero means warn about deprecated conversion from string constant to
307 int warn_write_strings;
309 /* Nonzero means warn about multiple (redundant) decls for the same single
310 variable or function. */
312 int warn_redundant_decls;
314 /* Warn about testing equality of floating point numbers. */
316 int warn_float_equal;
318 /* Warn about a subscript that has type char. */
320 int warn_char_subscripts;
322 /* Warn if a type conversion is done that might have confusing results. */
326 /* Warn about #pragma directives that are not recognized. */
328 int warn_unknown_pragmas; /* Tri state variable. */
330 /* Warn about format/argument anomalies in calls to formatted I/O functions
331 (*printf, *scanf, strftime, strfmon, etc.). */
335 /* Warn about Y2K problems with strftime formats. */
339 /* Warn about excess arguments to formats. */
341 int warn_format_extra_args;
343 /* Warn about zero-length formats. */
345 int warn_format_zero_length;
347 /* Warn about non-literal format arguments. */
349 int warn_format_nonliteral;
351 /* Warn about possible security problems with calls to format functions. */
353 int warn_format_security;
355 /* Zero means that faster, ...NonNil variants of objc_msgSend...
356 calls will be used in ObjC; passing nil receivers to such calls
357 will most likely result in crashes. */
358 int flag_nil_receivers = 1;
360 /* Nonzero means that we will allow new ObjC exception syntax (@throw,
361 @try, etc.) in source code. */
362 int flag_objc_exceptions = 0;
364 /* Nonzero means that code generation will be altered to support
365 "zero-link" execution. This currently affects ObjC only, but may
366 affect other languages in the future. */
367 int flag_zero_link = 0;
369 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
370 unit. It will inform the ObjC runtime that class definition(s) herein
371 contained are to replace one(s) previously loaded. */
372 int flag_replace_objc_classes = 0;
374 /* C/ObjC language option variables. */
377 /* Nonzero means message about use of implicit function declarations;
378 1 means warning; 2 means error. */
380 int mesg_implicit_function_declaration = -1;
382 /* Nonzero means allow type mismatches in conditional expressions;
383 just make their values `void'. */
385 int flag_cond_mismatch;
387 /* Nonzero means enable C89 Amendment 1 features. */
391 /* Nonzero means use the ISO C99 dialect of C. */
395 /* Nonzero means that we have builtin functions, and main is an int. */
399 /* Nonzero means warn when casting a function call to a type that does
400 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
401 when there is no previous declaration of sqrt or malloc. */
403 int warn_bad_function_cast;
405 /* Warn about traditional constructs whose meanings changed in ANSI C. */
407 int warn_traditional;
409 /* Nonzero means warn for a declaration found after a statement. */
411 int warn_declaration_after_statement;
413 /* Nonzero means warn for non-prototype function decls
414 or non-prototyped defs without previous prototype. */
416 int warn_strict_prototypes;
418 /* Nonzero means warn for any global function def
419 without separate previous decl. */
421 int warn_missing_declarations;
423 /* Nonzero means warn about declarations of objects not at
424 file-scope level and about *all* declarations of functions (whether
425 or static) not at file-scope level. Note that we exclude
426 implicit function declarations. To get warnings about those, use
429 int warn_nested_externs;
431 /* Warn if main is suspicious. */
435 /* Nonzero means warn about possible violations of sequence point rules. */
437 int warn_sequence_point;
439 /* Nonzero means warn about uninitialized variable when it is initialized with itself.
440 For example: int i = i;, GCC will not warn about this when warn_init_self is nonzero. */
444 /* Nonzero means to warn about compile-time division by zero. */
445 int warn_div_by_zero = 1;
447 /* Nonzero means warn about use of implicit int. */
449 int warn_implicit_int;
451 /* Warn about NULL being passed to argument slots marked as requiring
456 /* Warn about old-style parameter declaration. */
458 int warn_old_style_definition;
461 /* ObjC language option variables. */
464 /* Open and close the file for outputting class declarations, if
467 int flag_gen_declaration;
469 /* Generate code for GNU or NeXT runtime environment. */
471 #ifdef NEXT_OBJC_RUNTIME
472 int flag_next_runtime = 1;
474 int flag_next_runtime = 0;
477 /* Tells the compiler that this is a special run. Do not perform any
478 compiling, instead we are to test some platform dependent features
479 and output a C header file with appropriate definitions. */
481 int print_struct_values;
483 /* ???. Undocumented. */
485 const char *constant_string_class_name;
487 /* Warn if multiple methods are seen for the same selector, but with
488 different argument types. Performs the check on the whole selector
489 table at the end of compilation. */
493 /* Warn if a @selector() is found, and no method with that selector
494 has been previously declared. The check is done on each
495 @selector() as soon as it is found - so it warns about forward
498 int warn_undeclared_selector;
500 /* Warn if methods required by a protocol are not implemented in the
501 class adopting it. When turned off, methods inherited to that
502 class are also considered implemented. */
504 int warn_protocol = 1;
507 /* C++ language option variables. */
510 /* Nonzero means don't recognize any extension keywords. */
512 int flag_no_gnu_keywords;
514 /* Nonzero means do emit exported implementations of functions even if
515 they can be inlined. */
517 int flag_implement_inlines = 1;
519 /* Nonzero means that implicit instantiations will be emitted if needed. */
521 int flag_implicit_templates = 1;
523 /* Nonzero means that implicit instantiations of inline templates will be
524 emitted if needed, even if instantiations of non-inline templates
527 int flag_implicit_inline_templates = 1;
529 /* Nonzero means generate separate instantiation control files and
530 juggle them at link time. */
532 int flag_use_repository;
534 /* Nonzero if we want to issue diagnostics that the standard says are not
537 int flag_optional_diags = 1;
539 /* Nonzero means we should attempt to elide constructors when possible. */
541 int flag_elide_constructors = 1;
543 /* Nonzero means that member functions defined in class scope are
544 inline by default. */
546 int flag_default_inline = 1;
548 /* Controls whether compiler generates 'type descriptor' that give
549 run-time type information. */
553 /* Nonzero if we want to conserve space in the .o files. We do this
554 by putting uninitialized data and runtime initialized data into
555 .common instead of .data at the expense of not flagging multiple
558 int flag_conserve_space;
560 /* Nonzero if we want to obey access control semantics. */
562 int flag_access_control = 1;
564 /* Nonzero if we want to check the return value of new and avoid calling
565 constructors if it is a null pointer. */
569 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
570 initialization variables.
571 0: Old rules, set by -fno-for-scope.
572 2: New ISO rules, set by -ffor-scope.
573 1: Try to implement new ISO rules, but with backup compatibility
574 (and warnings). This is the default, for now. */
576 int flag_new_for_scope = 1;
578 /* Nonzero if we want to emit defined symbols with common-like linkage as
579 weak symbols where possible, in order to conform to C++ semantics.
580 Otherwise, emit them as local symbols. */
584 /* 0 means we want the preprocessor to not emit line directives for
585 the current working directory. 1 means we want it to do it. -1
586 means we should decide depending on whether debugging information
587 is being emitted or not. */
589 int flag_working_directory = -1;
591 /* Nonzero to use __cxa_atexit, rather than atexit, to register
592 destructors for local statics and global objects. */
594 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
596 /* Nonzero means make the default pedwarns warnings instead of errors.
597 The value of this flag is ignored if -pedantic is specified. */
601 /* Nonzero means to implement standard semantics for exception
602 specifications, calling unexpected if an exception is thrown that
603 doesn't match the specification. Zero means to treat them as
604 assertions and optimize accordingly, but not check them. */
606 int flag_enforce_eh_specs = 1;
608 /* Nonzero means warn about things that will change when compiling
609 with an ABI-compliant compiler. */
613 /* Nonzero means warn about invalid uses of offsetof. */
615 int warn_invalid_offsetof = 1;
617 /* Nonzero means warn about implicit declarations. */
619 int warn_implicit = 1;
621 /* Nonzero means warn when all ctors or dtors are private, and the class
624 int warn_ctor_dtor_privacy = 0;
626 /* Nonzero means warn in function declared in derived class has the
627 same name as a virtual in the base class, but fails to match the
628 type signature of any virtual function in the base class. */
630 int warn_overloaded_virtual;
632 /* Nonzero means warn when declaring a class that has a non virtual
633 destructor, when it really ought to have a virtual one. */
637 /* Nonzero means warn when the compiler will reorder code. */
641 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
645 /* Nonzero means warn when we convert a pointer to member function
646 into a pointer to (void or function). */
648 int warn_pmf2ptr = 1;
650 /* Nonzero means warn about violation of some Effective C++ style rules. */
654 /* Nonzero means warn where overload resolution chooses a promotion from
655 unsigned to signed over a conversion to an unsigned of the same size. */
659 /* Nonzero means warn when an old-style cast is used. */
661 int warn_old_style_cast;
663 /* Nonzero means warn when non-templatized friend functions are
664 declared within a template */
666 int warn_nontemplate_friend = 1;
668 /* Nonzero means complain about deprecated features. */
670 int warn_deprecated = 1;
672 /* Maximum template instantiation depth. This limit is rather
673 arbitrary, but it exists to limit the time it takes to notice
674 infinite template instantiations. */
676 int max_tinst_depth = 500;
680 /* The elements of `ridpointers' are identifier nodes for the reserved
681 type names and storage classes. It is indexed by a RID_... value. */
684 tree (*make_fname_decl) (tree, int);
686 /* If non-NULL, the address of a language-specific function that
687 returns 1 for language-specific statement codes. */
688 int (*lang_statement_code_p) (enum tree_code);
690 /* If non-NULL, the address of a language-specific function that does any
691 language-specific gimplification for _STMT nodes and returns 1 iff
693 int (*lang_gimplify_stmt) (tree *);
695 /* If non-NULL, the address of a language-specific function that takes
696 any action required right before expand_function_end is called. */
697 void (*lang_expand_function_end) (void);
699 /* Nonzero means the expression being parsed will never be evaluated.
700 This is a count, since unevaluated expressions can nest. */
703 /* Information about how a function name is generated. */
706 tree *const decl; /* pointer to the VAR_DECL. */
707 const unsigned rid; /* RID number for the identifier. */
708 const int pretty; /* How pretty is it? */
711 /* The three ways of getting then name of the current function. */
713 const struct fname_var_t fname_vars[] =
715 /* C99 compliant __func__, must be first. */
716 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
717 /* GCC __FUNCTION__ compliant. */
718 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
719 /* GCC __PRETTY_FUNCTION__ compliant. */
720 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
724 static int constant_fits_type_p (tree, tree);
726 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
727 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
728 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
729 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
730 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
731 static tree handle_always_inline_attribute (tree *, tree, tree, int,
733 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
734 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
735 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
736 static tree handle_transparent_union_attribute (tree *, tree, tree,
738 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
739 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
740 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
741 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
742 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
743 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
744 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
745 static tree handle_visibility_attribute (tree *, tree, tree, int,
747 static tree handle_tls_model_attribute (tree *, tree, tree, int,
749 static tree handle_no_instrument_function_attribute (tree *, tree,
751 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
752 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
754 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
755 static tree handle_deprecated_attribute (tree *, tree, tree, int,
757 static tree handle_vector_size_attribute (tree *, tree, tree, int,
759 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
760 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
761 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
762 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
765 static void check_function_nonnull (tree, tree);
766 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
767 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
768 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
769 static int resort_field_decl_cmp (const void *, const void *);
771 /* Table of machine-independent attributes common to all C-like languages. */
772 const struct attribute_spec c_common_attribute_table[] =
774 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
775 { "packed", 0, 0, false, false, false,
776 handle_packed_attribute },
777 { "nocommon", 0, 0, true, false, false,
778 handle_nocommon_attribute },
779 { "common", 0, 0, true, false, false,
780 handle_common_attribute },
781 /* FIXME: logically, noreturn attributes should be listed as
782 "false, true, true" and apply to function types. But implementing this
783 would require all the places in the compiler that use TREE_THIS_VOLATILE
784 on a decl to identify non-returning functions to be located and fixed
785 to check the function type instead. */
786 { "noreturn", 0, 0, true, false, false,
787 handle_noreturn_attribute },
788 { "volatile", 0, 0, true, false, false,
789 handle_noreturn_attribute },
790 { "noinline", 0, 0, true, false, false,
791 handle_noinline_attribute },
792 { "always_inline", 0, 0, true, false, false,
793 handle_always_inline_attribute },
794 { "used", 0, 0, true, false, false,
795 handle_used_attribute },
796 { "unused", 0, 0, false, false, false,
797 handle_unused_attribute },
798 /* The same comments as for noreturn attributes apply to const ones. */
799 { "const", 0, 0, true, false, false,
800 handle_const_attribute },
801 { "transparent_union", 0, 0, false, false, false,
802 handle_transparent_union_attribute },
803 { "constructor", 0, 0, true, false, false,
804 handle_constructor_attribute },
805 { "destructor", 0, 0, true, false, false,
806 handle_destructor_attribute },
807 { "mode", 1, 1, false, true, false,
808 handle_mode_attribute },
809 { "section", 1, 1, true, false, false,
810 handle_section_attribute },
811 { "aligned", 0, 1, false, false, false,
812 handle_aligned_attribute },
813 { "weak", 0, 0, true, false, false,
814 handle_weak_attribute },
815 { "alias", 1, 1, true, false, false,
816 handle_alias_attribute },
817 { "no_instrument_function", 0, 0, true, false, false,
818 handle_no_instrument_function_attribute },
819 { "malloc", 0, 0, true, false, false,
820 handle_malloc_attribute },
821 { "no_stack_limit", 0, 0, true, false, false,
822 handle_no_limit_stack_attribute },
823 { "pure", 0, 0, true, false, false,
824 handle_pure_attribute },
825 { "deprecated", 0, 0, false, false, false,
826 handle_deprecated_attribute },
827 { "vector_size", 1, 1, false, true, false,
828 handle_vector_size_attribute },
829 { "visibility", 1, 1, true, false, false,
830 handle_visibility_attribute },
831 { "tls_model", 1, 1, true, false, false,
832 handle_tls_model_attribute },
833 { "nonnull", 0, -1, false, true, true,
834 handle_nonnull_attribute },
835 { "nothrow", 0, 0, true, false, false,
836 handle_nothrow_attribute },
837 { "may_alias", 0, 0, false, true, false, NULL },
838 { "cleanup", 1, 1, true, false, false,
839 handle_cleanup_attribute },
840 { "warn_unused_result", 0, 0, false, true, true,
841 handle_warn_unused_result_attribute },
842 { NULL, 0, 0, false, false, false, NULL }
845 /* Give the specifications for the format attributes, used by C and all
848 const struct attribute_spec c_common_format_attribute_table[] =
850 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
851 { "format", 3, 3, false, true, true,
852 handle_format_attribute },
853 { "format_arg", 1, 1, false, true, true,
854 handle_format_arg_attribute },
855 { NULL, 0, 0, false, false, false, NULL }
858 /* Push current bindings for the function name VAR_DECLS. */
861 start_fname_decls (void)
864 tree saved = NULL_TREE;
866 for (ix = 0; fname_vars[ix].decl; ix++)
868 tree decl = *fname_vars[ix].decl;
872 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
873 *fname_vars[ix].decl = NULL_TREE;
876 if (saved || saved_function_name_decls)
877 /* Normally they'll have been NULL, so only push if we've got a
878 stack, or they are non-NULL. */
879 saved_function_name_decls = tree_cons (saved, NULL_TREE,
880 saved_function_name_decls);
883 /* Finish up the current bindings, adding them into the current function's
884 statement tree. This must be done _before_ finish_stmt_tree is called.
885 If there is no current function, we must be at file scope and no statements
886 are involved. Pop the previous bindings. */
889 finish_fname_decls (void)
892 tree stmts = NULL_TREE;
893 tree stack = saved_function_name_decls;
895 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
896 append_to_statement_list (TREE_VALUE (stack), &stmts);
900 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
902 if (TREE_CODE (*bodyp) == COMPOUND_STMT)
903 bodyp = &COMPOUND_BODY (*bodyp);
904 if (TREE_CODE (*bodyp) == BIND_EXPR)
905 bodyp = &BIND_EXPR_BODY (*bodyp);
907 append_to_statement_list (*bodyp, &stmts);
911 for (ix = 0; fname_vars[ix].decl; ix++)
912 *fname_vars[ix].decl = NULL_TREE;
916 /* We had saved values, restore them. */
919 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
921 tree decl = TREE_PURPOSE (saved);
922 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
924 *fname_vars[ix].decl = decl;
926 stack = TREE_CHAIN (stack);
928 saved_function_name_decls = stack;
931 /* Return the text name of the current function, suitably prettified
932 by PRETTY_P. Return string must be freed by caller. */
935 fname_as_string (int pretty_p)
937 const char *name = "top level";
947 if (current_function_decl)
948 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
950 if (c_lex_string_translate)
952 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
953 cpp_string cstr = { 0, 0 }, strname;
955 namep = xmalloc (len);
956 snprintf (namep, len, "\"%s\"", name);
957 strname.text = (unsigned char *) namep;
958 strname.len = len - 1;
960 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
961 return (char *) cstr.text;
964 namep = xstrdup (name);
969 /* Expand DECL if it declares an entity not handled by the
973 c_expand_decl (tree decl)
975 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
977 /* Let the back-end know about this variable. */
978 if (!anon_aggr_type_p (TREE_TYPE (decl)))
979 emit_local_var (decl);
981 expand_anon_union_decl (decl, NULL_TREE,
982 DECL_ANON_UNION_ELEMS (decl));
984 else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
985 make_rtl_for_local_static (decl);
993 /* Return the VAR_DECL for a const char array naming the current
994 function. If the VAR_DECL has not yet been created, create it
995 now. RID indicates how it should be formatted and IDENTIFIER_NODE
996 ID is its name (unfortunately C and C++ hold the RID values of
997 keywords in different places, so we can't derive RID from ID in
998 this language independent code. */
1001 fname_decl (unsigned int rid, tree id)
1004 tree decl = NULL_TREE;
1006 for (ix = 0; fname_vars[ix].decl; ix++)
1007 if (fname_vars[ix].rid == rid)
1010 decl = *fname_vars[ix].decl;
1013 /* If a tree is built here, it would normally have the lineno of
1014 the current statement. Later this tree will be moved to the
1015 beginning of the function and this line number will be wrong.
1016 To avoid this problem set the lineno to 0 here; that prevents
1017 it from appearing in the RTL. */
1019 location_t saved_locus = input_location;
1022 stmts = push_stmt_list ();
1023 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1024 stmts = pop_stmt_list (stmts);
1025 if (!IS_EMPTY_STMT (stmts))
1026 saved_function_name_decls
1027 = tree_cons (decl, stmts, saved_function_name_decls);
1028 *fname_vars[ix].decl = decl;
1029 input_location = saved_locus;
1031 if (!ix && !current_function_decl)
1032 pedwarn ("%J'%D' is not defined outside of function scope", decl, decl);
1037 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1040 fix_string_type (tree value)
1042 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1043 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1044 const int nchars_max = flag_isoc99 ? 4095 : 509;
1045 int length = TREE_STRING_LENGTH (value);
1048 /* Compute the number of elements, for the array type. */
1049 nchars = wide_flag ? length / wchar_bytes : length;
1051 if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
1052 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1053 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1055 /* Create the array type for the string constant.
1056 -Wwrite-strings says make the string constant an array of const char
1057 so that copying it to a non-const pointer will get a warning.
1058 For C++, this is the standard behavior. */
1059 if (flag_const_strings)
1062 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1065 = build_array_type (elements,
1066 build_index_type (build_int_2 (nchars - 1, 0)));
1070 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1071 build_index_type (build_int_2 (nchars - 1, 0)));
1073 TREE_CONSTANT (value) = 1;
1074 TREE_INVARIANT (value) = 1;
1075 TREE_READONLY (value) = 1;
1076 TREE_STATIC (value) = 1;
1080 /* Print a warning if a constant expression had overflow in folding.
1081 Invoke this function on every expression that the language
1082 requires to be a constant expression.
1083 Note the ANSI C standard says it is erroneous for a
1084 constant expression to overflow. */
1087 constant_expression_warning (tree value)
1089 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1090 || TREE_CODE (value) == VECTOR_CST
1091 || TREE_CODE (value) == COMPLEX_CST)
1092 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1093 pedwarn ("overflow in constant expression");
1096 /* Print a warning if an expression had overflow in folding.
1097 Invoke this function on every expression that
1098 (1) appears in the source code, and
1099 (2) might be a constant expression that overflowed, and
1100 (3) is not already checked by convert_and_check;
1101 however, do not invoke this function on operands of explicit casts. */
1104 overflow_warning (tree value)
1106 if ((TREE_CODE (value) == INTEGER_CST
1107 || (TREE_CODE (value) == COMPLEX_CST
1108 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1109 && TREE_OVERFLOW (value))
1111 TREE_OVERFLOW (value) = 0;
1112 if (skip_evaluation == 0)
1113 warning ("integer overflow in expression");
1115 else if ((TREE_CODE (value) == REAL_CST
1116 || (TREE_CODE (value) == COMPLEX_CST
1117 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1118 && TREE_OVERFLOW (value))
1120 TREE_OVERFLOW (value) = 0;
1121 if (skip_evaluation == 0)
1122 warning ("floating point overflow in expression");
1124 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1126 TREE_OVERFLOW (value) = 0;
1127 if (skip_evaluation == 0)
1128 warning ("vector overflow in expression");
1132 /* Print a warning if a large constant is truncated to unsigned,
1133 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1134 Invoke this function on every expression that might be implicitly
1135 converted to an unsigned type. */
1138 unsigned_conversion_warning (tree result, tree operand)
1140 tree type = TREE_TYPE (result);
1142 if (TREE_CODE (operand) == INTEGER_CST
1143 && TREE_CODE (type) == INTEGER_TYPE
1144 && TYPE_UNSIGNED (type)
1145 && skip_evaluation == 0
1146 && !int_fits_type_p (operand, type))
1148 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1149 /* This detects cases like converting -129 or 256 to unsigned char. */
1150 warning ("large integer implicitly truncated to unsigned type");
1151 else if (warn_conversion)
1152 warning ("negative integer implicitly converted to unsigned type");
1156 /* Nonzero if constant C has a value that is permissible
1157 for type TYPE (an INTEGER_TYPE). */
1160 constant_fits_type_p (tree c, tree type)
1162 if (TREE_CODE (c) == INTEGER_CST)
1163 return int_fits_type_p (c, type);
1165 c = convert (type, c);
1166 return !TREE_OVERFLOW (c);
1169 /* Nonzero if vector types T1 and T2 can be converted to each other
1170 without an explicit cast. */
1172 vector_types_convertible_p (tree t1, tree t2)
1174 return targetm.vector_opaque_p (t1)
1175 || targetm.vector_opaque_p (t2)
1176 || TYPE_MODE (t1) == TYPE_MODE (t2);
1179 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1180 Invoke this function on every expression that is converted implicitly,
1181 i.e. because of language rules and not because of an explicit cast. */
1184 convert_and_check (tree type, tree expr)
1186 tree t = convert (type, expr);
1187 if (TREE_CODE (t) == INTEGER_CST)
1189 if (TREE_OVERFLOW (t))
1191 TREE_OVERFLOW (t) = 0;
1193 /* Do not diagnose overflow in a constant expression merely
1194 because a conversion overflowed. */
1195 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1197 /* No warning for converting 0x80000000 to int. */
1198 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
1199 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1200 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1201 /* If EXPR fits in the unsigned version of TYPE,
1202 don't warn unless pedantic. */
1204 || TYPE_UNSIGNED (type)
1205 || ! constant_fits_type_p (expr,
1206 c_common_unsigned_type (type)))
1207 && skip_evaluation == 0)
1208 warning ("overflow in implicit constant conversion");
1211 unsigned_conversion_warning (t, expr);
1216 /* A node in a list that describes references to variables (EXPR), which are
1217 either read accesses if WRITER is zero, or write accesses, in which case
1218 WRITER is the parent of EXPR. */
1225 /* Used to implement a cache the results of a call to verify_tree. We only
1226 use this for SAVE_EXPRs. */
1229 struct tlist_cache *next;
1230 struct tlist *cache_before_sp;
1231 struct tlist *cache_after_sp;
1235 /* Obstack to use when allocating tlist structures, and corresponding
1237 static struct obstack tlist_obstack;
1238 static char *tlist_firstobj = 0;
1240 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1242 static struct tlist *warned_ids;
1243 /* SAVE_EXPRs need special treatment. We process them only once and then
1244 cache the results. */
1245 static struct tlist_cache *save_expr_cache;
1247 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1248 static void merge_tlist (struct tlist **, struct tlist *, int);
1249 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1250 static int warning_candidate_p (tree);
1251 static void warn_for_collisions (struct tlist *);
1252 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1253 static struct tlist *new_tlist (struct tlist *, tree, tree);
1254 static void verify_sequence_points (tree);
1256 /* Create a new struct tlist and fill in its fields. */
1257 static struct tlist *
1258 new_tlist (struct tlist *next, tree t, tree writer)
1261 l = obstack_alloc (&tlist_obstack, sizeof *l);
1268 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1269 is nonnull, we ignore any node we find which has a writer equal to it. */
1272 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1276 struct tlist *next = add->next;
1279 if (! exclude_writer || add->writer != exclude_writer)
1280 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1285 /* Merge the nodes of ADD into TO. This merging process is done so that for
1286 each variable that already exists in TO, no new node is added; however if
1287 there is a write access recorded in ADD, and an occurrence on TO is only
1288 a read access, then the occurrence in TO will be modified to record the
1292 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1294 struct tlist **end = to;
1297 end = &(*end)->next;
1303 struct tlist *next = add->next;
1305 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1306 if (tmp2->expr == add->expr)
1310 tmp2->writer = add->writer;
1314 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1315 end = &(*end)->next;
1322 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1323 references in list LIST conflict with it, excluding reads if ONLY writers
1327 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1332 /* Avoid duplicate warnings. */
1333 for (tmp = warned_ids; tmp; tmp = tmp->next)
1334 if (tmp->expr == written)
1339 if (list->expr == written
1340 && list->writer != writer
1341 && (! only_writes || list->writer))
1343 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1344 warning ("operation on `%s' may be undefined",
1345 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1351 /* Given a list LIST of references to variables, find whether any of these
1352 can cause conflicts due to missing sequence points. */
1355 warn_for_collisions (struct tlist *list)
1359 for (tmp = list; tmp; tmp = tmp->next)
1362 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1366 /* Return nonzero if X is a tree that can be verified by the sequence point
1369 warning_candidate_p (tree x)
1371 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1374 /* Walk the tree X, and record accesses to variables. If X is written by the
1375 parent tree, WRITER is the parent.
1376 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1377 expression or its only operand forces a sequence point, then everything up
1378 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1380 Once we return, we will have emitted warnings if any subexpression before
1381 such a sequence point could be undefined. On a higher level, however, the
1382 sequence point may not be relevant, and we'll merge the two lists.
1384 Example: (b++, a) + b;
1385 The call that processes the COMPOUND_EXPR will store the increment of B
1386 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1387 processes the PLUS_EXPR will need to merge the two lists so that
1388 eventually, all accesses end up on the same list (and we'll warn about the
1389 unordered subexpressions b++ and b.
1391 A note on merging. If we modify the former example so that our expression
1394 care must be taken not simply to add all three expressions into the final
1395 PNO_SP list. The function merge_tlist takes care of that by merging the
1396 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1397 way, so that no more than one access to B is recorded. */
1400 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1403 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1404 enum tree_code code;
1407 /* X may be NULL if it is the operand of an empty statement expression
1413 code = TREE_CODE (x);
1414 class = TREE_CODE_CLASS (code);
1416 if (warning_candidate_p (x))
1418 *pno_sp = new_tlist (*pno_sp, x, writer);
1428 case TRUTH_ANDIF_EXPR:
1429 case TRUTH_ORIF_EXPR:
1430 tmp_before = tmp_nosp = tmp_list3 = 0;
1431 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1432 warn_for_collisions (tmp_nosp);
1433 merge_tlist (pbefore_sp, tmp_before, 0);
1434 merge_tlist (pbefore_sp, tmp_nosp, 0);
1435 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1436 merge_tlist (pbefore_sp, tmp_list3, 0);
1440 tmp_before = tmp_list2 = 0;
1441 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1442 warn_for_collisions (tmp_list2);
1443 merge_tlist (pbefore_sp, tmp_before, 0);
1444 merge_tlist (pbefore_sp, tmp_list2, 1);
1446 tmp_list3 = tmp_nosp = 0;
1447 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1448 warn_for_collisions (tmp_nosp);
1449 merge_tlist (pbefore_sp, tmp_list3, 0);
1451 tmp_list3 = tmp_list2 = 0;
1452 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1453 warn_for_collisions (tmp_list2);
1454 merge_tlist (pbefore_sp, tmp_list3, 0);
1455 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1456 two first, to avoid warning for (a ? b++ : b++). */
1457 merge_tlist (&tmp_nosp, tmp_list2, 0);
1458 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1461 case PREDECREMENT_EXPR:
1462 case PREINCREMENT_EXPR:
1463 case POSTDECREMENT_EXPR:
1464 case POSTINCREMENT_EXPR:
1465 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1469 tmp_before = tmp_nosp = tmp_list3 = 0;
1470 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1471 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1472 /* Expressions inside the LHS are not ordered wrt. the sequence points
1473 in the RHS. Example:
1475 Despite the fact that the modification of "a" is in the before_sp
1476 list (tmp_before), it conflicts with the use of "a" in the LHS.
1477 We can handle this by adding the contents of tmp_list3
1478 to those of tmp_before, and redoing the collision warnings for that
1480 add_tlist (&tmp_before, tmp_list3, x, 1);
1481 warn_for_collisions (tmp_before);
1482 /* Exclude the LHS itself here; we first have to merge it into the
1483 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1484 didn't exclude the LHS, we'd get it twice, once as a read and once
1486 add_tlist (pno_sp, tmp_list3, x, 0);
1487 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1489 merge_tlist (pbefore_sp, tmp_before, 0);
1490 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1491 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1492 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1496 /* We need to warn about conflicts among arguments and conflicts between
1497 args and the function address. Side effects of the function address,
1498 however, are not ordered by the sequence point of the call. */
1499 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1500 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1501 if (TREE_OPERAND (x, 1))
1502 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1503 merge_tlist (&tmp_list3, tmp_list2, 0);
1504 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1505 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1506 warn_for_collisions (tmp_before);
1507 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1511 /* Scan all the list, e.g. indices of multi dimensional array. */
1514 tmp_before = tmp_nosp = 0;
1515 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1516 merge_tlist (&tmp_nosp, tmp_before, 0);
1517 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1524 struct tlist_cache *t;
1525 for (t = save_expr_cache; t; t = t->next)
1531 t = obstack_alloc (&tlist_obstack, sizeof *t);
1532 t->next = save_expr_cache;
1534 save_expr_cache = t;
1536 tmp_before = tmp_nosp = 0;
1537 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1538 warn_for_collisions (tmp_nosp);
1543 struct tlist *t = tmp_nosp;
1545 merge_tlist (&tmp_list3, t, 0);
1547 t->cache_before_sp = tmp_before;
1548 t->cache_after_sp = tmp_list3;
1550 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1551 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1560 if (first_rtl_op (code) == 0)
1562 x = TREE_OPERAND (x, 0);
1577 int max = first_rtl_op (TREE_CODE (x));
1578 for (lp = 0; lp < max; lp++)
1580 tmp_before = tmp_nosp = 0;
1581 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1582 merge_tlist (&tmp_nosp, tmp_before, 0);
1583 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1590 /* Try to warn for undefined behavior in EXPR due to missing sequence
1594 verify_sequence_points (tree expr)
1596 struct tlist *before_sp = 0, *after_sp = 0;
1599 save_expr_cache = 0;
1600 if (tlist_firstobj == 0)
1602 gcc_obstack_init (&tlist_obstack);
1603 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1606 verify_tree (expr, &before_sp, &after_sp, 0);
1607 warn_for_collisions (after_sp);
1608 obstack_free (&tlist_obstack, tlist_firstobj);
1612 c_expand_expr_stmt (tree expr)
1614 /* Do default conversion if safe and possibly important,
1615 in case within ({...}). */
1616 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1617 && (flag_isoc99 || lvalue_p (expr)))
1618 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1619 expr = default_conversion (expr);
1621 if (warn_sequence_point)
1622 verify_sequence_points (expr);
1624 if (TREE_TYPE (expr) != error_mark_node
1625 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1626 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1627 error ("expression statement has incomplete type");
1629 /* As tempting as it might be, we can't diagnose statement with no
1630 effect yet. We have to wait until after statement expressions
1631 have been parsed, and that process modifies the trees we are
1634 return add_stmt (build_stmt (EXPR_STMT, expr));
1637 /* Validate the expression after `case' and apply default promotions. */
1640 check_case_value (tree value)
1642 if (value == NULL_TREE)
1645 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1646 STRIP_TYPE_NOPS (value);
1647 /* In C++, the following is allowed:
1650 switch (...) { case i: ... }
1652 So, we try to reduce the VALUE to a constant that way. */
1653 if (c_dialect_cxx ())
1655 value = decl_constant_value (value);
1656 STRIP_TYPE_NOPS (value);
1657 value = fold (value);
1660 if (TREE_CODE (value) != INTEGER_CST
1661 && value != error_mark_node)
1663 error ("case label does not reduce to an integer constant");
1664 value = error_mark_node;
1667 /* Promote char or short to int. */
1668 value = default_conversion (value);
1670 constant_expression_warning (value);
1675 /* Return an integer type with BITS bits of precision,
1676 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1679 c_common_type_for_size (unsigned int bits, int unsignedp)
1681 if (bits == TYPE_PRECISION (integer_type_node))
1682 return unsignedp ? unsigned_type_node : integer_type_node;
1684 if (bits == TYPE_PRECISION (signed_char_type_node))
1685 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1687 if (bits == TYPE_PRECISION (short_integer_type_node))
1688 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1690 if (bits == TYPE_PRECISION (long_integer_type_node))
1691 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1693 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1694 return (unsignedp ? long_long_unsigned_type_node
1695 : long_long_integer_type_node);
1697 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1698 return (unsignedp ? widest_unsigned_literal_type_node
1699 : widest_integer_literal_type_node);
1701 if (bits <= TYPE_PRECISION (intQI_type_node))
1702 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1704 if (bits <= TYPE_PRECISION (intHI_type_node))
1705 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1707 if (bits <= TYPE_PRECISION (intSI_type_node))
1708 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1710 if (bits <= TYPE_PRECISION (intDI_type_node))
1711 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1716 /* Used for communication between c_common_type_for_mode and
1717 c_register_builtin_type. */
1718 static GTY(()) tree registered_builtin_types;
1720 /* Return a data type that has machine mode MODE.
1721 If the mode is an integer,
1722 then UNSIGNEDP selects between signed and unsigned types. */
1725 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1729 if (mode == TYPE_MODE (integer_type_node))
1730 return unsignedp ? unsigned_type_node : integer_type_node;
1732 if (mode == TYPE_MODE (signed_char_type_node))
1733 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1735 if (mode == TYPE_MODE (short_integer_type_node))
1736 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1738 if (mode == TYPE_MODE (long_integer_type_node))
1739 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1741 if (mode == TYPE_MODE (long_long_integer_type_node))
1742 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1744 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1745 return unsignedp ? widest_unsigned_literal_type_node
1746 : widest_integer_literal_type_node;
1749 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1752 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1755 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1758 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1760 #if HOST_BITS_PER_WIDE_INT >= 64
1761 if (mode == TYPE_MODE (intTI_type_node))
1762 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1765 if (mode == TYPE_MODE (float_type_node))
1766 return float_type_node;
1768 if (mode == TYPE_MODE (double_type_node))
1769 return double_type_node;
1771 if (mode == TYPE_MODE (long_double_type_node))
1772 return long_double_type_node;
1774 if (mode == TYPE_MODE (void_type_node))
1775 return void_type_node;
1777 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1778 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1780 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1781 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1783 if (VECTOR_MODE_P (mode))
1785 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1786 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1787 if (inner_type != NULL_TREE)
1788 return build_vector_type_for_mode (inner_type, mode);
1791 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1792 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1793 return TREE_VALUE (t);
1798 /* Return an unsigned type the same as TYPE in other respects. */
1800 c_common_unsigned_type (tree type)
1802 tree type1 = TYPE_MAIN_VARIANT (type);
1803 if (type1 == signed_char_type_node || type1 == char_type_node)
1804 return unsigned_char_type_node;
1805 if (type1 == integer_type_node)
1806 return unsigned_type_node;
1807 if (type1 == short_integer_type_node)
1808 return short_unsigned_type_node;
1809 if (type1 == long_integer_type_node)
1810 return long_unsigned_type_node;
1811 if (type1 == long_long_integer_type_node)
1812 return long_long_unsigned_type_node;
1813 if (type1 == widest_integer_literal_type_node)
1814 return widest_unsigned_literal_type_node;
1815 #if HOST_BITS_PER_WIDE_INT >= 64
1816 if (type1 == intTI_type_node)
1817 return unsigned_intTI_type_node;
1819 if (type1 == intDI_type_node)
1820 return unsigned_intDI_type_node;
1821 if (type1 == intSI_type_node)
1822 return unsigned_intSI_type_node;
1823 if (type1 == intHI_type_node)
1824 return unsigned_intHI_type_node;
1825 if (type1 == intQI_type_node)
1826 return unsigned_intQI_type_node;
1828 return c_common_signed_or_unsigned_type (1, type);
1831 /* Return a signed type the same as TYPE in other respects. */
1834 c_common_signed_type (tree type)
1836 tree type1 = TYPE_MAIN_VARIANT (type);
1837 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1838 return signed_char_type_node;
1839 if (type1 == unsigned_type_node)
1840 return integer_type_node;
1841 if (type1 == short_unsigned_type_node)
1842 return short_integer_type_node;
1843 if (type1 == long_unsigned_type_node)
1844 return long_integer_type_node;
1845 if (type1 == long_long_unsigned_type_node)
1846 return long_long_integer_type_node;
1847 if (type1 == widest_unsigned_literal_type_node)
1848 return widest_integer_literal_type_node;
1849 #if HOST_BITS_PER_WIDE_INT >= 64
1850 if (type1 == unsigned_intTI_type_node)
1851 return intTI_type_node;
1853 if (type1 == unsigned_intDI_type_node)
1854 return intDI_type_node;
1855 if (type1 == unsigned_intSI_type_node)
1856 return intSI_type_node;
1857 if (type1 == unsigned_intHI_type_node)
1858 return intHI_type_node;
1859 if (type1 == unsigned_intQI_type_node)
1860 return intQI_type_node;
1862 return c_common_signed_or_unsigned_type (0, type);
1865 /* Return a type the same as TYPE except unsigned or
1866 signed according to UNSIGNEDP. */
1869 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1871 if (! INTEGRAL_TYPE_P (type)
1872 || TYPE_UNSIGNED (type) == unsignedp)
1875 /* Must check the mode of the types, not the precision. Enumeral types
1876 in C++ have precision set to match their range, but may use a wider
1877 mode to match an ABI. If we change modes, we may wind up with bad
1880 if (TYPE_MODE (type) == TYPE_MODE (signed_char_type_node))
1881 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1882 if (TYPE_MODE (type) == TYPE_MODE (integer_type_node))
1883 return unsignedp ? unsigned_type_node : integer_type_node;
1884 if (TYPE_MODE (type) == TYPE_MODE (short_integer_type_node))
1885 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1886 if (TYPE_MODE (type) == TYPE_MODE (long_integer_type_node))
1887 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1888 if (TYPE_MODE (type) == TYPE_MODE (long_long_integer_type_node))
1889 return (unsignedp ? long_long_unsigned_type_node
1890 : long_long_integer_type_node);
1891 if (TYPE_MODE (type) == TYPE_MODE (widest_integer_literal_type_node))
1892 return (unsignedp ? widest_unsigned_literal_type_node
1893 : widest_integer_literal_type_node);
1895 #if HOST_BITS_PER_WIDE_INT >= 64
1896 if (TYPE_MODE (type) == TYPE_MODE (intTI_type_node))
1897 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1899 if (TYPE_MODE (type) == TYPE_MODE (intDI_type_node))
1900 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1901 if (TYPE_MODE (type) == TYPE_MODE (intSI_type_node))
1902 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1903 if (TYPE_MODE (type) == TYPE_MODE (intHI_type_node))
1904 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1905 if (TYPE_MODE (type) == TYPE_MODE (intQI_type_node))
1906 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1911 /* The C version of the register_builtin_type langhook. */
1914 c_register_builtin_type (tree type, const char* name)
1918 decl = build_decl (TYPE_DECL, get_identifier (name), type);
1919 DECL_ARTIFICIAL (decl) = 1;
1920 if (!TYPE_NAME (type))
1921 TYPE_NAME (type) = decl;
1924 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1928 /* Return the minimum number of bits needed to represent VALUE in a
1929 signed or unsigned type, UNSIGNEDP says which. */
1932 min_precision (tree value, int unsignedp)
1936 /* If the value is negative, compute its negative minus 1. The latter
1937 adjustment is because the absolute value of the largest negative value
1938 is one larger than the largest positive value. This is equivalent to
1939 a bit-wise negation, so use that operation instead. */
1941 if (tree_int_cst_sgn (value) < 0)
1942 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1944 /* Return the number of bits needed, taking into account the fact
1945 that we need one more bit for a signed than unsigned type. */
1947 if (integer_zerop (value))
1950 log = tree_floor_log2 (value);
1952 return log + 1 + ! unsignedp;
1955 /* Print an error message for invalid operands to arith operation
1956 CODE. NOP_EXPR is used as a special case (see
1957 c_common_truthvalue_conversion). */
1960 binary_op_error (enum tree_code code)
1967 error ("invalid truth-value expression");
1971 opname = "+"; break;
1973 opname = "-"; break;
1975 opname = "*"; break;
1977 opname = "max"; break;
1979 opname = "min"; break;
1981 opname = "=="; break;
1983 opname = "!="; break;
1985 opname = "<="; break;
1987 opname = ">="; break;
1989 opname = "<"; break;
1991 opname = ">"; break;
1993 opname = "<<"; break;
1995 opname = ">>"; break;
1996 case TRUNC_MOD_EXPR:
1997 case FLOOR_MOD_EXPR:
1998 opname = "%"; break;
1999 case TRUNC_DIV_EXPR:
2000 case FLOOR_DIV_EXPR:
2001 opname = "/"; break;
2003 opname = "&"; break;
2005 opname = "|"; break;
2006 case TRUTH_ANDIF_EXPR:
2007 opname = "&&"; break;
2008 case TRUTH_ORIF_EXPR:
2009 opname = "||"; break;
2011 opname = "^"; break;
2014 opname = "rotate"; break;
2016 opname = "unknown"; break;
2018 error ("invalid operands to binary %s", opname);
2021 /* Subroutine of build_binary_op, used for comparison operations.
2022 See if the operands have both been converted from subword integer types
2023 and, if so, perhaps change them both back to their original type.
2024 This function is also responsible for converting the two operands
2025 to the proper common type for comparison.
2027 The arguments of this function are all pointers to local variables
2028 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2029 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2031 If this function returns nonzero, it means that the comparison has
2032 a constant value. What this function returns is an expression for
2036 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2037 enum tree_code *rescode_ptr)
2040 tree op0 = *op0_ptr;
2041 tree op1 = *op1_ptr;
2042 int unsignedp0, unsignedp1;
2044 tree primop0, primop1;
2045 enum tree_code code = *rescode_ptr;
2047 /* Throw away any conversions to wider types
2048 already present in the operands. */
2050 primop0 = get_narrower (op0, &unsignedp0);
2051 primop1 = get_narrower (op1, &unsignedp1);
2053 /* Handle the case that OP0 does not *contain* a conversion
2054 but it *requires* conversion to FINAL_TYPE. */
2056 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2057 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2058 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2059 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2061 /* If one of the operands must be floated, we cannot optimize. */
2062 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2063 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2065 /* If first arg is constant, swap the args (changing operation
2066 so value is preserved), for canonicalization. Don't do this if
2067 the second arg is 0. */
2069 if (TREE_CONSTANT (primop0)
2070 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2073 int temi = unsignedp0;
2081 unsignedp0 = unsignedp1;
2104 *rescode_ptr = code;
2107 /* If comparing an integer against a constant more bits wide,
2108 maybe we can deduce a value of 1 or 0 independent of the data.
2109 Or else truncate the constant now
2110 rather than extend the variable at run time.
2112 This is only interesting if the constant is the wider arg.
2113 Also, it is not safe if the constant is unsigned and the
2114 variable arg is signed, since in this case the variable
2115 would be sign-extended and then regarded as unsigned.
2116 Our technique fails in this case because the lowest/highest
2117 possible unsigned results don't follow naturally from the
2118 lowest/highest possible values of the variable operand.
2119 For just EQ_EXPR and NE_EXPR there is another technique that
2120 could be used: see if the constant can be faithfully represented
2121 in the other operand's type, by truncating it and reextending it
2122 and see if that preserves the constant's value. */
2124 if (!real1 && !real2
2125 && TREE_CODE (primop1) == INTEGER_CST
2126 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2128 int min_gt, max_gt, min_lt, max_lt;
2129 tree maxval, minval;
2130 /* 1 if comparison is nominally unsigned. */
2131 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2134 type = c_common_signed_or_unsigned_type (unsignedp0,
2135 TREE_TYPE (primop0));
2137 /* In C, if TYPE is an enumeration, then we need to get its
2138 min/max values from its underlying integral type, not the
2139 enumerated type itself. In C++, TYPE_MAX_VALUE and
2140 TYPE_MIN_VALUE have already been set correctly on the
2141 enumeration type. */
2142 if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
2143 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2145 maxval = TYPE_MAX_VALUE (type);
2146 minval = TYPE_MIN_VALUE (type);
2148 if (unsignedp && !unsignedp0)
2149 *restype_ptr = c_common_signed_type (*restype_ptr);
2151 if (TREE_TYPE (primop1) != *restype_ptr)
2152 primop1 = convert (*restype_ptr, primop1);
2153 if (type != *restype_ptr)
2155 minval = convert (*restype_ptr, minval);
2156 maxval = convert (*restype_ptr, maxval);
2159 if (unsignedp && unsignedp0)
2161 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2162 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2163 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2164 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2168 min_gt = INT_CST_LT (primop1, minval);
2169 max_gt = INT_CST_LT (primop1, maxval);
2170 min_lt = INT_CST_LT (minval, primop1);
2171 max_lt = INT_CST_LT (maxval, primop1);
2175 /* This used to be a switch, but Genix compiler can't handle that. */
2176 if (code == NE_EXPR)
2178 if (max_lt || min_gt)
2179 val = truthvalue_true_node;
2181 else if (code == EQ_EXPR)
2183 if (max_lt || min_gt)
2184 val = truthvalue_false_node;
2186 else if (code == LT_EXPR)
2189 val = truthvalue_true_node;
2191 val = truthvalue_false_node;
2193 else if (code == GT_EXPR)
2196 val = truthvalue_true_node;
2198 val = truthvalue_false_node;
2200 else if (code == LE_EXPR)
2203 val = truthvalue_true_node;
2205 val = truthvalue_false_node;
2207 else if (code == GE_EXPR)
2210 val = truthvalue_true_node;
2212 val = truthvalue_false_node;
2215 /* If primop0 was sign-extended and unsigned comparison specd,
2216 we did a signed comparison above using the signed type bounds.
2217 But the comparison we output must be unsigned.
2219 Also, for inequalities, VAL is no good; but if the signed
2220 comparison had *any* fixed result, it follows that the
2221 unsigned comparison just tests the sign in reverse
2222 (positive values are LE, negative ones GE).
2223 So we can generate an unsigned comparison
2224 against an extreme value of the signed type. */
2226 if (unsignedp && !unsignedp0)
2233 primop1 = TYPE_MIN_VALUE (type);
2239 primop1 = TYPE_MAX_VALUE (type);
2246 type = c_common_unsigned_type (type);
2249 if (TREE_CODE (primop0) != INTEGER_CST)
2251 if (val == truthvalue_false_node)
2252 warning ("comparison is always false due to limited range of data type");
2253 if (val == truthvalue_true_node)
2254 warning ("comparison is always true due to limited range of data type");
2259 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2260 if (TREE_SIDE_EFFECTS (primop0))
2261 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2265 /* Value is not predetermined, but do the comparison
2266 in the type of the operand that is not constant.
2267 TYPE is already properly set. */
2269 else if (real1 && real2
2270 && (TYPE_PRECISION (TREE_TYPE (primop0))
2271 == TYPE_PRECISION (TREE_TYPE (primop1))))
2272 type = TREE_TYPE (primop0);
2274 /* If args' natural types are both narrower than nominal type
2275 and both extend in the same manner, compare them
2276 in the type of the wider arg.
2277 Otherwise must actually extend both to the nominal
2278 common type lest different ways of extending
2280 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2282 else if (unsignedp0 == unsignedp1 && real1 == real2
2283 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2284 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2286 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2287 type = c_common_signed_or_unsigned_type (unsignedp0
2288 || TYPE_UNSIGNED (*restype_ptr),
2290 /* Make sure shorter operand is extended the right way
2291 to match the longer operand. */
2293 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2294 TREE_TYPE (primop0)),
2297 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2298 TREE_TYPE (primop1)),
2303 /* Here we must do the comparison on the nominal type
2304 using the args exactly as we received them. */
2305 type = *restype_ptr;
2309 if (!real1 && !real2 && integer_zerop (primop1)
2310 && TYPE_UNSIGNED (*restype_ptr))
2316 /* All unsigned values are >= 0, so we warn if extra warnings
2317 are requested. However, if OP0 is a constant that is
2318 >= 0, the signedness of the comparison isn't an issue,
2319 so suppress the warning. */
2320 if (extra_warnings && !in_system_header
2321 && ! (TREE_CODE (primop0) == INTEGER_CST
2322 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2324 warning ("comparison of unsigned expression >= 0 is always true");
2325 value = truthvalue_true_node;
2329 if (extra_warnings && !in_system_header
2330 && ! (TREE_CODE (primop0) == INTEGER_CST
2331 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2333 warning ("comparison of unsigned expression < 0 is always false");
2334 value = truthvalue_false_node;
2343 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2344 if (TREE_SIDE_EFFECTS (primop0))
2345 return build (COMPOUND_EXPR, TREE_TYPE (value),
2352 *op0_ptr = convert (type, primop0);
2353 *op1_ptr = convert (type, primop1);
2355 *restype_ptr = truthvalue_type_node;
2360 /* Return a tree for the sum or difference (RESULTCODE says which)
2361 of pointer PTROP and integer INTOP. */
2364 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2368 /* The result is a pointer of the same type that is being added. */
2370 tree result_type = TREE_TYPE (ptrop);
2372 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2374 if (pedantic || warn_pointer_arith)
2375 pedwarn ("pointer of type `void *' used in arithmetic");
2376 size_exp = integer_one_node;
2378 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2380 if (pedantic || warn_pointer_arith)
2381 pedwarn ("pointer to a function used in arithmetic");
2382 size_exp = integer_one_node;
2384 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2386 if (pedantic || warn_pointer_arith)
2387 pedwarn ("pointer to member function used in arithmetic");
2388 size_exp = integer_one_node;
2391 size_exp = size_in_bytes (TREE_TYPE (result_type));
2393 /* If what we are about to multiply by the size of the elements
2394 contains a constant term, apply distributive law
2395 and multiply that constant term separately.
2396 This helps produce common subexpressions. */
2398 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2399 && ! TREE_CONSTANT (intop)
2400 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2401 && TREE_CONSTANT (size_exp)
2402 /* If the constant comes from pointer subtraction,
2403 skip this optimization--it would cause an error. */
2404 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2405 /* If the constant is unsigned, and smaller than the pointer size,
2406 then we must skip this optimization. This is because it could cause
2407 an overflow error if the constant is negative but INTOP is not. */
2408 && (! TYPE_UNSIGNED (TREE_TYPE (intop))
2409 || (TYPE_PRECISION (TREE_TYPE (intop))
2410 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2412 enum tree_code subcode = resultcode;
2413 tree int_type = TREE_TYPE (intop);
2414 if (TREE_CODE (intop) == MINUS_EXPR)
2415 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2416 /* Convert both subexpression types to the type of intop,
2417 because weird cases involving pointer arithmetic
2418 can result in a sum or difference with different type args. */
2419 ptrop = build_binary_op (subcode, ptrop,
2420 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2421 intop = convert (int_type, TREE_OPERAND (intop, 0));
2424 /* Convert the integer argument to a type the same size as sizetype
2425 so the multiply won't overflow spuriously. */
2427 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2428 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2429 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2430 TYPE_UNSIGNED (sizetype)), intop);
2432 /* Replace the integer argument with a suitable product by the object size.
2433 Do this multiplication as signed, then convert to the appropriate
2434 pointer type (actually unsigned integral). */
2436 intop = convert (result_type,
2437 build_binary_op (MULT_EXPR, intop,
2438 convert (TREE_TYPE (intop), size_exp), 1));
2440 /* Create the sum or difference. */
2441 return fold (build (resultcode, result_type, ptrop, intop));
2444 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2445 or validate its data type for an `if' or `while' statement or ?..: exp.
2447 This preparation consists of taking the ordinary
2448 representation of an expression expr and producing a valid tree
2449 boolean expression describing whether expr is nonzero. We could
2450 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2451 but we optimize comparisons, &&, ||, and !.
2453 The resulting type should always be `truthvalue_type_node'. */
2456 c_common_truthvalue_conversion (tree expr)
2458 if (TREE_CODE (expr) == ERROR_MARK)
2461 if (TREE_CODE (expr) == FUNCTION_DECL)
2462 expr = build_unary_op (ADDR_EXPR, expr, 0);
2464 switch (TREE_CODE (expr))
2466 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2467 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2468 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2469 case ORDERED_EXPR: case UNORDERED_EXPR:
2470 case TRUTH_ANDIF_EXPR:
2471 case TRUTH_ORIF_EXPR:
2472 case TRUTH_AND_EXPR:
2474 case TRUTH_XOR_EXPR:
2475 case TRUTH_NOT_EXPR:
2476 TREE_TYPE (expr) = truthvalue_type_node;
2483 return integer_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2486 return real_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2490 if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2491 && ! DECL_WEAK (TREE_OPERAND (expr, 0)))
2493 /* Common Ada/Pascal programmer's mistake. We always warn
2494 about this since it is so bad. */
2495 warning ("the address of `%D', will always evaluate as `true'",
2496 TREE_OPERAND (expr, 0));
2497 return truthvalue_true_node;
2500 /* If we are taking the address of an external decl, it might be
2501 zero if it is weak, so we cannot optimize. */
2502 if (DECL_P (TREE_OPERAND (expr, 0))
2503 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2506 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2507 return build (COMPOUND_EXPR, truthvalue_type_node,
2508 TREE_OPERAND (expr, 0), truthvalue_true_node);
2510 return truthvalue_true_node;
2514 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2515 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2516 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)),
2517 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2523 /* These don't change whether an object is nonzero or zero. */
2524 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2528 /* These don't change whether an object is zero or nonzero, but
2529 we can't ignore them if their second arg has side-effects. */
2530 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2531 return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1),
2532 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)));
2534 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2537 /* Distribute the conversion into the arms of a COND_EXPR. */
2538 return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0),
2539 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2540 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 2))));
2543 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2544 since that affects how `default_conversion' will behave. */
2545 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2546 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2548 /* Fall through.... */
2550 /* If this is widening the argument, we can ignore it. */
2551 if (TYPE_PRECISION (TREE_TYPE (expr))
2552 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2553 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2557 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2558 aren't guaranteed to the be same for modes that can represent
2559 infinity, since if x and y are both +infinity, or both
2560 -infinity, then x - y is not a number.
2562 Note that this transformation is safe when x or y is NaN.
2563 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2565 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2567 /* Fall through.... */
2569 /* This and MINUS_EXPR can be changed into a comparison of the
2571 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2572 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2573 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2574 TREE_OPERAND (expr, 1), 1);
2575 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2576 fold (build1 (NOP_EXPR,
2577 TREE_TYPE (TREE_OPERAND (expr, 0)),
2578 TREE_OPERAND (expr, 1))), 1);
2581 if (integer_onep (TREE_OPERAND (expr, 1))
2582 && TREE_TYPE (expr) != truthvalue_type_node)
2583 /* Using convert here would cause infinite recursion. */
2584 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2588 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2589 warning ("suggest parentheses around assignment used as truth value");
2596 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2598 tree t = save_expr (expr);
2599 return (build_binary_op
2600 ((TREE_SIDE_EFFECTS (expr)
2601 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2602 lang_hooks.truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2603 lang_hooks.truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2607 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2610 static tree builtin_function_2 (const char *, const char *, tree, tree,
2611 int, enum built_in_class, int, int,
2614 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2615 down to the element type of an array. */
2618 c_build_qualified_type (tree type, int type_quals)
2620 if (type == error_mark_node)
2623 if (TREE_CODE (type) == ARRAY_TYPE)
2624 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2626 TYPE_DOMAIN (type));
2628 /* A restrict-qualified pointer type must be a pointer to object or
2629 incomplete type. Note that the use of POINTER_TYPE_P also allows
2630 REFERENCE_TYPEs, which is appropriate for C++. */
2631 if ((type_quals & TYPE_QUAL_RESTRICT)
2632 && (!POINTER_TYPE_P (type)
2633 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2635 error ("invalid use of `restrict'");
2636 type_quals &= ~TYPE_QUAL_RESTRICT;
2639 return build_qualified_type (type, type_quals);
2642 /* Apply the TYPE_QUALS to the new DECL. */
2645 c_apply_type_quals_to_decl (int type_quals, tree decl)
2647 tree type = TREE_TYPE (decl);
2649 if (type == error_mark_node)
2652 if (((type_quals & TYPE_QUAL_CONST)
2653 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2654 /* An object declared 'const' is only readonly after it is
2655 initialized. We don't have any way of expressing this currently,
2656 so we need to be conservative and unset TREE_READONLY for types
2657 with constructors. Otherwise aliasing code will ignore stores in
2658 an inline constructor. */
2659 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2660 TREE_READONLY (decl) = 1;
2661 if (type_quals & TYPE_QUAL_VOLATILE)
2663 TREE_SIDE_EFFECTS (decl) = 1;
2664 TREE_THIS_VOLATILE (decl) = 1;
2666 if (type_quals & TYPE_QUAL_RESTRICT)
2668 while (type && TREE_CODE (type) == ARRAY_TYPE)
2669 /* Allow 'restrict' on arrays of pointers.
2670 FIXME currently we just ignore it. */
2671 type = TREE_TYPE (type);
2673 || !POINTER_TYPE_P (type)
2674 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2675 error ("invalid use of `restrict'");
2676 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2677 /* Indicate we need to make a unique alias set for this pointer.
2678 We can't do it here because it might be pointing to an
2680 DECL_POINTER_ALIAS_SET (decl) = -2;
2684 /* Hash function for the problem of multiple type definitions in
2685 different files. This must hash all types that will compare
2686 equal via comptypes to the same value. In practice it hashes
2687 on some of the simple stuff and leaves the details to comptypes. */
2690 c_type_hash (const void *p)
2696 switch (TREE_CODE (t))
2698 /* For pointers, hash on pointee type plus some swizzling. */
2700 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2701 /* Hash on number of elements and total size. */
2704 t2 = TYPE_VALUES (t);
2708 t2 = TYPE_FIELDS (t);
2710 case QUAL_UNION_TYPE:
2712 t2 = TYPE_FIELDS (t);
2716 t2 = TYPE_FIELDS (t);
2721 for (; t2; t2 = TREE_CHAIN (t2))
2723 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2724 return ((size << 24) | (i << shift));
2727 /* Return the typed-based alias set for T, which may be an expression
2728 or a type. Return -1 if we don't do anything special. */
2731 c_common_get_alias_set (tree t)
2735 static htab_t type_hash_table;
2737 /* Permit type-punning when accessing a union, provided the access
2738 is directly through the union. For example, this code does not
2739 permit taking the address of a union member and then storing
2740 through it. Even the type-punning allowed here is a GCC
2741 extension, albeit a common and useful one; the C standard says
2742 that such accesses have implementation-defined behavior. */
2744 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2745 u = TREE_OPERAND (u, 0))
2746 if (TREE_CODE (u) == COMPONENT_REF
2747 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2750 /* That's all the expressions we handle specially. */
2754 /* The C standard guarantees that any object may be accessed via an
2755 lvalue that has character type. */
2756 if (t == char_type_node
2757 || t == signed_char_type_node
2758 || t == unsigned_char_type_node)
2761 /* If it has the may_alias attribute, it can alias anything. */
2762 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2765 /* The C standard specifically allows aliasing between signed and
2766 unsigned variants of the same type. We treat the signed
2767 variant as canonical. */
2768 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2770 tree t1 = c_common_signed_type (t);
2772 /* t1 == t can happen for boolean nodes which are always unsigned. */
2774 return get_alias_set (t1);
2776 else if (POINTER_TYPE_P (t))
2780 /* Unfortunately, there is no canonical form of a pointer type.
2781 In particular, if we have `typedef int I', then `int *', and
2782 `I *' are different types. So, we have to pick a canonical
2783 representative. We do this below.
2785 Technically, this approach is actually more conservative that
2786 it needs to be. In particular, `const int *' and `int *'
2787 should be in different alias sets, according to the C and C++
2788 standard, since their types are not the same, and so,
2789 technically, an `int **' and `const int **' cannot point at
2792 But, the standard is wrong. In particular, this code is
2797 const int* const* cipp = ipp;
2799 And, it doesn't make sense for that to be legal unless you
2800 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2801 the pointed-to types. This issue has been reported to the
2803 t1 = build_type_no_quals (t);
2805 return get_alias_set (t1);
2808 /* Handle the case of multiple type nodes referring to "the same" type,
2809 which occurs with IMA. These share an alias set. FIXME: Currently only
2810 C90 is handled. (In C99 type compatibility is not transitive, which
2811 complicates things mightily. The alias set splay trees can theoretically
2812 represent this, but insertion is tricky when you consider all the
2813 different orders things might arrive in.) */
2815 if (c_language != clk_c || flag_isoc99)
2818 /* Save time if there's only one input file. */
2819 if (!current_file_decl || TREE_CHAIN (current_file_decl) == NULL_TREE)
2822 /* Pointers need special handling if they point to any type that
2823 needs special handling (below). */
2824 if (TREE_CODE (t) == POINTER_TYPE)
2827 /* Find bottom type under any nested POINTERs. */
2828 for (t2 = TREE_TYPE (t);
2829 TREE_CODE (t2) == POINTER_TYPE;
2830 t2 = TREE_TYPE (t2))
2832 if (TREE_CODE (t2) != RECORD_TYPE
2833 && TREE_CODE (t2) != ENUMERAL_TYPE
2834 && TREE_CODE (t2) != QUAL_UNION_TYPE
2835 && TREE_CODE (t2) != UNION_TYPE)
2837 if (TYPE_SIZE (t2) == 0)
2840 /* These are the only cases that need special handling. */
2841 if (TREE_CODE (t) != RECORD_TYPE
2842 && TREE_CODE (t) != ENUMERAL_TYPE
2843 && TREE_CODE (t) != QUAL_UNION_TYPE
2844 && TREE_CODE (t) != UNION_TYPE
2845 && TREE_CODE (t) != POINTER_TYPE)
2848 if (TYPE_SIZE (t) == 0)
2851 /* Look up t in hash table. Only one of the compatible types within each
2852 alias set is recorded in the table. */
2853 if (!type_hash_table)
2854 type_hash_table = htab_create (1021, c_type_hash,
2855 (htab_eq) lang_hooks.types_compatible_p,
2857 slot = htab_find_slot (type_hash_table, t, INSERT);
2859 return TYPE_ALIAS_SET ((tree)*slot);
2861 /* Our caller will assign and record (in t) a new alias set; all we need
2862 to do is remember t in the hash table. */
2868 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2869 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2870 flag controls whether we should diagnose possibly ill-formed
2871 constructs or not. */
2873 c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2875 const char *op_name;
2877 enum tree_code type_code = TREE_CODE (type);
2879 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
2880 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2882 if (type_code == FUNCTION_TYPE)
2884 if (op == SIZEOF_EXPR)
2886 if (complain && (pedantic || warn_pointer_arith))
2887 pedwarn ("invalid application of `sizeof' to a function type");
2888 value = size_one_node;
2891 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2893 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2895 if (type_code == VOID_TYPE
2896 && complain && (pedantic || warn_pointer_arith))
2897 pedwarn ("invalid application of `%s' to a void type", op_name);
2898 value = size_one_node;
2900 else if (!COMPLETE_TYPE_P (type))
2903 error ("invalid application of `%s' to incomplete type `%T' ",
2905 value = size_zero_node;
2909 if (op == SIZEOF_EXPR)
2910 /* Convert in case a char is more than one unit. */
2911 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2912 size_int (TYPE_PRECISION (char_type_node)
2915 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2918 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2919 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2920 never happen. However, this node should really have type
2921 `size_t', which is just a typedef for an ordinary integer type. */
2922 value = fold (build1 (NOP_EXPR, size_type_node, value));
2923 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
2928 /* Implement the __alignof keyword: Return the minimum required
2929 alignment of EXPR, measured in bytes. For VAR_DECL's and
2930 FIELD_DECL's return DECL_ALIGN (which can be set from an
2931 "aligned" __attribute__ specification). */
2934 c_alignof_expr (tree expr)
2938 if (TREE_CODE (expr) == VAR_DECL)
2939 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2941 else if (TREE_CODE (expr) == COMPONENT_REF
2942 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2944 error ("`__alignof' applied to a bit-field");
2947 else if (TREE_CODE (expr) == COMPONENT_REF
2948 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2949 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2951 else if (TREE_CODE (expr) == INDIRECT_REF)
2953 tree t = TREE_OPERAND (expr, 0);
2955 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2957 while (TREE_CODE (t) == NOP_EXPR
2958 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2962 t = TREE_OPERAND (t, 0);
2963 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2964 if (thisalign > bestalign)
2965 best = t, bestalign = thisalign;
2967 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2970 return c_alignof (TREE_TYPE (expr));
2972 return fold (build1 (NOP_EXPR, size_type_node, t));
2975 /* Handle C and C++ default attributes. */
2977 enum built_in_attribute
2979 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2980 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2981 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2982 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2983 #include "builtin-attrs.def"
2984 #undef DEF_ATTR_NULL_TREE
2986 #undef DEF_ATTR_IDENT
2987 #undef DEF_ATTR_TREE_LIST
2991 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
2993 static void c_init_attributes (void);
2995 /* Build tree nodes and builtin functions common to both C and C++ language
2999 c_common_nodes_and_builtins (void)
3003 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3004 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3005 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3006 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3007 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3008 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3009 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3010 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3011 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3012 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3013 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3014 #include "builtin-types.def"
3015 #undef DEF_PRIMITIVE_TYPE
3016 #undef DEF_FUNCTION_TYPE_0
3017 #undef DEF_FUNCTION_TYPE_1
3018 #undef DEF_FUNCTION_TYPE_2
3019 #undef DEF_FUNCTION_TYPE_3
3020 #undef DEF_FUNCTION_TYPE_4
3021 #undef DEF_FUNCTION_TYPE_VAR_0
3022 #undef DEF_FUNCTION_TYPE_VAR_1
3023 #undef DEF_FUNCTION_TYPE_VAR_2
3024 #undef DEF_FUNCTION_TYPE_VAR_3
3025 #undef DEF_POINTER_TYPE
3029 typedef enum builtin_type builtin_type;
3031 tree builtin_types[(int) BT_LAST];
3032 int wchar_type_size;
3033 tree array_domain_type;
3034 tree va_list_ref_type_node;
3035 tree va_list_arg_type_node;
3037 /* Define `int' and `char' first so that dbx will output them first. */
3038 record_builtin_type (RID_INT, NULL, integer_type_node);
3039 record_builtin_type (RID_CHAR, "char", char_type_node);
3041 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3042 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3043 but not C. Are the conditionals here needed? */
3044 if (c_dialect_cxx ())
3045 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3046 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3047 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3048 record_builtin_type (RID_MAX, "long unsigned int",
3049 long_unsigned_type_node);
3050 if (c_dialect_cxx ())
3051 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3052 record_builtin_type (RID_MAX, "long long int",
3053 long_long_integer_type_node);
3054 record_builtin_type (RID_MAX, "long long unsigned int",
3055 long_long_unsigned_type_node);
3056 if (c_dialect_cxx ())
3057 record_builtin_type (RID_MAX, "long long unsigned",
3058 long_long_unsigned_type_node);
3059 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3060 record_builtin_type (RID_MAX, "short unsigned int",
3061 short_unsigned_type_node);
3062 if (c_dialect_cxx ())
3063 record_builtin_type (RID_MAX, "unsigned short",
3064 short_unsigned_type_node);
3066 /* Define both `signed char' and `unsigned char'. */
3067 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3068 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3070 /* These are types that c_common_type_for_size and
3071 c_common_type_for_mode use. */
3072 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3074 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3076 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3078 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3080 #if HOST_BITS_PER_WIDE_INT >= 64
3081 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3082 get_identifier ("__int128_t"),
3085 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3086 unsigned_intQI_type_node));
3087 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3088 unsigned_intHI_type_node));
3089 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3090 unsigned_intSI_type_node));
3091 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3092 unsigned_intDI_type_node));
3093 #if HOST_BITS_PER_WIDE_INT >= 64
3094 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3095 get_identifier ("__uint128_t"),
3096 unsigned_intTI_type_node));
3099 /* Create the widest literal types. */
3100 widest_integer_literal_type_node
3101 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3102 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3103 widest_integer_literal_type_node));
3105 widest_unsigned_literal_type_node
3106 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3107 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3108 widest_unsigned_literal_type_node));
3110 /* `unsigned long' is the standard type for sizeof.
3111 Note that stddef.h uses `unsigned long',
3112 and this must agree, even if long and int are the same size. */
3114 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3115 signed_size_type_node = c_common_signed_type (size_type_node);
3116 set_sizetype (size_type_node);
3119 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3121 build_common_tree_nodes_2 (flag_short_double);
3123 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3124 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3125 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3127 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3128 get_identifier ("complex int"),
3129 complex_integer_type_node));
3130 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3131 get_identifier ("complex float"),
3132 complex_float_type_node));
3133 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3134 get_identifier ("complex double"),
3135 complex_double_type_node));
3136 lang_hooks.decls.pushdecl
3137 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3138 complex_long_double_type_node));
3140 if (c_dialect_cxx ())
3141 /* For C++, make fileptr_type_node a distinct void * type until
3142 FILE type is defined. */
3143 fileptr_type_node = build_type_copy (ptr_type_node);
3145 record_builtin_type (RID_VOID, NULL, void_type_node);
3147 void_zero_node = build_int_2 (0, 0);
3148 TREE_TYPE (void_zero_node) = void_type_node;
3150 void_list_node = build_void_list_node ();
3152 /* Make a type to be the domain of a few array types
3153 whose domains don't really matter.
3154 200 is small enough that it always fits in size_t
3155 and large enough that it can hold most function names for the
3156 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3157 array_domain_type = build_index_type (size_int (200));
3159 /* Make a type for arrays of characters.
3160 With luck nothing will ever really depend on the length of this
3162 char_array_type_node
3163 = build_array_type (char_type_node, array_domain_type);
3165 /* Likewise for arrays of ints. */
3167 = build_array_type (integer_type_node, array_domain_type);
3169 string_type_node = build_pointer_type (char_type_node);
3170 const_string_type_node
3171 = build_pointer_type (build_qualified_type
3172 (char_type_node, TYPE_QUAL_CONST));
3174 /* This is special for C++ so functions can be overloaded. */
3175 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3176 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3177 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3178 if (c_dialect_cxx ())
3180 if (TYPE_UNSIGNED (wchar_type_node))
3181 wchar_type_node = make_unsigned_type (wchar_type_size);
3183 wchar_type_node = make_signed_type (wchar_type_size);
3184 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3188 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3189 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3192 /* This is for wide string constants. */
3193 wchar_array_type_node
3194 = build_array_type (wchar_type_node, array_domain_type);
3197 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3200 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3202 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3204 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3206 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3207 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3209 lang_hooks.decls.pushdecl
3210 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3211 va_list_type_node));
3213 lang_hooks.decls.pushdecl
3214 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3215 ptrdiff_type_node));
3217 lang_hooks.decls.pushdecl
3218 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3221 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3223 va_list_arg_type_node = va_list_ref_type_node =
3224 build_pointer_type (TREE_TYPE (va_list_type_node));
3228 va_list_arg_type_node = va_list_type_node;
3229 va_list_ref_type_node = build_reference_type (va_list_type_node);
3232 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3233 builtin_types[(int) ENUM] = VALUE;
3234 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3235 builtin_types[(int) ENUM] \
3236 = build_function_type (builtin_types[(int) RETURN], \
3238 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3239 builtin_types[(int) ENUM] \
3240 = build_function_type (builtin_types[(int) RETURN], \
3241 tree_cons (NULL_TREE, \
3242 builtin_types[(int) ARG1], \
3244 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3245 builtin_types[(int) ENUM] \
3246 = build_function_type \
3247 (builtin_types[(int) RETURN], \
3248 tree_cons (NULL_TREE, \
3249 builtin_types[(int) ARG1], \
3250 tree_cons (NULL_TREE, \
3251 builtin_types[(int) ARG2], \
3253 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3254 builtin_types[(int) ENUM] \
3255 = build_function_type \
3256 (builtin_types[(int) RETURN], \
3257 tree_cons (NULL_TREE, \
3258 builtin_types[(int) ARG1], \
3259 tree_cons (NULL_TREE, \
3260 builtin_types[(int) ARG2], \
3261 tree_cons (NULL_TREE, \
3262 builtin_types[(int) ARG3], \
3264 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3265 builtin_types[(int) ENUM] \
3266 = build_function_type \
3267 (builtin_types[(int) RETURN], \
3268 tree_cons (NULL_TREE, \
3269 builtin_types[(int) ARG1], \
3270 tree_cons (NULL_TREE, \
3271 builtin_types[(int) ARG2], \
3274 builtin_types[(int) ARG3], \
3275 tree_cons (NULL_TREE, \
3276 builtin_types[(int) ARG4], \
3277 void_list_node)))));
3278 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3279 builtin_types[(int) ENUM] \
3280 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3281 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3282 builtin_types[(int) ENUM] \
3283 = build_function_type (builtin_types[(int) RETURN], \
3284 tree_cons (NULL_TREE, \
3285 builtin_types[(int) ARG1], \
3288 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3289 builtin_types[(int) ENUM] \
3290 = build_function_type \
3291 (builtin_types[(int) RETURN], \
3292 tree_cons (NULL_TREE, \
3293 builtin_types[(int) ARG1], \
3294 tree_cons (NULL_TREE, \
3295 builtin_types[(int) ARG2], \
3298 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3299 builtin_types[(int) ENUM] \
3300 = build_function_type \
3301 (builtin_types[(int) RETURN], \
3302 tree_cons (NULL_TREE, \
3303 builtin_types[(int) ARG1], \
3304 tree_cons (NULL_TREE, \
3305 builtin_types[(int) ARG2], \
3306 tree_cons (NULL_TREE, \
3307 builtin_types[(int) ARG3], \
3310 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3311 builtin_types[(int) ENUM] \
3312 = build_pointer_type (builtin_types[(int) TYPE]);
3313 #include "builtin-types.def"
3314 #undef DEF_PRIMITIVE_TYPE
3315 #undef DEF_FUNCTION_TYPE_1
3316 #undef DEF_FUNCTION_TYPE_2
3317 #undef DEF_FUNCTION_TYPE_3
3318 #undef DEF_FUNCTION_TYPE_4
3319 #undef DEF_FUNCTION_TYPE_VAR_0
3320 #undef DEF_FUNCTION_TYPE_VAR_1
3321 #undef DEF_FUNCTION_TYPE_VAR_2
3322 #undef DEF_FUNCTION_TYPE_VAR_3
3323 #undef DEF_POINTER_TYPE
3325 c_init_attributes ();
3327 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3328 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3333 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3337 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3340 ? (NAME + strlen ("__builtin_")) \
3342 built_in_attributes[(int) ATTRS]); \
3344 decl = builtin_function_2 (NAME, \
3345 NAME + strlen ("__builtin_"), \
3346 builtin_types[TYPE], \
3347 builtin_types[LIBTYPE], \
3352 built_in_attributes[(int) ATTRS]); \
3354 built_in_decls[(int) ENUM] = decl; \
3356 implicit_built_in_decls[(int) ENUM] = decl; \
3358 #include "builtins.def"
3361 targetm.init_builtins ();
3363 main_identifier_node = get_identifier ("main");
3367 build_va_arg (tree expr, tree type)
3369 return build1 (VA_ARG_EXPR, type, expr);
3373 /* Linked list of disabled built-in functions. */
3375 typedef struct disabled_builtin
3378 struct disabled_builtin *next;
3380 static disabled_builtin *disabled_builtins = NULL;
3382 static bool builtin_function_disabled_p (const char *);
3384 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3385 begins with "__builtin_", give an error. */
3388 disable_builtin_function (const char *name)
3390 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3391 error ("cannot disable built-in function `%s'", name);
3394 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3396 new->next = disabled_builtins;
3397 disabled_builtins = new;
3402 /* Return true if the built-in function NAME has been disabled, false
3406 builtin_function_disabled_p (const char *name)
3408 disabled_builtin *p;
3409 for (p = disabled_builtins; p != NULL; p = p->next)
3411 if (strcmp (name, p->name) == 0)
3418 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3419 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3420 of these may be NULL (though both being NULL is useless).
3421 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3422 TYPE is the type of the function with the ordinary name. These
3423 may differ if the ordinary name is declared with a looser type to avoid
3424 conflicts with headers. FUNCTION_CODE and CLASS are as for
3425 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3426 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3427 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3428 ATTRS is the tree list representing the builtin's function attributes.
3429 Returns the declaration of BUILTIN_NAME, if any, otherwise
3430 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3431 or if NONANSI_P and flag_no_nonansi_builtin. */
3434 builtin_function_2 (const char *builtin_name, const char *name,
3435 tree builtin_type, tree type, int function_code,
3436 enum built_in_class class, int library_name_p,
3437 int nonansi_p, tree attrs)
3439 tree bdecl = NULL_TREE;
3440 tree decl = NULL_TREE;
3442 if (builtin_name != 0)
3443 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3444 class, library_name_p ? name : NULL, attrs);
3446 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3447 && !(nonansi_p && flag_no_nonansi_builtin))
3448 decl = builtin_function (name, type, function_code, class, NULL, attrs);
3450 return (bdecl != 0 ? bdecl : decl);
3453 /* Nonzero if the type T promotes to int. This is (nearly) the
3454 integral promotions defined in ISO C99 6.3.1.1/2. */
3457 c_promoting_integer_type_p (tree t)
3459 switch (TREE_CODE (t))
3462 return (TYPE_MAIN_VARIANT (t) == char_type_node
3463 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3464 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3465 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3466 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3467 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3470 /* ??? Technically all enumerations not larger than an int
3471 promote to an int. But this is used along code paths
3472 that only want to notice a size change. */
3473 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3483 /* Return 1 if PARMS specifies a fixed number of parameters
3484 and none of their types is affected by default promotions. */
3487 self_promoting_args_p (tree parms)
3490 for (t = parms; t; t = TREE_CHAIN (t))
3492 tree type = TREE_VALUE (t);
3494 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3500 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3503 if (c_promoting_integer_type_p (type))
3509 /* Recursively examines the array elements of TYPE, until a non-array
3510 element type is found. */
3513 strip_array_types (tree type)
3515 while (TREE_CODE (type) == ARRAY_TYPE)
3516 type = TREE_TYPE (type);
3521 /* Recursively remove any '*' or '&' operator from TYPE. */
3523 strip_pointer_operator (tree t)
3525 while (POINTER_TYPE_P (t))
3530 static tree expand_unordered_cmp (tree, tree, enum tree_code, enum tree_code);
3532 /* Expand a call to an unordered comparison function such as
3533 __builtin_isgreater(). FUNCTION is the function's declaration and
3534 PARAMS a list of the values passed. For __builtin_isunordered(),
3535 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3536 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3537 that give the opposite of the desired result. UNORDERED_CODE is
3538 used for modes that can hold NaNs and ORDERED_CODE is used for the
3542 expand_unordered_cmp (tree function, tree params,
3543 enum tree_code unordered_code,
3544 enum tree_code ordered_code)
3546 tree arg0, arg1, type;
3547 enum tree_code code0, code1;
3549 /* Check that we have exactly two arguments. */
3550 if (params == 0 || TREE_CHAIN (params) == 0)
3552 error ("too few arguments to function `%s'",
3553 IDENTIFIER_POINTER (DECL_NAME (function)));
3554 return error_mark_node;
3556 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3558 error ("too many arguments to function `%s'",
3559 IDENTIFIER_POINTER (DECL_NAME (function)));
3560 return error_mark_node;
3563 arg0 = TREE_VALUE (params);
3564 arg1 = TREE_VALUE (TREE_CHAIN (params));
3566 code0 = TREE_CODE (TREE_TYPE (arg0));
3567 code1 = TREE_CODE (TREE_TYPE (arg1));
3569 /* Make sure that the arguments have a common type of REAL. */
3571 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3572 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3573 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3575 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3577 error ("non-floating-point argument to function `%s'",
3578 IDENTIFIER_POINTER (DECL_NAME (function)));
3579 return error_mark_node;
3582 if (unordered_code == UNORDERED_EXPR)
3584 if (MODE_HAS_NANS (TYPE_MODE (type)))
3585 return build_binary_op (unordered_code,
3586 convert (type, arg0),
3587 convert (type, arg1),
3590 return integer_zero_node;
3593 return build_unary_op (TRUTH_NOT_EXPR,
3594 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3597 convert (type, arg0),
3598 convert (type, arg1),
3604 /* Recognize certain built-in functions so we can make tree-codes
3605 other than CALL_EXPR. We do this when it enables fold-const.c
3606 to do something useful. */
3607 /* ??? By rights this should go in builtins.c, but only C and C++
3608 implement build_{binary,unary}_op. Not exactly sure what bits
3609 of functionality are actually needed from those functions, or
3610 where the similar functionality exists in the other front ends. */
3613 expand_tree_builtin (tree function, tree params, tree coerced_params)
3615 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3618 switch (DECL_FUNCTION_CODE (function))
3622 case BUILT_IN_LLABS:
3623 case BUILT_IN_IMAXABS:
3625 case BUILT_IN_FABSL:
3626 case BUILT_IN_FABSF:
3627 if (coerced_params == 0)
3628 return integer_zero_node;
3629 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3632 case BUILT_IN_CONJF:
3633 case BUILT_IN_CONJL:
3634 if (coerced_params == 0)
3635 return integer_zero_node;
3636 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3638 case BUILT_IN_CREAL:
3639 case BUILT_IN_CREALF:
3640 case BUILT_IN_CREALL:
3641 if (coerced_params == 0)
3642 return integer_zero_node;
3643 return non_lvalue (build_unary_op (REALPART_EXPR,
3644 TREE_VALUE (coerced_params), 0));
3646 case BUILT_IN_CIMAG:
3647 case BUILT_IN_CIMAGF:
3648 case BUILT_IN_CIMAGL:
3649 if (coerced_params == 0)
3650 return integer_zero_node;
3651 return non_lvalue (build_unary_op (IMAGPART_EXPR,
3652 TREE_VALUE (coerced_params), 0));
3654 case BUILT_IN_ISGREATER:
3655 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3657 case BUILT_IN_ISGREATEREQUAL:
3658 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3660 case BUILT_IN_ISLESS:
3661 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3663 case BUILT_IN_ISLESSEQUAL:
3664 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3666 case BUILT_IN_ISLESSGREATER:
3667 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3669 case BUILT_IN_ISUNORDERED:
3670 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3679 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3680 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3681 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3682 value, the traversal is aborted, and the value returned by FUNC is
3683 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3684 the node being visited are not walked.
3686 We don't need a without_duplicates variant of this one because the
3687 statement tree is a tree, not a graph. */
3690 walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
3692 enum tree_code code;
3697 #define WALK_SUBTREE(NODE) \
3700 result = walk_stmt_tree (&(NODE), func, data); \
3706 /* Skip empty subtrees. */
3710 /* Skip subtrees below non-statement nodes. */
3711 if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
3714 /* Call the function. */
3716 result = (*func) (tp, &walk_subtrees, data);
3718 /* If we found something, return it. */
3722 /* FUNC may have modified the tree, recheck that we're looking at a
3724 code = TREE_CODE (*tp);
3725 if (!STATEMENT_CODE_P (code))
3728 /* Visit the subtrees unless FUNC decided that there was nothing
3729 interesting below this point in the tree. */
3732 /* Walk over all the sub-trees of this operand. Statement nodes
3733 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3734 len = TREE_CODE_LENGTH (code);
3736 /* Go through the subtrees. We need to do this in forward order so
3737 that the scope of a FOR_EXPR is handled properly. */
3738 for (i = 0; i < len; ++i)
3739 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3742 /* Finally visit the chain. This can be tail-recursion optimized if
3743 we write it this way. */
3744 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3749 /* Used to compare case labels. K1 and K2 are actually tree nodes
3750 representing case labels, or NULL_TREE for a `default' label.
3751 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3752 K2, and 0 if K1 and K2 are equal. */
3755 case_compare (splay_tree_key k1, splay_tree_key k2)
3757 /* Consider a NULL key (such as arises with a `default' label) to be
3758 smaller than anything else. */
3764 return tree_int_cst_compare ((tree) k1, (tree) k2);
3767 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3768 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3769 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3770 case label was declared using the usual C/C++ syntax, rather than
3771 the GNU case range extension. CASES is a tree containing all the
3772 case ranges processed so far; COND is the condition for the
3773 switch-statement itself. Returns the CASE_LABEL created, or
3774 ERROR_MARK_NODE if no CASE_LABEL is created. */
3777 c_add_case_label (splay_tree cases, tree cond, tree low_value,
3783 splay_tree_node node;
3785 /* Create the LABEL_DECL itself. */
3786 label = create_artificial_label ();
3788 /* If there was an error processing the switch condition, bail now
3789 before we get more confused. */
3790 if (!cond || cond == error_mark_node)
3793 if ((low_value && TREE_TYPE (low_value)
3794 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3795 || (high_value && TREE_TYPE (high_value)
3796 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3797 error ("pointers are not permitted as case values");
3799 /* Case ranges are a GNU extension. */
3800 if (high_value && pedantic)
3801 pedwarn ("range expressions in switch statements are non-standard");
3803 type = TREE_TYPE (cond);
3806 low_value = check_case_value (low_value);
3807 low_value = convert_and_check (type, low_value);
3811 high_value = check_case_value (high_value);
3812 high_value = convert_and_check (type, high_value);
3815 /* If an error has occurred, bail out now. */
3816 if (low_value == error_mark_node || high_value == error_mark_node)
3819 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3820 really a case range, even though it was written that way. Remove
3821 the HIGH_VALUE to simplify later processing. */
3822 if (tree_int_cst_equal (low_value, high_value))
3823 high_value = NULL_TREE;
3824 if (low_value && high_value
3825 && !tree_int_cst_lt (low_value, high_value))
3826 warning ("empty range specified");
3828 /* Look up the LOW_VALUE in the table of case labels we already
3830 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3831 /* If there was not an exact match, check for overlapping ranges.
3832 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3833 that's a `default' label and the only overlap is an exact match. */
3834 if (!node && (low_value || high_value))
3836 splay_tree_node low_bound;
3837 splay_tree_node high_bound;
3839 /* Even though there wasn't an exact match, there might be an
3840 overlap between this case range and another case range.
3841 Since we've (inductively) not allowed any overlapping case
3842 ranges, we simply need to find the greatest low case label
3843 that is smaller that LOW_VALUE, and the smallest low case
3844 label that is greater than LOW_VALUE. If there is an overlap
3845 it will occur in one of these two ranges. */
3846 low_bound = splay_tree_predecessor (cases,
3847 (splay_tree_key) low_value);
3848 high_bound = splay_tree_successor (cases,
3849 (splay_tree_key) low_value);
3851 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3852 the LOW_VALUE, so there is no need to check unless the
3853 LOW_BOUND is in fact itself a case range. */
3855 && CASE_HIGH ((tree) low_bound->value)
3856 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3859 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3860 range is bigger than the low end of the current range, so we
3861 are only interested if the current range is a real range, and
3862 not an ordinary case label. */
3865 && (tree_int_cst_compare ((tree) high_bound->key,
3870 /* If there was an overlap, issue an error. */
3873 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3877 error ("duplicate (or overlapping) case value");
3878 error ("%Jthis is the first entry overlapping that value", duplicate);
3882 error ("duplicate case value") ;
3883 error ("%Jpreviously used here", duplicate);
3887 error ("multiple default labels in one switch");
3888 error ("%Jthis is the first default label", duplicate);
3893 /* Add a CASE_LABEL to the statement-tree. */
3894 case_label = add_stmt (build_case_label (low_value, high_value, label));
3895 /* Register this case label in the splay tree. */
3896 splay_tree_insert (cases,
3897 (splay_tree_key) low_value,
3898 (splay_tree_value) case_label);
3903 /* Add a label so that the back-end doesn't think that the beginning o
3904 the switch is unreachable. Note that we do not add a case label, as
3905 that just leads to duplicates and thence to aborts later on. */
3908 tree t = create_artificial_label ();
3909 add_stmt (build_stmt (LABEL_STMT, t));
3911 return error_mark_node;
3914 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3915 Used to verify that case values match up with enumerator values. */
3918 match_case_to_enum_1 (tree key, tree type, tree label)
3920 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3922 /* ??? Not working too hard to print the double-word value.
3923 Should perhaps be done with %lwd in the diagnostic routines? */
3924 if (TREE_INT_CST_HIGH (key) == 0)
3925 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3926 TREE_INT_CST_LOW (key));
3927 else if (!TYPE_UNSIGNED (type)
3928 && TREE_INT_CST_HIGH (key) == -1
3929 && TREE_INT_CST_LOW (key) != 0)
3930 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3931 -TREE_INT_CST_LOW (key));
3933 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3934 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3936 if (TYPE_NAME (type) == 0)
3937 warning ("%Jcase value `%s' not in enumerated type",
3938 CASE_LABEL_DECL (label), buf);
3940 warning ("%Jcase value `%s' not in enumerated type `%T'",
3941 CASE_LABEL_DECL (label), buf, type);
3945 match_case_to_enum (splay_tree_node node, void *data)
3947 tree label = (tree) node->value;
3950 /* Skip default case. */
3951 if (!CASE_LOW (label))
3954 /* If TREE_ADDRESSABLE is not set, that means CASE_LOW did not appear
3955 when we did our enum->case scan. Reset our scratch bit after. */
3956 if (!TREE_ADDRESSABLE (label))
3957 match_case_to_enum_1 (CASE_LOW (label), type, label);
3959 TREE_ADDRESSABLE (label) = 0;
3961 /* If CASE_HIGH is non-null, we have a range. Here we must search.
3962 Note that the old code in stmt.c did not check for the values in
3963 the range either, just the endpoints. */
3964 if (CASE_HIGH (label))
3966 tree chain, key = CASE_HIGH (label);
3968 for (chain = TYPE_VALUES (type);
3969 chain && !tree_int_cst_equal (key, TREE_VALUE (chain));
3970 chain = TREE_CHAIN (chain))
3973 match_case_to_enum_1 (key, type, label);
3979 /* Handle -Wswitch*. Called from the front end after parsing the switch
3981 /* ??? Should probably be somewhere generic, since other languages besides
3982 C and C++ would want this. We'd want to agree on the datastructure,
3983 however, which is a problem. Alternately, we operate on gimplified
3984 switch_exprs, which I don't especially like. At the moment, however,
3985 C/C++ are the only tree-ssa languages that support enumerations at all,
3986 so the point is moot. */
3989 c_do_switch_warnings (splay_tree cases, tree switch_stmt)
3991 splay_tree_node default_node;
3992 location_t *switch_locus;
3995 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3998 switch_locus = EXPR_LOCUS (switch_stmt);
4000 switch_locus = &input_location;
4001 type = SWITCH_TYPE (switch_stmt);
4003 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4004 if (warn_switch_default && !default_node)
4005 warning ("%Hswitch missing default case", switch_locus);
4007 /* If the switch expression was an enumerated type, check that
4008 exactly all enumeration literals are covered by the cases.
4009 The check is made when -Wswitch was specified and there is no
4010 default case, or when -Wswitch-enum was specified. */
4011 if (((warn_switch && !default_node) || warn_switch_enum)
4012 && type && TREE_CODE (type) == ENUMERAL_TYPE
4013 && TREE_CODE (SWITCH_COND (switch_stmt)) != INTEGER_CST)
4017 /* The time complexity here is O(N*lg(N)) worst case, but for the
4018 common case of monotonically increasing enumerators, it is
4019 O(N), since the nature of the splay tree will keep the next
4020 element adjacent to the root at all times. */
4022 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4024 splay_tree_node node
4025 = splay_tree_lookup (cases, (splay_tree_key) TREE_VALUE (chain));
4029 /* Mark the CASE_LOW part of the case entry as seen, so
4030 that we save time later. Choose TREE_ADDRESSABLE
4031 randomly as a bit that won't have been set to-date. */
4032 tree label = (tree) node->value;
4033 TREE_ADDRESSABLE (label) = 1;
4037 /* Warn if there are enumerators that don't correspond to
4038 case expressions. */
4039 warning ("%Henumeration value `%E' not handled in switch",
4040 switch_locus, TREE_PURPOSE (chain));
4044 /* Warn if there are case expressions that don't correspond to
4045 enumerators. This can occur since C and C++ don't enforce
4046 type-checking of assignments to enumeration variables.
4048 The time complexity here is O(N**2) worst case, since we've
4049 not sorted the enumeration values. However, in the absence
4050 of case ranges this is O(N), since all single cases that
4051 corresponded to enumerations have been marked above. */
4053 splay_tree_foreach (cases, match_case_to_enum, type);
4057 /* Finish an expression taking the address of LABEL (an
4058 IDENTIFIER_NODE). Returns an expression for the address. */
4061 finish_label_address_expr (tree label)
4066 pedwarn ("taking the address of a label is non-standard");
4068 if (label == error_mark_node)
4069 return error_mark_node;
4071 label = lookup_label (label);
4072 if (label == NULL_TREE)
4073 result = null_pointer_node;
4076 TREE_USED (label) = 1;
4077 result = build1 (ADDR_EXPR, ptr_type_node, label);
4078 /* The current function in not necessarily uninlinable.
4079 Computed gotos are incompatible with inlining, but the value
4080 here could be used only in a diagnostic, for example. */
4086 /* Hook used by expand_expr to expand language-specific tree codes. */
4087 /* The only things that should go here are bits needed to expand
4088 constant initializers. Everything else should be handled by the
4089 gimplification routines. */
4092 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4093 int modifier /* Actually enum_modifier. */,
4096 switch (TREE_CODE (exp))
4098 case COMPOUND_LITERAL_EXPR:
4100 /* Initialize the anonymous variable declared in the compound
4101 literal, then return the variable. */
4102 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4103 emit_local_var (decl);
4104 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4112 /* Hook used by safe_from_p to handle language-specific tree codes. */
4115 c_safe_from_p (rtx target, tree exp)
4117 /* We can see statements here when processing the body of a
4118 statement-expression. For a declaration statement declaring a
4119 variable, look at the variable's initializer. */
4120 if (TREE_CODE (exp) == DECL_STMT)
4122 tree decl = DECL_STMT_DECL (exp);
4124 if (TREE_CODE (decl) == VAR_DECL
4125 && DECL_INITIAL (decl)
4126 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4130 /* Assume everything else is safe. */
4134 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4137 c_common_unsafe_for_reeval (tree exp)
4139 /* Statement expressions may not be reevaluated, likewise compound
4141 if (TREE_CODE (exp) == STMT_EXPR
4142 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4145 /* Walk all other expressions. */
4149 /* Hook used by staticp to handle language-specific tree codes. */
4152 c_staticp (tree exp)
4154 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4155 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4161 /* Given a boolean expression ARG, return a tree representing an increment
4162 or decrement (as indicated by CODE) of ARG. The front end must check for
4163 invalid cases (e.g., decrement in C++). */
4165 boolean_increment (enum tree_code code, tree arg)
4168 tree true_res = boolean_true_node;
4170 arg = stabilize_reference (arg);
4173 case PREINCREMENT_EXPR:
4174 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4176 case POSTINCREMENT_EXPR:
4177 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4178 arg = save_expr (arg);
4179 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4180 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4182 case PREDECREMENT_EXPR:
4183 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4185 case POSTDECREMENT_EXPR:
4186 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4187 arg = save_expr (arg);
4188 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4189 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4194 TREE_SIDE_EFFECTS (val) = 1;
4198 /* Built-in macros for stddef.h, that require macros defined in this
4201 c_stddef_cpp_builtins(void)
4203 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4204 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4205 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4206 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4210 c_init_attributes (void)
4212 /* Fill in the built_in_attributes array. */
4213 #define DEF_ATTR_NULL_TREE(ENUM) \
4214 built_in_attributes[(int) ENUM] = NULL_TREE;
4215 #define DEF_ATTR_INT(ENUM, VALUE) \
4216 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4217 #define DEF_ATTR_IDENT(ENUM, STRING) \
4218 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4219 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4220 built_in_attributes[(int) ENUM] \
4221 = tree_cons (built_in_attributes[(int) PURPOSE], \
4222 built_in_attributes[(int) VALUE], \
4223 built_in_attributes[(int) CHAIN]);
4224 #include "builtin-attrs.def"
4225 #undef DEF_ATTR_NULL_TREE
4227 #undef DEF_ATTR_IDENT
4228 #undef DEF_ATTR_TREE_LIST
4231 /* Attribute handlers common to C front ends. */
4233 /* Handle a "packed" attribute; arguments as in
4234 struct attribute_spec.handler. */
4237 handle_packed_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4238 int flags, bool *no_add_attrs)
4242 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4243 *node = build_type_copy (*node);
4244 TYPE_PACKED (*node) = 1;
4245 if (TYPE_MAIN_VARIANT (*node) == *node)
4247 /* If it is the main variant, then pack the other variants
4248 too. This happens in,
4251 struct Foo const *ptr; // creates a variant w/o packed flag
4252 } __ attribute__((packed)); // packs it now.
4256 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
4257 TYPE_PACKED (probe) = 1;
4261 else if (TREE_CODE (*node) == FIELD_DECL)
4262 DECL_PACKED (*node) = 1;
4263 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4264 used for DECL_REGISTER. It wouldn't mean anything anyway.
4265 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4266 that changes what the typedef is typing. */
4269 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4270 *no_add_attrs = true;
4276 /* Handle a "nocommon" attribute; arguments as in
4277 struct attribute_spec.handler. */
4280 handle_nocommon_attribute (tree *node, tree name,
4281 tree args ATTRIBUTE_UNUSED,
4282 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4284 if (TREE_CODE (*node) == VAR_DECL)
4285 DECL_COMMON (*node) = 0;
4288 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4289 *no_add_attrs = true;
4295 /* Handle a "common" attribute; arguments as in
4296 struct attribute_spec.handler. */
4299 handle_common_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4300 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4302 if (TREE_CODE (*node) == VAR_DECL)
4303 DECL_COMMON (*node) = 1;
4306 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4307 *no_add_attrs = true;
4313 /* Handle a "noreturn" attribute; arguments as in
4314 struct attribute_spec.handler. */
4317 handle_noreturn_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4318 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4320 tree type = TREE_TYPE (*node);
4322 /* See FIXME comment in c_common_attribute_table. */
4323 if (TREE_CODE (*node) == FUNCTION_DECL)
4324 TREE_THIS_VOLATILE (*node) = 1;
4325 else if (TREE_CODE (type) == POINTER_TYPE
4326 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4328 = build_pointer_type
4329 (build_type_variant (TREE_TYPE (type),
4330 TYPE_READONLY (TREE_TYPE (type)), 1));
4333 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4334 *no_add_attrs = true;
4340 /* Handle a "noinline" attribute; arguments as in
4341 struct attribute_spec.handler. */
4344 handle_noinline_attribute (tree *node, tree name,
4345 tree args ATTRIBUTE_UNUSED,
4346 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4348 if (TREE_CODE (*node) == FUNCTION_DECL)
4349 DECL_UNINLINABLE (*node) = 1;
4352 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4353 *no_add_attrs = true;
4359 /* Handle a "always_inline" attribute; arguments as in
4360 struct attribute_spec.handler. */
4363 handle_always_inline_attribute (tree *node, tree name,
4364 tree args ATTRIBUTE_UNUSED,
4365 int flags ATTRIBUTE_UNUSED,
4368 if (TREE_CODE (*node) == FUNCTION_DECL)
4370 /* Do nothing else, just set the attribute. We'll get at
4371 it later with lookup_attribute. */
4375 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4376 *no_add_attrs = true;
4382 /* Handle a "used" attribute; arguments as in
4383 struct attribute_spec.handler. */
4386 handle_used_attribute (tree *pnode, tree name, tree args ATTRIBUTE_UNUSED,
4387 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4391 if (TREE_CODE (node) == FUNCTION_DECL
4392 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4394 TREE_USED (node) = 1;
4398 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4399 *no_add_attrs = true;
4405 /* Handle a "unused" attribute; arguments as in
4406 struct attribute_spec.handler. */
4409 handle_unused_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4410 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4416 if (TREE_CODE (decl) == PARM_DECL
4417 || TREE_CODE (decl) == VAR_DECL
4418 || TREE_CODE (decl) == FUNCTION_DECL
4419 || TREE_CODE (decl) == LABEL_DECL
4420 || TREE_CODE (decl) == TYPE_DECL)
4421 TREE_USED (decl) = 1;
4424 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4425 *no_add_attrs = true;
4430 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4431 *node = build_type_copy (*node);
4432 TREE_USED (*node) = 1;
4438 /* Handle a "const" attribute; arguments as in
4439 struct attribute_spec.handler. */
4442 handle_const_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4443 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4445 tree type = TREE_TYPE (*node);
4447 /* See FIXME comment on noreturn in c_common_attribute_table. */
4448 if (TREE_CODE (*node) == FUNCTION_DECL)
4449 TREE_READONLY (*node) = 1;
4450 else if (TREE_CODE (type) == POINTER_TYPE
4451 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4453 = build_pointer_type
4454 (build_type_variant (TREE_TYPE (type), 1,
4455 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4458 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4459 *no_add_attrs = true;
4465 /* Handle a "transparent_union" attribute; arguments as in
4466 struct attribute_spec.handler. */
4469 handle_transparent_union_attribute (tree *node, tree name,
4470 tree args ATTRIBUTE_UNUSED, int flags,
4473 tree decl = NULL_TREE;
4480 type = &TREE_TYPE (decl);
4481 is_type = TREE_CODE (*node) == TYPE_DECL;
4483 else if (TYPE_P (*node))
4484 type = node, is_type = 1;
4487 && TREE_CODE (*type) == UNION_TYPE
4489 || (TYPE_FIELDS (*type) != 0
4490 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4492 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4493 *type = build_type_copy (*type);
4494 TYPE_TRANSPARENT_UNION (*type) = 1;
4496 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4497 && TREE_CODE (*type) == UNION_TYPE
4498 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4499 DECL_TRANSPARENT_UNION (decl) = 1;
4502 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4503 *no_add_attrs = true;
4509 /* Handle a "constructor" attribute; arguments as in
4510 struct attribute_spec.handler. */
4513 handle_constructor_attribute (tree *node, tree name,
4514 tree args ATTRIBUTE_UNUSED,
4515 int flags ATTRIBUTE_UNUSED,
4519 tree type = TREE_TYPE (decl);
4521 if (TREE_CODE (decl) == FUNCTION_DECL
4522 && TREE_CODE (type) == FUNCTION_TYPE
4523 && decl_function_context (decl) == 0)
4525 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4526 TREE_USED (decl) = 1;
4530 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4531 *no_add_attrs = true;
4537 /* Handle a "destructor" attribute; arguments as in
4538 struct attribute_spec.handler. */
4541 handle_destructor_attribute (tree *node, tree name,
4542 tree args ATTRIBUTE_UNUSED,
4543 int flags ATTRIBUTE_UNUSED,
4547 tree type = TREE_TYPE (decl);
4549 if (TREE_CODE (decl) == FUNCTION_DECL
4550 && TREE_CODE (type) == FUNCTION_TYPE
4551 && decl_function_context (decl) == 0)
4553 DECL_STATIC_DESTRUCTOR (decl) = 1;
4554 TREE_USED (decl) = 1;
4558 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4559 *no_add_attrs = true;
4565 /* Handle a "mode" attribute; arguments as in
4566 struct attribute_spec.handler. */
4569 handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4570 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4574 *no_add_attrs = true;
4576 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4577 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4581 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4582 int len = strlen (p);
4583 enum machine_mode mode = VOIDmode;
4587 if (len > 4 && p[0] == '_' && p[1] == '_'
4588 && p[len - 1] == '_' && p[len - 2] == '_')
4590 char *newp = alloca (len - 1);
4592 strcpy (newp, &p[2]);
4593 newp[len - 4] = '\0';
4597 /* Change this type to have a type with the specified mode.
4598 First check for the special modes. */
4599 if (! strcmp (p, "byte"))
4601 else if (!strcmp (p, "word"))
4603 else if (! strcmp (p, "pointer"))
4606 for (j = 0; j < NUM_MACHINE_MODES; j++)
4607 if (!strcmp (p, GET_MODE_NAME (j)))
4608 mode = (enum machine_mode) j;
4610 if (mode == VOIDmode)
4612 error ("unknown machine mode `%s'", p);
4616 if (VECTOR_MODE_P (mode))
4618 warning ("specifying vector types with __attribute__ ((mode)) "
4620 warning ("use __attribute__ ((vector_size)) instead");
4623 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4624 if (typefm == NULL_TREE)
4625 error ("no data type for mode `%s'", p);
4627 else if ((TREE_CODE (type) == POINTER_TYPE
4628 || TREE_CODE (type) == REFERENCE_TYPE)
4629 && !targetm.valid_pointer_mode (mode))
4630 error ("invalid pointer mode `%s'", p);
4633 /* If this is a vector, make sure we either have hardware
4634 support, or we can emulate it. */
4635 if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
4637 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
4641 if (TREE_CODE (type) == POINTER_TYPE)
4643 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
4647 else if (TREE_CODE (type) == REFERENCE_TYPE)
4649 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
4655 /* No need to layout the type here. The caller should do this. */
4662 /* Handle a "section" attribute; arguments as in
4663 struct attribute_spec.handler. */
4666 handle_section_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4667 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4671 if (targetm.have_named_sections)
4673 if ((TREE_CODE (decl) == FUNCTION_DECL
4674 || TREE_CODE (decl) == VAR_DECL)
4675 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4677 if (TREE_CODE (decl) == VAR_DECL
4678 && current_function_decl != NULL_TREE
4679 && ! TREE_STATIC (decl))
4681 error ("%Jsection attribute cannot be specified for "
4682 "local variables", decl);
4683 *no_add_attrs = true;
4686 /* The decl may have already been given a section attribute
4687 from a previous declaration. Ensure they match. */
4688 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4689 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4690 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4692 error ("%Jsection of '%D' conflicts with previous declaration",
4694 *no_add_attrs = true;
4697 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4701 error ("%Jsection attribute not allowed for '%D'", *node, *node);
4702 *no_add_attrs = true;
4707 error ("%Jsection attributes are not supported for this target", *node);
4708 *no_add_attrs = true;
4714 /* Handle a "aligned" attribute; arguments as in
4715 struct attribute_spec.handler. */
4718 handle_aligned_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4719 int flags, bool *no_add_attrs)
4721 tree decl = NULL_TREE;
4724 tree align_expr = (args ? TREE_VALUE (args)
4725 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4731 type = &TREE_TYPE (decl);
4732 is_type = TREE_CODE (*node) == TYPE_DECL;
4734 else if (TYPE_P (*node))
4735 type = node, is_type = 1;
4737 /* Strip any NOPs of any kind. */
4738 while (TREE_CODE (align_expr) == NOP_EXPR
4739 || TREE_CODE (align_expr) == CONVERT_EXPR
4740 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4741 align_expr = TREE_OPERAND (align_expr, 0);
4743 if (TREE_CODE (align_expr) != INTEGER_CST)
4745 error ("requested alignment is not a constant");
4746 *no_add_attrs = true;
4748 else if ((i = tree_log2 (align_expr)) == -1)
4750 error ("requested alignment is not a power of 2");
4751 *no_add_attrs = true;
4753 else if (i > HOST_BITS_PER_INT - 2)
4755 error ("requested alignment is too large");
4756 *no_add_attrs = true;
4760 /* If we have a TYPE_DECL, then copy the type, so that we
4761 don't accidentally modify a builtin type. See pushdecl. */
4762 if (decl && TREE_TYPE (decl) != error_mark_node
4763 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4765 tree tt = TREE_TYPE (decl);
4766 *type = build_type_copy (*type);
4767 DECL_ORIGINAL_TYPE (decl) = tt;
4768 TYPE_NAME (*type) = decl;
4769 TREE_USED (*type) = TREE_USED (decl);
4770 TREE_TYPE (decl) = *type;
4772 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4773 *type = build_type_copy (*type);
4775 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4776 TYPE_USER_ALIGN (*type) = 1;
4778 else if (TREE_CODE (decl) != VAR_DECL
4779 && TREE_CODE (decl) != FIELD_DECL)
4781 error ("%Jalignment may not be specified for '%D'", decl, decl);
4782 *no_add_attrs = true;
4786 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4787 DECL_USER_ALIGN (decl) = 1;
4793 /* Handle a "weak" attribute; arguments as in
4794 struct attribute_spec.handler. */
4797 handle_weak_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
4798 tree args ATTRIBUTE_UNUSED,
4799 int flags ATTRIBUTE_UNUSED,
4800 bool *no_add_attrs ATTRIBUTE_UNUSED)
4802 declare_weak (*node);
4807 /* Handle an "alias" attribute; arguments as in
4808 struct attribute_spec.handler. */
4811 handle_alias_attribute (tree *node, tree name, tree args,
4812 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4816 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4817 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
4819 error ("%J'%D' defined both normally and as an alias", decl, decl);
4820 *no_add_attrs = true;
4823 /* Note that the very first time we process a nested declaration,
4824 decl_function_context will not be set. Indeed, *would* never
4825 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4826 we do below. After such frobbery, pushdecl would set the context.
4827 In any case, this is never what we want. */
4828 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4832 id = TREE_VALUE (args);
4833 if (TREE_CODE (id) != STRING_CST)
4835 error ("alias arg not a string");
4836 *no_add_attrs = true;
4839 id = get_identifier (TREE_STRING_POINTER (id));
4840 /* This counts as a use of the object pointed to. */
4843 if (TREE_CODE (decl) == FUNCTION_DECL)
4844 DECL_INITIAL (decl) = error_mark_node;
4847 DECL_EXTERNAL (decl) = 0;
4848 TREE_STATIC (decl) = 1;
4853 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4854 *no_add_attrs = true;
4860 /* Handle an "visibility" attribute; arguments as in
4861 struct attribute_spec.handler. */
4864 handle_visibility_attribute (tree *node, tree name, tree args,
4865 int flags ATTRIBUTE_UNUSED,
4869 tree id = TREE_VALUE (args);
4871 *no_add_attrs = true;
4873 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
4875 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4879 if (TREE_CODE (id) != STRING_CST)
4881 error ("visibility arg not a string");
4885 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4886 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4887 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4888 DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4889 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4890 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4891 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4892 DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4894 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4899 /* Handle an "tls_model" attribute; arguments as in
4900 struct attribute_spec.handler. */
4903 handle_tls_model_attribute (tree *node, tree name, tree args,
4904 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4908 if (! DECL_THREAD_LOCAL (decl))
4910 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4911 *no_add_attrs = true;
4917 id = TREE_VALUE (args);
4918 if (TREE_CODE (id) != STRING_CST)
4920 error ("tls_model arg not a string");
4921 *no_add_attrs = true;
4924 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
4925 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
4926 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
4927 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4929 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4930 *no_add_attrs = true;
4938 /* Handle a "no_instrument_function" attribute; arguments as in
4939 struct attribute_spec.handler. */
4942 handle_no_instrument_function_attribute (tree *node, tree name,
4943 tree args ATTRIBUTE_UNUSED,
4944 int flags ATTRIBUTE_UNUSED,
4949 if (TREE_CODE (decl) != FUNCTION_DECL)
4951 error ("%J'%E' attribute applies only to functions", decl, name);
4952 *no_add_attrs = true;
4954 else if (DECL_INITIAL (decl))
4956 error ("%Jcan't set '%E' attribute after definition", decl, name);
4957 *no_add_attrs = true;
4960 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
4965 /* Handle a "malloc" attribute; arguments as in
4966 struct attribute_spec.handler. */
4969 handle_malloc_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4970 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4972 if (TREE_CODE (*node) == FUNCTION_DECL)
4973 DECL_IS_MALLOC (*node) = 1;
4974 /* ??? TODO: Support types. */
4977 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4978 *no_add_attrs = true;
4984 /* Handle a "no_limit_stack" attribute; arguments as in
4985 struct attribute_spec.handler. */
4988 handle_no_limit_stack_attribute (tree *node, tree name,
4989 tree args ATTRIBUTE_UNUSED,
4990 int flags ATTRIBUTE_UNUSED,
4995 if (TREE_CODE (decl) != FUNCTION_DECL)
4997 error ("%J'%E' attribute applies only to functions", decl, name);
4998 *no_add_attrs = true;
5000 else if (DECL_INITIAL (decl))
5002 error ("%Jcan't set '%E' attribute after definition", decl, name);
5003 *no_add_attrs = true;
5006 DECL_NO_LIMIT_STACK (decl) = 1;
5011 /* Handle a "pure" attribute; arguments as in
5012 struct attribute_spec.handler. */
5015 handle_pure_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5016 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5018 if (TREE_CODE (*node) == FUNCTION_DECL)
5019 DECL_IS_PURE (*node) = 1;
5020 /* ??? TODO: Support types. */
5023 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5024 *no_add_attrs = true;
5030 /* Handle a "deprecated" attribute; arguments as in
5031 struct attribute_spec.handler. */
5034 handle_deprecated_attribute (tree *node, tree name,
5035 tree args ATTRIBUTE_UNUSED, int flags,
5038 tree type = NULL_TREE;
5040 const char *what = NULL;
5045 type = TREE_TYPE (decl);
5047 if (TREE_CODE (decl) == TYPE_DECL
5048 || TREE_CODE (decl) == PARM_DECL
5049 || TREE_CODE (decl) == VAR_DECL
5050 || TREE_CODE (decl) == FUNCTION_DECL
5051 || TREE_CODE (decl) == FIELD_DECL)
5052 TREE_DEPRECATED (decl) = 1;
5056 else if (TYPE_P (*node))
5058 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5059 *node = build_type_copy (*node);
5060 TREE_DEPRECATED (*node) = 1;
5068 *no_add_attrs = true;
5069 if (type && TYPE_NAME (type))
5071 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5072 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5073 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5074 && DECL_NAME (TYPE_NAME (type)))
5075 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5078 warning ("`%s' attribute ignored for `%s'",
5079 IDENTIFIER_POINTER (name), what);
5081 warning ("`%s' attribute ignored",
5082 IDENTIFIER_POINTER (name));
5088 /* Handle a "vector_size" attribute; arguments as in
5089 struct attribute_spec.handler. */
5092 handle_vector_size_attribute (tree *node, tree name, tree args,
5093 int flags ATTRIBUTE_UNUSED,
5096 unsigned HOST_WIDE_INT vecsize, nunits;
5097 enum machine_mode mode, orig_mode, new_mode;
5098 tree type = *node, new_type, size;
5100 *no_add_attrs = true;
5102 /* Stripping NON_LVALUE_EXPR allows declarations such as
5103 typedef short v4si __attribute__((vector_size (4 * sizeof(short)))). */
5104 size = TREE_VALUE (args);
5105 if (TREE_CODE (size) == NON_LVALUE_EXPR)
5106 size = TREE_OPERAND (size, 0);
5108 if (! host_integerp (size, 1))
5110 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5114 /* Get the vector size (in bytes). */
5115 vecsize = tree_low_cst (size, 1);
5117 /* We need to provide for vector pointers, vector arrays, and
5118 functions returning vectors. For example:
5120 __attribute__((vector_size(16))) short *foo;
5122 In this case, the mode is SI, but the type being modified is
5123 HI, so we need to look further. */
5125 while (POINTER_TYPE_P (type)
5126 || TREE_CODE (type) == FUNCTION_TYPE
5127 || TREE_CODE (type) == METHOD_TYPE
5128 || TREE_CODE (type) == ARRAY_TYPE)
5129 type = TREE_TYPE (type);
5131 /* Get the mode of the type being modified. */
5132 orig_mode = TYPE_MODE (type);
5134 if (TREE_CODE (type) == RECORD_TYPE
5135 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5136 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5137 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5139 error ("invalid vector type for attribute `%s'",
5140 IDENTIFIER_POINTER (name));
5144 /* Calculate how many units fit in the vector. */
5145 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5147 /* Find a suitably sized vector. */
5148 new_mode = VOIDmode;
5149 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5151 : MODE_VECTOR_FLOAT);
5153 mode = GET_MODE_WIDER_MODE (mode))
5154 if (vecsize == GET_MODE_SIZE (mode)
5155 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5161 if (new_mode == VOIDmode)
5163 error ("no vector mode with the size and type specified could be found");
5167 new_type = build_vector_type_for_mode (type, new_mode);
5169 /* Build back pointers if needed. */
5170 *node = reconstruct_complex_type (*node, new_type);
5175 /* Handle the "nonnull" attribute. */
5177 handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
5178 tree args, int flags ATTRIBUTE_UNUSED,
5182 unsigned HOST_WIDE_INT attr_arg_num;
5184 /* If no arguments are specified, all pointer arguments should be
5185 non-null. Verify a full prototype is given so that the arguments
5186 will have the correct types when we actually check them later. */
5189 if (! TYPE_ARG_TYPES (type))
5191 error ("nonnull attribute without arguments on a non-prototype");
5192 *no_add_attrs = true;
5197 /* Argument list specified. Verify that each argument number references
5198 a pointer argument. */
5199 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5202 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5204 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5206 error ("nonnull argument has invalid operand number (arg %lu)",
5207 (unsigned long) attr_arg_num);
5208 *no_add_attrs = true;
5212 argument = TYPE_ARG_TYPES (type);
5215 for (ck_num = 1; ; ck_num++)
5217 if (! argument || ck_num == arg_num)
5219 argument = TREE_CHAIN (argument);
5223 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5225 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5226 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5227 *no_add_attrs = true;
5231 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5233 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5234 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5235 *no_add_attrs = true;
5244 /* Check the argument list of a function call for null in argument slots
5245 that are marked as requiring a non-null pointer argument. */
5248 check_function_nonnull (tree attrs, tree params)
5250 tree a, args, param;
5253 for (a = attrs; a; a = TREE_CHAIN (a))
5255 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5257 args = TREE_VALUE (a);
5259 /* Walk the argument list. If we encounter an argument number we
5260 should check for non-null, do it. If the attribute has no args,
5261 then every pointer argument is checked (in which case the check
5262 for pointer type is done in check_nonnull_arg). */
5263 for (param = params, param_num = 1; ;
5264 param_num++, param = TREE_CHAIN (param))
5268 if (! args || nonnull_check_p (args, param_num))
5269 check_function_arguments_recurse (check_nonnull_arg, NULL,
5277 /* Helper for check_function_nonnull; given a list of operands which
5278 must be non-null in ARGS, determine if operand PARAM_NUM should be
5282 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5284 unsigned HOST_WIDE_INT arg_num = 0;
5286 for (; args; args = TREE_CHAIN (args))
5288 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5291 if (arg_num == param_num)
5297 /* Check that the function argument PARAM (which is operand number
5298 PARAM_NUM) is non-null. This is called by check_function_nonnull
5299 via check_function_arguments_recurse. */
5302 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED, tree param,
5303 unsigned HOST_WIDE_INT param_num)
5305 /* Just skip checking the argument if it's not a pointer. This can
5306 happen if the "nonnull" attribute was given without an operand
5307 list (which means to check every pointer argument). */
5309 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5312 if (integer_zerop (param))
5313 warning ("null argument where non-null required (arg %lu)",
5314 (unsigned long) param_num);
5317 /* Helper for nonnull attribute handling; fetch the operand number
5318 from the attribute argument list. */
5321 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5323 /* Strip any conversions from the arg number and verify they
5325 while (TREE_CODE (arg_num_expr) == NOP_EXPR
5326 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
5327 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
5328 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
5330 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5331 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5334 *valp = TREE_INT_CST_LOW (arg_num_expr);
5338 /* Handle a "nothrow" attribute; arguments as in
5339 struct attribute_spec.handler. */
5342 handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5343 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5345 if (TREE_CODE (*node) == FUNCTION_DECL)
5346 TREE_NOTHROW (*node) = 1;
5347 /* ??? TODO: Support types. */
5350 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5351 *no_add_attrs = true;
5357 /* Handle a "cleanup" attribute; arguments as in
5358 struct attribute_spec.handler. */
5361 handle_cleanup_attribute (tree *node, tree name, tree args,
5362 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5365 tree cleanup_id, cleanup_decl;
5367 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5368 for global destructors in C++. This requires infrastructure that
5369 we don't have generically at the moment. It's also not a feature
5370 we'd be missing too much, since we do have attribute constructor. */
5371 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5373 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5374 *no_add_attrs = true;
5378 /* Verify that the argument is a function in scope. */
5379 /* ??? We could support pointers to functions here as well, if
5380 that was considered desirable. */
5381 cleanup_id = TREE_VALUE (args);
5382 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5384 error ("cleanup arg not an identifier");
5385 *no_add_attrs = true;
5388 cleanup_decl = lookup_name (cleanup_id);
5389 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5391 error ("cleanup arg not a function");
5392 *no_add_attrs = true;
5396 /* That the function has proper type is checked with the
5397 eventual call to build_function_call. */
5402 /* Handle a "warn_unused_result" attribute. No special handling. */
5405 handle_warn_unused_result_attribute (tree *node, tree name,
5406 tree args ATTRIBUTE_UNUSED,
5407 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5409 /* Ignore the attribute for functions not returning any value. */
5410 if (VOID_TYPE_P (TREE_TYPE (*node)))
5412 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5413 *no_add_attrs = true;
5419 /* Check for valid arguments being passed to a function. */
5421 check_function_arguments (tree attrs, tree params)
5423 /* Check for null being passed in a pointer argument that must be
5424 non-null. We also need to do this if format checking is enabled. */
5427 check_function_nonnull (attrs, params);
5429 /* Check for errors in format strings. */
5432 check_function_format (NULL, attrs, params);
5435 /* Generic argument checking recursion routine. PARAM is the argument to
5436 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5437 once the argument is resolved. CTX is context for the callback. */
5439 check_function_arguments_recurse (void (*callback)
5440 (void *, tree, unsigned HOST_WIDE_INT),
5441 void *ctx, tree param,
5442 unsigned HOST_WIDE_INT param_num)
5444 if (TREE_CODE (param) == NOP_EXPR)
5446 /* Strip coercion. */
5447 check_function_arguments_recurse (callback, ctx,
5448 TREE_OPERAND (param, 0), param_num);
5452 if (TREE_CODE (param) == CALL_EXPR)
5454 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5456 bool found_format_arg = false;
5458 /* See if this is a call to a known internationalization function
5459 that modifies a format arg. Such a function may have multiple
5460 format_arg attributes (for example, ngettext). */
5462 for (attrs = TYPE_ATTRIBUTES (type);
5464 attrs = TREE_CHAIN (attrs))
5465 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5468 tree format_num_expr;
5472 /* Extract the argument number, which was previously checked
5474 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5475 while (TREE_CODE (format_num_expr) == NOP_EXPR
5476 || TREE_CODE (format_num_expr) == CONVERT_EXPR
5477 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5478 format_num_expr = TREE_OPERAND (format_num_expr, 0);
5480 if (TREE_CODE (format_num_expr) != INTEGER_CST
5481 || TREE_INT_CST_HIGH (format_num_expr) != 0)
5484 format_num = TREE_INT_CST_LOW (format_num_expr);
5486 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5488 inner_args = TREE_CHAIN (inner_args), i++)
5489 if (i == format_num)
5491 check_function_arguments_recurse (callback, ctx,
5492 TREE_VALUE (inner_args),
5494 found_format_arg = true;
5499 /* If we found a format_arg attribute and did a recursive check,
5500 we are done with checking this argument. Otherwise, we continue
5501 and this will be considered a non-literal. */
5502 if (found_format_arg)
5506 if (TREE_CODE (param) == COND_EXPR)
5508 /* Check both halves of the conditional expression. */
5509 check_function_arguments_recurse (callback, ctx,
5510 TREE_OPERAND (param, 1), param_num);
5511 check_function_arguments_recurse (callback, ctx,
5512 TREE_OPERAND (param, 2), param_num);
5516 (*callback) (ctx, param, param_num);
5519 /* C implementation of lang_hooks.tree_inlining.walk_subtrees. Tracks the
5520 locus from EXPR_LOCUS and handles DECL_STMT specially. */
5523 c_walk_subtrees (tree *tp, int *walk_subtrees_p ATTRIBUTE_UNUSED,
5524 walk_tree_fn func, void *data, void *htab)
5526 enum tree_code code = TREE_CODE (*tp);
5527 location_t save_locus;
5530 #define WALK_SUBTREE(NODE) \
5533 result = walk_tree (&(NODE), func, data, htab); \
5534 if (result) goto out; \
5538 if (code != DECL_STMT)
5541 /* Set input_location here so we get the right instantiation context
5542 if we call instantiate_decl from inlinable_function_p. */
5543 save_locus = input_location;
5544 if (EXPR_LOCUS (*tp))
5545 input_location = *EXPR_LOCUS (*tp);
5547 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
5548 into declarations that are just mentioned, rather than
5549 declared; they don't really belong to this part of the tree.
5550 And, we can see cycles: the initializer for a declaration can
5551 refer to the declaration itself. */
5552 WALK_SUBTREE (DECL_INITIAL (DECL_STMT_DECL (*tp)));
5553 WALK_SUBTREE (DECL_SIZE (DECL_STMT_DECL (*tp)));
5554 WALK_SUBTREE (DECL_SIZE_UNIT (DECL_STMT_DECL (*tp)));
5555 WALK_SUBTREE (TREE_CHAIN (*tp));
5556 *walk_subtrees_p = 0;
5558 /* We didn't find what we were looking for. */
5560 input_location = save_locus;
5566 /* Function to help qsort sort FIELD_DECLs by name order. */
5569 field_decl_cmp (const void *x_p, const void *y_p)
5571 const tree *const x = x_p;
5572 const tree *const y = y_p;
5573 if (DECL_NAME (*x) == DECL_NAME (*y))
5574 /* A nontype is "greater" than a type. */
5575 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5576 if (DECL_NAME (*x) == NULL_TREE)
5578 if (DECL_NAME (*y) == NULL_TREE)
5580 if (DECL_NAME (*x) < DECL_NAME (*y))
5586 gt_pointer_operator new_value;
5590 /* This routine compares two fields like field_decl_cmp but using the
5591 pointer operator in resort_data. */
5594 resort_field_decl_cmp (const void *x_p, const void *y_p)
5596 const tree *const x = x_p;
5597 const tree *const y = y_p;
5599 if (DECL_NAME (*x) == DECL_NAME (*y))
5600 /* A nontype is "greater" than a type. */
5601 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5602 if (DECL_NAME (*x) == NULL_TREE)
5604 if (DECL_NAME (*y) == NULL_TREE)
5607 tree d1 = DECL_NAME (*x);
5608 tree d2 = DECL_NAME (*y);
5609 resort_data.new_value (&d1, resort_data.cookie);
5610 resort_data.new_value (&d2, resort_data.cookie);
5617 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5620 resort_sorted_fields (void *obj,
5621 void *orig_obj ATTRIBUTE_UNUSED ,
5622 gt_pointer_operator new_value,
5625 struct sorted_fields_type *sf = obj;
5626 resort_data.new_value = new_value;
5627 resort_data.cookie = cookie;
5628 qsort (&sf->elts[0], sf->len, sizeof (tree),
5629 resort_field_decl_cmp);
5632 /* Issue the error given by MSGID, indicating that it occurred before
5633 TOKEN, which had the associated VALUE. */
5636 c_parse_error (const char *msgid, enum cpp_ttype token, tree value)
5638 const char *string = _(msgid);
5640 if (token == CPP_EOF)
5641 error ("%s at end of input", string);
5642 else if (token == CPP_CHAR || token == CPP_WCHAR)
5644 unsigned int val = TREE_INT_CST_LOW (value);
5645 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5646 if (val <= UCHAR_MAX && ISGRAPH (val))
5647 error ("%s before %s'%c'", string, ell, val);
5649 error ("%s before %s'\\x%x'", string, ell, val);
5651 else if (token == CPP_STRING
5652 || token == CPP_WSTRING)
5653 error ("%s before string constant", string);
5654 else if (token == CPP_NUMBER)
5655 error ("%s before numeric constant", string);
5656 else if (token == CPP_NAME)
5657 error ("%s before \"%s\"", string, IDENTIFIER_POINTER (value));
5658 else if (token < N_TTYPES)
5659 error ("%s before '%s' token", string, cpp_type2name (token));
5661 error ("%s", string);
5664 /* Walk a gimplified function and warn for functions whose return value is
5665 ignored and attribute((warn_unused_result)) is set. This is done before
5666 inlining, so we don't have to worry about that. */
5669 c_warn_unused_result (tree *top_p)
5672 tree_stmt_iterator i;
5675 switch (TREE_CODE (t))
5677 case STATEMENT_LIST:
5678 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
5679 c_warn_unused_result (tsi_stmt_ptr (i));
5683 c_warn_unused_result (&COND_EXPR_THEN (t));
5684 c_warn_unused_result (&COND_EXPR_ELSE (t));
5687 c_warn_unused_result (&BIND_EXPR_BODY (t));
5689 case TRY_FINALLY_EXPR:
5690 case TRY_CATCH_EXPR:
5691 c_warn_unused_result (&TREE_OPERAND (t, 0));
5692 c_warn_unused_result (&TREE_OPERAND (t, 1));
5695 c_warn_unused_result (&CATCH_BODY (t));
5697 case EH_FILTER_EXPR:
5698 c_warn_unused_result (&EH_FILTER_FAILURE (t));
5702 /* This is a naked call, as opposed to a CALL_EXPR nested inside
5703 a MODIFY_EXPR. All calls whose value is ignored should be
5704 represented like this. Look for the attribute. */
5705 fdecl = get_callee_fndecl (t);
5707 ftype = TREE_TYPE (fdecl);
5710 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
5711 /* Look past pointer-to-function to the function type itself. */
5712 ftype = TREE_TYPE (ftype);
5715 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
5718 warning ("%Hignoring return value of `%D', "
5719 "declared with attribute warn_unused_result",
5720 EXPR_LOCUS (t), fdecl);
5722 warning ("%Hignoring return value of function "
5723 "declared with attribute warn_unused_result",
5729 /* Not a container, not a call, or a call whose value is used. */
5734 #include "gt-c-common.h"