1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
46 cpp_reader *parse_in; /* Declared in c-pragma.h. */
48 /* We let tm.h override the types used here, to handle trivial differences
49 such as the choice of unsigned int or long unsigned int for size_t.
50 When machines start needing nontrivial differences in the size type,
51 it would be best to do something here to figure out automatically
52 from other information what type to use. */
55 #define SIZE_TYPE "long unsigned int"
59 #define WCHAR_TYPE "int"
62 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
63 #define MODIFIED_WCHAR_TYPE \
64 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
67 #define PTRDIFF_TYPE "long int"
71 #define WINT_TYPE "unsigned int"
75 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
77 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
85 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
86 ? "long unsigned int" \
87 : "long long unsigned int"))
90 /* The following symbols are subsumed in the c_global_trees array, and
91 listed here individually for documentation purposes.
93 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
95 tree short_integer_type_node;
96 tree long_integer_type_node;
97 tree long_long_integer_type_node;
99 tree short_unsigned_type_node;
100 tree long_unsigned_type_node;
101 tree long_long_unsigned_type_node;
103 tree truthvalue_type_node;
104 tree truthvalue_false_node;
105 tree truthvalue_true_node;
107 tree ptrdiff_type_node;
109 tree unsigned_char_type_node;
110 tree signed_char_type_node;
111 tree wchar_type_node;
112 tree signed_wchar_type_node;
113 tree unsigned_wchar_type_node;
115 tree float_type_node;
116 tree double_type_node;
117 tree long_double_type_node;
119 tree complex_integer_type_node;
120 tree complex_float_type_node;
121 tree complex_double_type_node;
122 tree complex_long_double_type_node;
124 tree intQI_type_node;
125 tree intHI_type_node;
126 tree intSI_type_node;
127 tree intDI_type_node;
128 tree intTI_type_node;
130 tree unsigned_intQI_type_node;
131 tree unsigned_intHI_type_node;
132 tree unsigned_intSI_type_node;
133 tree unsigned_intDI_type_node;
134 tree unsigned_intTI_type_node;
136 tree widest_integer_literal_type_node;
137 tree widest_unsigned_literal_type_node;
139 Nodes for types `void *' and `const void *'.
141 tree ptr_type_node, const_ptr_type_node;
143 Nodes for types `char *' and `const char *'.
145 tree string_type_node, const_string_type_node;
147 Type `char[SOMENUMBER]'.
148 Used when an array of char is needed and the size is irrelevant.
150 tree char_array_type_node;
152 Type `int[SOMENUMBER]' or something like it.
153 Used when an array of int needed and the size is irrelevant.
155 tree int_array_type_node;
157 Type `wchar_t[SOMENUMBER]' or something like it.
158 Used when a wide string literal is created.
160 tree wchar_array_type_node;
162 Type `int ()' -- used for implicit declaration of functions.
164 tree default_function_type;
166 A VOID_TYPE node, packaged in a TREE_LIST.
170 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
171 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
172 VAR_DECLS, but C++ does.)
174 tree function_name_decl_node;
175 tree pretty_function_name_decl_node;
176 tree c99_function_name_decl_node;
178 Stack of nested function name VAR_DECLs.
180 tree saved_function_name_decls;
184 tree c_global_trees[CTI_MAX];
186 /* TRUE if a code represents a statement. The front end init
187 langhook should take care of initialization of this array. */
189 bool statement_code_p[MAX_TREE_CODES];
191 /* Switches common to the C front ends. */
193 /* Nonzero if prepreprocessing only. */
195 int flag_preprocess_only;
197 /* Nonzero means don't output line number information. */
199 char flag_no_line_commands;
201 /* Nonzero causes -E output not to be done, but directives such as
202 #define that have side effects are still obeyed. */
206 /* Nonzero means dump macros in some fashion. */
208 char flag_dump_macros;
210 /* Nonzero means pass #include lines through to the output. */
212 char flag_dump_includes;
214 /* The file name to which we should write a precompiled header, or
215 NULL if no header will be written in this compile. */
217 const char *pch_file;
219 /* Nonzero if an ISO standard was selected. It rejects macros in the
223 /* Nonzero if -undef was given. It suppresses target built-in macros
227 /* Nonzero means don't recognize the non-ANSI builtin functions. */
231 /* Nonzero means don't recognize the non-ANSI builtin functions.
234 int flag_no_nonansi_builtin;
236 /* Nonzero means give `double' the same size as `float'. */
238 int flag_short_double;
240 /* Nonzero means give `wchar_t' the same size as `short'. */
242 int flag_short_wchar;
244 /* Nonzero means allow Microsoft extensions without warnings or errors. */
245 int flag_ms_extensions;
247 /* Nonzero means don't recognize the keyword `asm'. */
251 /* Nonzero means give string constants the type `const char *', as mandated
254 int flag_const_strings;
256 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
258 int flag_signed_bitfields = 1;
259 int explicit_flag_signed_bitfields;
261 /* Nonzero means warn about pointer casts that can drop a type qualifier
262 from the pointer target type. */
266 /* Warn about functions which might be candidates for format attributes. */
268 int warn_missing_format_attribute;
270 /* Nonzero means warn about sizeof(function) or addition/subtraction
271 of function pointers. */
273 int warn_pointer_arith;
275 /* Nonzero means do not warn that K&R style main() is not a function prototype. */
277 int flag_bsd_no_warn_kr_main;
279 /* Nonzero means warn for any global function def
280 without separate previous prototype decl. */
282 int warn_missing_prototypes;
284 /* Warn if adding () is suggested. */
286 int warn_parentheses;
288 /* Warn if initializer is not completely bracketed. */
290 int warn_missing_braces;
292 /* Warn about comparison of signed and unsigned values.
293 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified
294 (in which case -Wextra gets to decide). */
296 int warn_sign_compare = -1;
298 /* Nonzero means warn about usage of long long when `-pedantic'. */
300 int warn_long_long = 1;
302 /* Nonzero means warn about deprecated conversion from string constant to
305 int warn_write_strings;
307 /* Nonzero means warn about multiple (redundant) decls for the same single
308 variable or function. */
310 int warn_redundant_decls;
312 /* Warn about testing equality of floating point numbers. */
314 int warn_float_equal;
316 /* Warn about a subscript that has type char. */
318 int warn_char_subscripts;
320 /* Warn if a type conversion is done that might have confusing results. */
324 /* Warn about #pragma directives that are not recognized. */
326 int warn_unknown_pragmas; /* Tri state variable. */
328 /* Warn about format/argument anomalies in calls to formatted I/O functions
329 (*printf, *scanf, strftime, strfmon, etc.). */
333 /* Warn about Y2K problems with strftime formats. */
337 /* Warn about excess arguments to formats. */
339 int warn_format_extra_args;
341 /* Warn about zero-length formats. */
343 int warn_format_zero_length;
345 /* Warn about non-literal format arguments. */
347 int warn_format_nonliteral;
349 /* Warn about possible security problems with calls to format functions. */
351 int warn_format_security;
353 /* Zero means that faster, ...NonNil variants of objc_msgSend...
354 calls will be used in ObjC; passing nil receivers to such calls
355 will most likely result in crashes. */
356 int flag_nil_receivers = 1;
358 /* Nonzero means that we will allow new ObjC exception syntax (@throw,
359 @try, etc.) in source code. */
360 int flag_objc_exceptions = 0;
362 /* Nonzero means that code generation will be altered to support
363 "zero-link" execution. This currently affects ObjC only, but may
364 affect other languages in the future. */
365 int flag_zero_link = 0;
367 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
368 unit. It will inform the ObjC runtime that class definition(s) herein
369 contained are to replace one(s) previously loaded. */
370 int flag_replace_objc_classes = 0;
372 /* C/ObjC language option variables. */
375 /* Nonzero means message about use of implicit function declarations;
376 1 means warning; 2 means error. */
378 int mesg_implicit_function_declaration = -1;
380 /* Nonzero means allow type mismatches in conditional expressions;
381 just make their values `void'. */
383 int flag_cond_mismatch;
385 /* Nonzero means enable C89 Amendment 1 features. */
389 /* Nonzero means use the ISO C99 dialect of C. */
393 /* Nonzero means allow the BSD kernel printf enhancements. */
397 /* Nonzero means that we have builtin functions, and main is an int. */
401 /* Nonzero means warn when casting a function call to a type that does
402 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
403 when there is no previous declaration of sqrt or malloc. */
405 int warn_bad_function_cast;
407 /* Warn about traditional constructs whose meanings changed in ANSI C. */
409 int warn_traditional;
411 /* Nonzero means warn for a declaration found after a statement. */
413 int warn_declaration_after_statement;
415 /* Nonzero means warn for non-prototype function decls
416 or non-prototyped defs without previous prototype. */
418 int warn_strict_prototypes;
420 /* Nonzero means warn for any global function def
421 without separate previous decl. */
423 int warn_missing_declarations;
425 /* Nonzero means warn about declarations of objects not at
426 file-scope level and about *all* declarations of functions (whether
427 or static) not at file-scope level. Note that we exclude
428 implicit function declarations. To get warnings about those, use
431 int warn_nested_externs;
433 /* Warn if main is suspicious. */
437 /* Nonzero means warn about possible violations of sequence point rules. */
439 int warn_sequence_point;
441 /* Nonzero means warn about uninitialized variable when it is initialized with itself.
442 For example: int i = i;, GCC will not warn about this when warn_init_self is nonzero. */
446 /* Nonzero means to warn about compile-time division by zero. */
447 int warn_div_by_zero = 1;
449 /* Nonzero means warn about use of implicit int. */
451 int warn_implicit_int;
453 /* Warn about NULL being passed to argument slots marked as requiring
458 /* Warn about old-style parameter declaration. */
460 int warn_old_style_definition;
463 /* ObjC language option variables. */
466 /* Open and close the file for outputting class declarations, if
469 int flag_gen_declaration;
471 /* Generate code for GNU or NeXT runtime environment. */
473 #ifdef NEXT_OBJC_RUNTIME
474 int flag_next_runtime = 1;
476 int flag_next_runtime = 0;
479 /* Tells the compiler that this is a special run. Do not perform any
480 compiling, instead we are to test some platform dependent features
481 and output a C header file with appropriate definitions. */
483 int print_struct_values;
485 /* ???. Undocumented. */
487 const char *constant_string_class_name;
489 /* Warn if multiple methods are seen for the same selector, but with
490 different argument types. Performs the check on the whole selector
491 table at the end of compilation. */
495 /* Warn if a @selector() is found, and no method with that selector
496 has been previously declared. The check is done on each
497 @selector() as soon as it is found - so it warns about forward
500 int warn_undeclared_selector;
502 /* Warn if methods required by a protocol are not implemented in the
503 class adopting it. When turned off, methods inherited to that
504 class are also considered implemented. */
506 int warn_protocol = 1;
509 /* C++ language option variables. */
512 /* Nonzero means don't recognize any extension keywords. */
514 int flag_no_gnu_keywords;
516 /* Nonzero means do emit exported implementations of functions even if
517 they can be inlined. */
519 int flag_implement_inlines = 1;
521 /* Nonzero means that implicit instantiations will be emitted if needed. */
523 int flag_implicit_templates = 1;
525 /* Nonzero means that implicit instantiations of inline templates will be
526 emitted if needed, even if instantiations of non-inline templates
529 int flag_implicit_inline_templates = 1;
531 /* Nonzero means generate separate instantiation control files and
532 juggle them at link time. */
534 int flag_use_repository;
536 /* Nonzero if we want to issue diagnostics that the standard says are not
539 int flag_optional_diags = 1;
541 /* Nonzero means we should attempt to elide constructors when possible. */
543 int flag_elide_constructors = 1;
545 /* Nonzero means that member functions defined in class scope are
546 inline by default. */
548 int flag_default_inline = 1;
550 /* Controls whether compiler generates 'type descriptor' that give
551 run-time type information. */
555 /* Nonzero if we want to conserve space in the .o files. We do this
556 by putting uninitialized data and runtime initialized data into
557 .common instead of .data at the expense of not flagging multiple
560 int flag_conserve_space;
562 /* Nonzero if we want to obey access control semantics. */
564 int flag_access_control = 1;
566 /* Nonzero if we want to check the return value of new and avoid calling
567 constructors if it is a null pointer. */
571 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
572 initialization variables.
573 0: Old rules, set by -fno-for-scope.
574 2: New ISO rules, set by -ffor-scope.
575 1: Try to implement new ISO rules, but with backup compatibility
576 (and warnings). This is the default, for now. */
578 int flag_new_for_scope = 1;
580 /* Nonzero if we want to emit defined symbols with common-like linkage as
581 weak symbols where possible, in order to conform to C++ semantics.
582 Otherwise, emit them as local symbols. */
586 /* 0 means we want the preprocessor to not emit line directives for
587 the current working directory. 1 means we want it to do it. -1
588 means we should decide depending on whether debugging information
589 is being emitted or not. */
591 int flag_working_directory = -1;
593 /* Nonzero to use __cxa_atexit, rather than atexit, to register
594 destructors for local statics and global objects. */
596 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
598 /* Nonzero means make the default pedwarns warnings instead of errors.
599 The value of this flag is ignored if -pedantic is specified. */
603 /* Nonzero means to implement standard semantics for exception
604 specifications, calling unexpected if an exception is thrown that
605 doesn't match the specification. Zero means to treat them as
606 assertions and optimize accordingly, but not check them. */
608 int flag_enforce_eh_specs = 1;
610 /* Nonzero means warn about things that will change when compiling
611 with an ABI-compliant compiler. */
615 /* Nonzero means warn about invalid uses of offsetof. */
617 int warn_invalid_offsetof = 1;
619 /* Nonzero means warn about implicit declarations. */
621 int warn_implicit = 1;
623 /* Nonzero means warn when all ctors or dtors are private, and the class
626 int warn_ctor_dtor_privacy = 0;
628 /* Nonzero means warn in function declared in derived class has the
629 same name as a virtual in the base class, but fails to match the
630 type signature of any virtual function in the base class. */
632 int warn_overloaded_virtual;
634 /* Nonzero means warn when declaring a class that has a non virtual
635 destructor, when it really ought to have a virtual one. */
639 /* Nonzero means warn when the compiler will reorder code. */
643 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
647 /* Nonzero means warn when we convert a pointer to member function
648 into a pointer to (void or function). */
650 int warn_pmf2ptr = 1;
652 /* Nonzero means warn about violation of some Effective C++ style rules. */
656 /* Nonzero means warn where overload resolution chooses a promotion from
657 unsigned to signed over a conversion to an unsigned of the same size. */
661 /* Nonzero means warn when an old-style cast is used. */
663 int warn_old_style_cast;
665 /* Nonzero means warn when non-templatized friend functions are
666 declared within a template */
668 int warn_nontemplate_friend = 1;
670 /* Nonzero means complain about deprecated features. */
672 int warn_deprecated = 1;
674 /* Maximum template instantiation depth. This limit is rather
675 arbitrary, but it exists to limit the time it takes to notice
676 infinite template instantiations. */
678 int max_tinst_depth = 500;
682 /* The elements of `ridpointers' are identifier nodes for the reserved
683 type names and storage classes. It is indexed by a RID_... value. */
686 tree (*make_fname_decl) (tree, int);
688 /* If non-NULL, the address of a language-specific function that takes
689 any action required right before expand_function_end is called. */
690 void (*lang_expand_function_end) (void);
692 /* Nonzero means the expression being parsed will never be evaluated.
693 This is a count, since unevaluated expressions can nest. */
696 /* Information about how a function name is generated. */
699 tree *const decl; /* pointer to the VAR_DECL. */
700 const unsigned rid; /* RID number for the identifier. */
701 const int pretty; /* How pretty is it? */
704 /* The three ways of getting then name of the current function. */
706 const struct fname_var_t fname_vars[] =
708 /* C99 compliant __func__, must be first. */
709 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
710 /* GCC __FUNCTION__ compliant. */
711 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
712 /* GCC __PRETTY_FUNCTION__ compliant. */
713 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
717 static int constant_fits_type_p (tree, tree);
719 /* Keep a stack of if statements. We record the number of compound
720 statements seen up to the if keyword, as well as the line number
721 and file of the if. If a potentially ambiguous else is seen, that
722 fact is recorded; the warning is issued when we can be sure that
723 the enclosing if statement does not have an else branch. */
732 static if_elt *if_stack;
734 /* Amount of space in the if statement stack. */
735 static int if_stack_space = 0;
738 static int if_stack_pointer = 0;
740 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
741 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
742 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
743 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
744 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
745 static tree handle_always_inline_attribute (tree *, tree, tree, int,
747 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
748 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
749 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
750 static tree handle_transparent_union_attribute (tree *, tree, tree,
752 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
753 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
754 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
755 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
756 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
757 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
758 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
759 static tree handle_visibility_attribute (tree *, tree, tree, int,
761 static tree handle_tls_model_attribute (tree *, tree, tree, int,
763 static tree handle_no_instrument_function_attribute (tree *, tree,
765 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
766 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
768 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
769 static tree handle_deprecated_attribute (tree *, tree, tree, int,
771 static tree handle_vector_size_attribute (tree *, tree, tree, int,
773 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
774 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
775 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
776 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
779 static void check_function_nonnull (tree, tree);
780 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
781 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
782 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
783 static int resort_field_decl_cmp (const void *, const void *);
785 /* Table of machine-independent attributes common to all C-like languages. */
786 const struct attribute_spec c_common_attribute_table[] =
788 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
789 { "packed", 0, 0, false, false, false,
790 handle_packed_attribute },
791 { "nocommon", 0, 0, true, false, false,
792 handle_nocommon_attribute },
793 { "common", 0, 0, true, false, false,
794 handle_common_attribute },
795 /* FIXME: logically, noreturn attributes should be listed as
796 "false, true, true" and apply to function types. But implementing this
797 would require all the places in the compiler that use TREE_THIS_VOLATILE
798 on a decl to identify non-returning functions to be located and fixed
799 to check the function type instead. */
800 { "noreturn", 0, 0, true, false, false,
801 handle_noreturn_attribute },
802 { "volatile", 0, 0, true, false, false,
803 handle_noreturn_attribute },
804 { "noinline", 0, 0, true, false, false,
805 handle_noinline_attribute },
806 { "always_inline", 0, 0, true, false, false,
807 handle_always_inline_attribute },
808 { "used", 0, 0, true, false, false,
809 handle_used_attribute },
810 { "unused", 0, 0, false, false, false,
811 handle_unused_attribute },
812 /* The same comments as for noreturn attributes apply to const ones. */
813 { "const", 0, 0, true, false, false,
814 handle_const_attribute },
815 { "transparent_union", 0, 0, false, false, false,
816 handle_transparent_union_attribute },
817 { "constructor", 0, 0, true, false, false,
818 handle_constructor_attribute },
819 { "destructor", 0, 0, true, false, false,
820 handle_destructor_attribute },
821 { "mode", 1, 1, false, true, false,
822 handle_mode_attribute },
823 { "section", 1, 1, true, false, false,
824 handle_section_attribute },
825 { "aligned", 0, 1, false, false, false,
826 handle_aligned_attribute },
827 { "weak", 0, 0, true, false, false,
828 handle_weak_attribute },
829 { "alias", 1, 1, true, false, false,
830 handle_alias_attribute },
831 { "no_instrument_function", 0, 0, true, false, false,
832 handle_no_instrument_function_attribute },
833 { "malloc", 0, 0, true, false, false,
834 handle_malloc_attribute },
835 { "no_stack_limit", 0, 0, true, false, false,
836 handle_no_limit_stack_attribute },
837 { "pure", 0, 0, true, false, false,
838 handle_pure_attribute },
839 { "deprecated", 0, 0, false, false, false,
840 handle_deprecated_attribute },
841 { "vector_size", 1, 1, false, true, false,
842 handle_vector_size_attribute },
843 { "visibility", 1, 1, true, false, false,
844 handle_visibility_attribute },
845 { "tls_model", 1, 1, true, false, false,
846 handle_tls_model_attribute },
847 { "nonnull", 0, -1, false, true, true,
848 handle_nonnull_attribute },
849 { "nothrow", 0, 0, true, false, false,
850 handle_nothrow_attribute },
851 { "may_alias", 0, 0, false, true, false, NULL },
852 { "cleanup", 1, 1, true, false, false,
853 handle_cleanup_attribute },
854 { "warn_unused_result", 0, 0, false, true, true,
855 handle_warn_unused_result_attribute },
856 { NULL, 0, 0, false, false, false, NULL }
859 /* Give the specifications for the format attributes, used by C and all
862 const struct attribute_spec c_common_format_attribute_table[] =
864 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
865 { "format", 3, 3, false, true, true,
866 handle_format_attribute },
867 { "format_arg", 1, 1, false, true, true,
868 handle_format_arg_attribute },
869 { NULL, 0, 0, false, false, false, NULL }
872 /* Record the start of an if-then, and record the start of it
873 for ambiguous else detection.
875 COND is the condition for the if-then statement.
877 IF_STMT is the statement node that has already been created for
878 this if-then statement. It is created before parsing the
879 condition to keep line number information accurate. */
882 c_expand_start_cond (tree cond, int compstmt_count, tree if_stmt)
884 /* Make sure there is enough space on the stack. */
885 if (if_stack_space == 0)
888 if_stack = xmalloc (10 * sizeof (if_elt));
890 else if (if_stack_space == if_stack_pointer)
892 if_stack_space += 10;
893 if_stack = xrealloc (if_stack, if_stack_space * sizeof (if_elt));
896 IF_COND (if_stmt) = cond;
899 /* Record this if statement. */
900 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
901 if_stack[if_stack_pointer].locus = input_location;
902 if_stack[if_stack_pointer].needs_warning = 0;
903 if_stack[if_stack_pointer].if_stmt = if_stmt;
907 /* Called after the then-clause for an if-statement is processed. */
912 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
913 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
916 /* Record the end of an if-then. Optionally warn if a nested
917 if statement had an ambiguous else clause. */
920 c_expand_end_cond (void)
923 if (if_stack[if_stack_pointer].needs_warning)
924 warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
925 &if_stack[if_stack_pointer].locus);
926 last_expr_type = NULL_TREE;
929 /* Called between the then-clause and the else-clause
930 of an if-then-else. */
933 c_expand_start_else (void)
935 /* An ambiguous else warning must be generated for the enclosing if
936 statement, unless we see an else branch for that one, too. */
938 && if_stack_pointer > 1
939 && (if_stack[if_stack_pointer - 1].compstmt_count
940 == if_stack[if_stack_pointer - 2].compstmt_count))
941 if_stack[if_stack_pointer - 2].needs_warning = 1;
943 /* Even if a nested if statement had an else branch, it can't be
944 ambiguous if this one also has an else. So don't warn in that
945 case. Also don't warn for any if statements nested in this else. */
946 if_stack[if_stack_pointer - 1].needs_warning = 0;
947 if_stack[if_stack_pointer - 1].compstmt_count--;
950 /* Called after the else-clause for an if-statement is processed. */
955 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
956 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
959 /* Begin an if-statement. Returns a newly created IF_STMT if
962 Unlike the C++ front-end, we do not call add_stmt here; it is
963 probably safe to do so, but I am not very familiar with this
964 code so I am being extra careful not to change its behavior
965 beyond what is strictly necessary for correctness. */
968 c_begin_if_stmt (void)
971 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
975 /* Begin a while statement. Returns a newly created WHILE_STMT if
978 Unlike the C++ front-end, we do not call add_stmt here; it is
979 probably safe to do so, but I am not very familiar with this
980 code so I am being extra careful not to change its behavior
981 beyond what is strictly necessary for correctness. */
984 c_begin_while_stmt (void)
987 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
992 c_finish_while_stmt_cond (tree cond, tree while_stmt)
994 WHILE_COND (while_stmt) = cond;
997 /* Push current bindings for the function name VAR_DECLS. */
1000 start_fname_decls (void)
1003 tree saved = NULL_TREE;
1005 for (ix = 0; fname_vars[ix].decl; ix++)
1007 tree decl = *fname_vars[ix].decl;
1011 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
1012 *fname_vars[ix].decl = NULL_TREE;
1015 if (saved || saved_function_name_decls)
1016 /* Normally they'll have been NULL, so only push if we've got a
1017 stack, or they are non-NULL. */
1018 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1019 saved_function_name_decls);
1022 /* Finish up the current bindings, adding them into the
1023 current function's statement tree. This is done by wrapping the
1024 function's body in a COMPOUND_STMT containing these decls too. This
1025 must be done _before_ finish_stmt_tree is called. If there is no
1026 current function, we must be at file scope and no statements are
1027 involved. Pop the previous bindings. */
1030 finish_fname_decls (void)
1033 tree body = NULL_TREE;
1034 tree stack = saved_function_name_decls;
1036 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1037 body = chainon (TREE_VALUE (stack), body);
1041 /* They were called into existence, so add to statement tree. Add
1042 the DECL_STMTs inside the outermost scope. */
1043 tree *p = &DECL_SAVED_TREE (current_function_decl);
1044 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1045 while (TREE_CODE (*p) != COMPOUND_STMT)
1047 if (TREE_CODE (*p) == EXPR_STMT)
1048 p = &TREE_CHAIN (*p);
1050 p = &TREE_OPERAND(*p, 0);
1053 p = &COMPOUND_BODY (*p);
1054 if (TREE_CODE (*p) == SCOPE_STMT)
1055 p = &TREE_CHAIN (*p);
1057 body = chainon (body, *p);
1061 for (ix = 0; fname_vars[ix].decl; ix++)
1062 *fname_vars[ix].decl = NULL_TREE;
1066 /* We had saved values, restore them. */
1069 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1071 tree decl = TREE_PURPOSE (saved);
1072 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1074 *fname_vars[ix].decl = decl;
1076 stack = TREE_CHAIN (stack);
1078 saved_function_name_decls = stack;
1081 /* Return the text name of the current function, suitably prettified
1085 fname_as_string (int pretty_p)
1087 const char *name = "top level";
1096 if (current_function_decl)
1097 name = (*lang_hooks.decl_printable_name) (current_function_decl, vrb);
1102 /* Return the VAR_DECL for a const char array naming the current
1103 function. If the VAR_DECL has not yet been created, create it
1104 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1105 ID is its name (unfortunately C and C++ hold the RID values of
1106 keywords in different places, so we can't derive RID from ID in
1107 this language independent code. */
1110 fname_decl (unsigned int rid, tree id)
1113 tree decl = NULL_TREE;
1115 for (ix = 0; fname_vars[ix].decl; ix++)
1116 if (fname_vars[ix].rid == rid)
1119 decl = *fname_vars[ix].decl;
1122 tree saved_last_tree = last_tree;
1123 /* If a tree is built here, it would normally have the lineno of
1124 the current statement. Later this tree will be moved to the
1125 beginning of the function and this line number will be wrong.
1126 To avoid this problem set the lineno to 0 here; that prevents
1127 it from appearing in the RTL. */
1128 int saved_lineno = input_line;
1131 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1132 if (last_tree != saved_last_tree)
1134 /* We created some statement tree for the decl. This belongs
1135 at the start of the function, so remove it now and reinsert
1136 it after the function is complete. */
1137 tree stmts = TREE_CHAIN (saved_last_tree);
1139 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1140 last_tree = saved_last_tree;
1141 saved_function_name_decls = tree_cons (decl, stmts,
1142 saved_function_name_decls);
1144 *fname_vars[ix].decl = decl;
1145 input_line = saved_lineno;
1147 if (!ix && !current_function_decl)
1148 pedwarn ("'%D' is not defined outside of function scope", decl);
1153 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1156 fix_string_type (tree value)
1158 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1159 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1160 const int nchars_max = flag_isoc99 ? 4095 : 509;
1161 int length = TREE_STRING_LENGTH (value);
1164 /* Compute the number of elements, for the array type. */
1165 nchars = wide_flag ? length / wchar_bytes : length;
1167 if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
1168 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1169 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1171 /* Create the array type for the string constant.
1172 -Wwrite-strings says make the string constant an array of const char
1173 so that copying it to a non-const pointer will get a warning.
1174 For C++, this is the standard behavior. */
1175 if (flag_const_strings && ! flag_writable_strings)
1178 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1181 = build_array_type (elements,
1182 build_index_type (build_int_2 (nchars - 1, 0)));
1186 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1187 build_index_type (build_int_2 (nchars - 1, 0)));
1189 TREE_CONSTANT (value) = 1;
1190 TREE_READONLY (value) = ! flag_writable_strings;
1191 TREE_STATIC (value) = 1;
1195 /* Print a warning if a constant expression had overflow in folding.
1196 Invoke this function on every expression that the language
1197 requires to be a constant expression.
1198 Note the ANSI C standard says it is erroneous for a
1199 constant expression to overflow. */
1202 constant_expression_warning (tree value)
1204 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1205 || TREE_CODE (value) == VECTOR_CST
1206 || TREE_CODE (value) == COMPLEX_CST)
1207 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1208 pedwarn ("overflow in constant expression");
1211 /* Print a warning if an expression had overflow in folding.
1212 Invoke this function on every expression that
1213 (1) appears in the source code, and
1214 (2) might be a constant expression that overflowed, and
1215 (3) is not already checked by convert_and_check;
1216 however, do not invoke this function on operands of explicit casts. */
1219 overflow_warning (tree value)
1221 if ((TREE_CODE (value) == INTEGER_CST
1222 || (TREE_CODE (value) == COMPLEX_CST
1223 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1224 && TREE_OVERFLOW (value))
1226 TREE_OVERFLOW (value) = 0;
1227 if (skip_evaluation == 0)
1228 warning ("integer overflow in expression");
1230 else if ((TREE_CODE (value) == REAL_CST
1231 || (TREE_CODE (value) == COMPLEX_CST
1232 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1233 && TREE_OVERFLOW (value))
1235 TREE_OVERFLOW (value) = 0;
1236 if (skip_evaluation == 0)
1237 warning ("floating point overflow in expression");
1239 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1241 TREE_OVERFLOW (value) = 0;
1242 if (skip_evaluation == 0)
1243 warning ("vector overflow in expression");
1247 /* Print a warning if a large constant is truncated to unsigned,
1248 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1249 Invoke this function on every expression that might be implicitly
1250 converted to an unsigned type. */
1253 unsigned_conversion_warning (tree result, tree operand)
1255 tree type = TREE_TYPE (result);
1257 if (TREE_CODE (operand) == INTEGER_CST
1258 && TREE_CODE (type) == INTEGER_TYPE
1259 && TREE_UNSIGNED (type)
1260 && skip_evaluation == 0
1261 && !int_fits_type_p (operand, type))
1263 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1264 /* This detects cases like converting -129 or 256 to unsigned char. */
1265 warning ("large integer implicitly truncated to unsigned type");
1266 else if (warn_conversion)
1267 warning ("negative integer implicitly converted to unsigned type");
1271 /* Nonzero if constant C has a value that is permissible
1272 for type TYPE (an INTEGER_TYPE). */
1275 constant_fits_type_p (tree c, tree type)
1277 if (TREE_CODE (c) == INTEGER_CST)
1278 return int_fits_type_p (c, type);
1280 c = convert (type, c);
1281 return !TREE_OVERFLOW (c);
1284 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1285 Invoke this function on every expression that is converted implicitly,
1286 i.e. because of language rules and not because of an explicit cast. */
1289 convert_and_check (tree type, tree expr)
1291 tree t = convert (type, expr);
1292 if (TREE_CODE (t) == INTEGER_CST)
1294 if (TREE_OVERFLOW (t))
1296 TREE_OVERFLOW (t) = 0;
1298 /* Do not diagnose overflow in a constant expression merely
1299 because a conversion overflowed. */
1300 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1302 /* No warning for converting 0x80000000 to int. */
1303 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1304 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1305 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1306 /* If EXPR fits in the unsigned version of TYPE,
1307 don't warn unless pedantic. */
1309 || TREE_UNSIGNED (type)
1310 || ! constant_fits_type_p (expr,
1311 c_common_unsigned_type (type)))
1312 && skip_evaluation == 0)
1313 warning ("overflow in implicit constant conversion");
1316 unsigned_conversion_warning (t, expr);
1321 /* A node in a list that describes references to variables (EXPR), which are
1322 either read accesses if WRITER is zero, or write accesses, in which case
1323 WRITER is the parent of EXPR. */
1330 /* Used to implement a cache the results of a call to verify_tree. We only
1331 use this for SAVE_EXPRs. */
1334 struct tlist_cache *next;
1335 struct tlist *cache_before_sp;
1336 struct tlist *cache_after_sp;
1340 /* Obstack to use when allocating tlist structures, and corresponding
1342 static struct obstack tlist_obstack;
1343 static char *tlist_firstobj = 0;
1345 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1347 static struct tlist *warned_ids;
1348 /* SAVE_EXPRs need special treatment. We process them only once and then
1349 cache the results. */
1350 static struct tlist_cache *save_expr_cache;
1352 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1353 static void merge_tlist (struct tlist **, struct tlist *, int);
1354 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1355 static int warning_candidate_p (tree);
1356 static void warn_for_collisions (struct tlist *);
1357 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1358 static struct tlist *new_tlist (struct tlist *, tree, tree);
1359 static void verify_sequence_points (tree);
1361 /* Create a new struct tlist and fill in its fields. */
1362 static struct tlist *
1363 new_tlist (struct tlist *next, tree t, tree writer)
1366 l = obstack_alloc (&tlist_obstack, sizeof *l);
1373 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1374 is nonnull, we ignore any node we find which has a writer equal to it. */
1377 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1381 struct tlist *next = add->next;
1384 if (! exclude_writer || add->writer != exclude_writer)
1385 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1390 /* Merge the nodes of ADD into TO. This merging process is done so that for
1391 each variable that already exists in TO, no new node is added; however if
1392 there is a write access recorded in ADD, and an occurrence on TO is only
1393 a read access, then the occurrence in TO will be modified to record the
1397 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1399 struct tlist **end = to;
1402 end = &(*end)->next;
1408 struct tlist *next = add->next;
1410 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1411 if (tmp2->expr == add->expr)
1415 tmp2->writer = add->writer;
1419 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1420 end = &(*end)->next;
1427 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1428 references in list LIST conflict with it, excluding reads if ONLY writers
1432 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1437 /* Avoid duplicate warnings. */
1438 for (tmp = warned_ids; tmp; tmp = tmp->next)
1439 if (tmp->expr == written)
1444 if (list->expr == written
1445 && list->writer != writer
1446 && (! only_writes || list->writer))
1448 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1449 warning ("operation on `%s' may be undefined",
1450 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1456 /* Given a list LIST of references to variables, find whether any of these
1457 can cause conflicts due to missing sequence points. */
1460 warn_for_collisions (struct tlist *list)
1464 for (tmp = list; tmp; tmp = tmp->next)
1467 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1471 /* Return nonzero if X is a tree that can be verified by the sequence point
1474 warning_candidate_p (tree x)
1476 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1479 /* Walk the tree X, and record accesses to variables. If X is written by the
1480 parent tree, WRITER is the parent.
1481 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1482 expression or its only operand forces a sequence point, then everything up
1483 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1485 Once we return, we will have emitted warnings if any subexpression before
1486 such a sequence point could be undefined. On a higher level, however, the
1487 sequence point may not be relevant, and we'll merge the two lists.
1489 Example: (b++, a) + b;
1490 The call that processes the COMPOUND_EXPR will store the increment of B
1491 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1492 processes the PLUS_EXPR will need to merge the two lists so that
1493 eventually, all accesses end up on the same list (and we'll warn about the
1494 unordered subexpressions b++ and b.
1496 A note on merging. If we modify the former example so that our expression
1499 care must be taken not simply to add all three expressions into the final
1500 PNO_SP list. The function merge_tlist takes care of that by merging the
1501 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1502 way, so that no more than one access to B is recorded. */
1505 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1508 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1509 enum tree_code code;
1512 /* X may be NULL if it is the operand of an empty statement expression
1518 code = TREE_CODE (x);
1519 class = TREE_CODE_CLASS (code);
1521 if (warning_candidate_p (x))
1523 *pno_sp = new_tlist (*pno_sp, x, writer);
1533 case TRUTH_ANDIF_EXPR:
1534 case TRUTH_ORIF_EXPR:
1535 tmp_before = tmp_nosp = tmp_list3 = 0;
1536 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1537 warn_for_collisions (tmp_nosp);
1538 merge_tlist (pbefore_sp, tmp_before, 0);
1539 merge_tlist (pbefore_sp, tmp_nosp, 0);
1540 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1541 merge_tlist (pbefore_sp, tmp_list3, 0);
1545 tmp_before = tmp_list2 = 0;
1546 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1547 warn_for_collisions (tmp_list2);
1548 merge_tlist (pbefore_sp, tmp_before, 0);
1549 merge_tlist (pbefore_sp, tmp_list2, 1);
1551 tmp_list3 = tmp_nosp = 0;
1552 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1553 warn_for_collisions (tmp_nosp);
1554 merge_tlist (pbefore_sp, tmp_list3, 0);
1556 tmp_list3 = tmp_list2 = 0;
1557 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1558 warn_for_collisions (tmp_list2);
1559 merge_tlist (pbefore_sp, tmp_list3, 0);
1560 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1561 two first, to avoid warning for (a ? b++ : b++). */
1562 merge_tlist (&tmp_nosp, tmp_list2, 0);
1563 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1566 case PREDECREMENT_EXPR:
1567 case PREINCREMENT_EXPR:
1568 case POSTDECREMENT_EXPR:
1569 case POSTINCREMENT_EXPR:
1570 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1574 tmp_before = tmp_nosp = tmp_list3 = 0;
1575 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1576 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1577 /* Expressions inside the LHS are not ordered wrt. the sequence points
1578 in the RHS. Example:
1580 Despite the fact that the modification of "a" is in the before_sp
1581 list (tmp_before), it conflicts with the use of "a" in the LHS.
1582 We can handle this by adding the contents of tmp_list3
1583 to those of tmp_before, and redoing the collision warnings for that
1585 add_tlist (&tmp_before, tmp_list3, x, 1);
1586 warn_for_collisions (tmp_before);
1587 /* Exclude the LHS itself here; we first have to merge it into the
1588 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1589 didn't exclude the LHS, we'd get it twice, once as a read and once
1591 add_tlist (pno_sp, tmp_list3, x, 0);
1592 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1594 merge_tlist (pbefore_sp, tmp_before, 0);
1595 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1596 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1597 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1601 /* We need to warn about conflicts among arguments and conflicts between
1602 args and the function address. Side effects of the function address,
1603 however, are not ordered by the sequence point of the call. */
1604 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1605 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1606 if (TREE_OPERAND (x, 1))
1607 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1608 merge_tlist (&tmp_list3, tmp_list2, 0);
1609 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1610 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1611 warn_for_collisions (tmp_before);
1612 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1616 /* Scan all the list, e.g. indices of multi dimensional array. */
1619 tmp_before = tmp_nosp = 0;
1620 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1621 merge_tlist (&tmp_nosp, tmp_before, 0);
1622 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1629 struct tlist_cache *t;
1630 for (t = save_expr_cache; t; t = t->next)
1636 t = obstack_alloc (&tlist_obstack, sizeof *t);
1637 t->next = save_expr_cache;
1639 save_expr_cache = t;
1641 tmp_before = tmp_nosp = 0;
1642 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1643 warn_for_collisions (tmp_nosp);
1648 struct tlist *t = tmp_nosp;
1650 merge_tlist (&tmp_list3, t, 0);
1652 t->cache_before_sp = tmp_before;
1653 t->cache_after_sp = tmp_list3;
1655 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1656 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1665 if (first_rtl_op (code) == 0)
1667 x = TREE_OPERAND (x, 0);
1683 int max = first_rtl_op (TREE_CODE (x));
1684 for (lp = 0; lp < max; lp++)
1686 tmp_before = tmp_nosp = 0;
1687 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1688 merge_tlist (&tmp_nosp, tmp_before, 0);
1689 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1696 /* Try to warn for undefined behavior in EXPR due to missing sequence
1700 verify_sequence_points (tree expr)
1702 struct tlist *before_sp = 0, *after_sp = 0;
1705 save_expr_cache = 0;
1706 if (tlist_firstobj == 0)
1708 gcc_obstack_init (&tlist_obstack);
1709 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1712 verify_tree (expr, &before_sp, &after_sp, 0);
1713 warn_for_collisions (after_sp);
1714 obstack_free (&tlist_obstack, tlist_firstobj);
1718 c_expand_expr_stmt (tree expr)
1720 /* Do default conversion if safe and possibly important,
1721 in case within ({...}). */
1722 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1723 && (flag_isoc99 || lvalue_p (expr)))
1724 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1725 expr = default_conversion (expr);
1727 if (warn_sequence_point)
1728 verify_sequence_points (expr);
1730 if (TREE_TYPE (expr) != error_mark_node
1731 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1732 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1733 error ("expression statement has incomplete type");
1735 last_expr_type = TREE_TYPE (expr);
1736 return add_stmt (build_stmt (EXPR_STMT, expr));
1739 /* Validate the expression after `case' and apply default promotions. */
1742 check_case_value (tree value)
1744 if (value == NULL_TREE)
1747 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1748 STRIP_TYPE_NOPS (value);
1749 /* In C++, the following is allowed:
1752 switch (...) { case i: ... }
1754 So, we try to reduce the VALUE to a constant that way. */
1755 if (c_dialect_cxx ())
1757 value = decl_constant_value (value);
1758 STRIP_TYPE_NOPS (value);
1759 value = fold (value);
1762 if (TREE_CODE (value) != INTEGER_CST
1763 && value != error_mark_node)
1765 error ("case label does not reduce to an integer constant");
1766 value = error_mark_node;
1769 /* Promote char or short to int. */
1770 value = default_conversion (value);
1772 constant_expression_warning (value);
1777 /* Return an integer type with BITS bits of precision,
1778 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1781 c_common_type_for_size (unsigned int bits, int unsignedp)
1783 if (bits == TYPE_PRECISION (integer_type_node))
1784 return unsignedp ? unsigned_type_node : integer_type_node;
1786 if (bits == TYPE_PRECISION (signed_char_type_node))
1787 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1789 if (bits == TYPE_PRECISION (short_integer_type_node))
1790 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1792 if (bits == TYPE_PRECISION (long_integer_type_node))
1793 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1795 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1796 return (unsignedp ? long_long_unsigned_type_node
1797 : long_long_integer_type_node);
1799 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1800 return (unsignedp ? widest_unsigned_literal_type_node
1801 : widest_integer_literal_type_node);
1803 if (bits <= TYPE_PRECISION (intQI_type_node))
1804 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1806 if (bits <= TYPE_PRECISION (intHI_type_node))
1807 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1809 if (bits <= TYPE_PRECISION (intSI_type_node))
1810 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1812 if (bits <= TYPE_PRECISION (intDI_type_node))
1813 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1818 /* Used for communication between c_common_type_for_mode and
1819 c_register_builtin_type. */
1820 static GTY(()) tree registered_builtin_types;
1822 /* Return a data type that has machine mode MODE.
1823 If the mode is an integer,
1824 then UNSIGNEDP selects between signed and unsigned types. */
1827 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1831 if (mode == TYPE_MODE (integer_type_node))
1832 return unsignedp ? unsigned_type_node : integer_type_node;
1834 if (mode == TYPE_MODE (signed_char_type_node))
1835 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1837 if (mode == TYPE_MODE (short_integer_type_node))
1838 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1840 if (mode == TYPE_MODE (long_integer_type_node))
1841 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1843 if (mode == TYPE_MODE (long_long_integer_type_node))
1844 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1846 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1847 return unsignedp ? widest_unsigned_literal_type_node
1848 : widest_integer_literal_type_node;
1851 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1854 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1857 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1860 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1862 #if HOST_BITS_PER_WIDE_INT >= 64
1863 if (mode == TYPE_MODE (intTI_type_node))
1864 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1867 if (mode == TYPE_MODE (float_type_node))
1868 return float_type_node;
1870 if (mode == TYPE_MODE (double_type_node))
1871 return double_type_node;
1873 if (mode == TYPE_MODE (long_double_type_node))
1874 return long_double_type_node;
1876 if (mode == TYPE_MODE (void_type_node))
1877 return void_type_node;
1879 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1880 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1882 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1883 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1888 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1890 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1892 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1894 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
1896 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1898 return unsignedp ? unsigned_V2HI_type_node : V2HI_type_node;
1900 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1902 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1904 return unsignedp ? unsigned_V1DI_type_node : V1DI_type_node;
1906 return V16SF_type_node;
1908 return V4SF_type_node;
1910 return V2SF_type_node;
1912 return V2DF_type_node;
1914 return V4DF_type_node;
1919 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1920 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1921 return TREE_VALUE (t);
1926 /* Return an unsigned type the same as TYPE in other respects. */
1928 c_common_unsigned_type (tree type)
1930 tree type1 = TYPE_MAIN_VARIANT (type);
1931 if (type1 == signed_char_type_node || type1 == char_type_node)
1932 return unsigned_char_type_node;
1933 if (type1 == integer_type_node)
1934 return unsigned_type_node;
1935 if (type1 == short_integer_type_node)
1936 return short_unsigned_type_node;
1937 if (type1 == long_integer_type_node)
1938 return long_unsigned_type_node;
1939 if (type1 == long_long_integer_type_node)
1940 return long_long_unsigned_type_node;
1941 if (type1 == widest_integer_literal_type_node)
1942 return widest_unsigned_literal_type_node;
1943 #if HOST_BITS_PER_WIDE_INT >= 64
1944 if (type1 == intTI_type_node)
1945 return unsigned_intTI_type_node;
1947 if (type1 == intDI_type_node)
1948 return unsigned_intDI_type_node;
1949 if (type1 == intSI_type_node)
1950 return unsigned_intSI_type_node;
1951 if (type1 == intHI_type_node)
1952 return unsigned_intHI_type_node;
1953 if (type1 == intQI_type_node)
1954 return unsigned_intQI_type_node;
1956 return c_common_signed_or_unsigned_type (1, type);
1959 /* Return a signed type the same as TYPE in other respects. */
1962 c_common_signed_type (tree type)
1964 tree type1 = TYPE_MAIN_VARIANT (type);
1965 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1966 return signed_char_type_node;
1967 if (type1 == unsigned_type_node)
1968 return integer_type_node;
1969 if (type1 == short_unsigned_type_node)
1970 return short_integer_type_node;
1971 if (type1 == long_unsigned_type_node)
1972 return long_integer_type_node;
1973 if (type1 == long_long_unsigned_type_node)
1974 return long_long_integer_type_node;
1975 if (type1 == widest_unsigned_literal_type_node)
1976 return widest_integer_literal_type_node;
1977 #if HOST_BITS_PER_WIDE_INT >= 64
1978 if (type1 == unsigned_intTI_type_node)
1979 return intTI_type_node;
1981 if (type1 == unsigned_intDI_type_node)
1982 return intDI_type_node;
1983 if (type1 == unsigned_intSI_type_node)
1984 return intSI_type_node;
1985 if (type1 == unsigned_intHI_type_node)
1986 return intHI_type_node;
1987 if (type1 == unsigned_intQI_type_node)
1988 return intQI_type_node;
1990 return c_common_signed_or_unsigned_type (0, type);
1993 /* Return a type the same as TYPE except unsigned or
1994 signed according to UNSIGNEDP. */
1997 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1999 if (! INTEGRAL_TYPE_P (type)
2000 || TREE_UNSIGNED (type) == unsignedp)
2003 /* Must check the mode of the types, not the precision. Enumeral types
2004 in C++ have precision set to match their range, but may use a wider
2005 mode to match an ABI. If we change modes, we may wind up with bad
2008 if (TYPE_MODE (type) == TYPE_MODE (signed_char_type_node))
2009 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2010 if (TYPE_MODE (type) == TYPE_MODE (integer_type_node))
2011 return unsignedp ? unsigned_type_node : integer_type_node;
2012 if (TYPE_MODE (type) == TYPE_MODE (short_integer_type_node))
2013 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2014 if (TYPE_MODE (type) == TYPE_MODE (long_integer_type_node))
2015 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2016 if (TYPE_MODE (type) == TYPE_MODE (long_long_integer_type_node))
2017 return (unsignedp ? long_long_unsigned_type_node
2018 : long_long_integer_type_node);
2019 if (TYPE_MODE (type) == TYPE_MODE (widest_integer_literal_type_node))
2020 return (unsignedp ? widest_unsigned_literal_type_node
2021 : widest_integer_literal_type_node);
2023 #if HOST_BITS_PER_WIDE_INT >= 64
2024 if (TYPE_MODE (type) == TYPE_MODE (intTI_type_node))
2025 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2027 if (TYPE_MODE (type) == TYPE_MODE (intDI_type_node))
2028 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2029 if (TYPE_MODE (type) == TYPE_MODE (intSI_type_node))
2030 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2031 if (TYPE_MODE (type) == TYPE_MODE (intHI_type_node))
2032 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2033 if (TYPE_MODE (type) == TYPE_MODE (intQI_type_node))
2034 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2039 /* The C version of the register_builtin_type langhook. */
2042 c_register_builtin_type (tree type, const char* name)
2046 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2047 DECL_ARTIFICIAL (decl) = 1;
2048 if (!TYPE_NAME (type))
2049 TYPE_NAME (type) = decl;
2052 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2056 /* Return the minimum number of bits needed to represent VALUE in a
2057 signed or unsigned type, UNSIGNEDP says which. */
2060 min_precision (tree value, int unsignedp)
2064 /* If the value is negative, compute its negative minus 1. The latter
2065 adjustment is because the absolute value of the largest negative value
2066 is one larger than the largest positive value. This is equivalent to
2067 a bit-wise negation, so use that operation instead. */
2069 if (tree_int_cst_sgn (value) < 0)
2070 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2072 /* Return the number of bits needed, taking into account the fact
2073 that we need one more bit for a signed than unsigned type. */
2075 if (integer_zerop (value))
2078 log = tree_floor_log2 (value);
2080 return log + 1 + ! unsignedp;
2083 /* Print an error message for invalid operands to arith operation
2084 CODE. NOP_EXPR is used as a special case (see
2085 c_common_truthvalue_conversion). */
2088 binary_op_error (enum tree_code code)
2095 error ("invalid truth-value expression");
2099 opname = "+"; break;
2101 opname = "-"; break;
2103 opname = "*"; break;
2105 opname = "max"; break;
2107 opname = "min"; break;
2109 opname = "=="; break;
2111 opname = "!="; break;
2113 opname = "<="; break;
2115 opname = ">="; break;
2117 opname = "<"; break;
2119 opname = ">"; break;
2121 opname = "<<"; break;
2123 opname = ">>"; break;
2124 case TRUNC_MOD_EXPR:
2125 case FLOOR_MOD_EXPR:
2126 opname = "%"; break;
2127 case TRUNC_DIV_EXPR:
2128 case FLOOR_DIV_EXPR:
2129 opname = "/"; break;
2131 opname = "&"; break;
2133 opname = "|"; break;
2134 case TRUTH_ANDIF_EXPR:
2135 opname = "&&"; break;
2136 case TRUTH_ORIF_EXPR:
2137 opname = "||"; break;
2139 opname = "^"; break;
2142 opname = "rotate"; break;
2144 opname = "unknown"; break;
2146 error ("invalid operands to binary %s", opname);
2149 /* Subroutine of build_binary_op, used for comparison operations.
2150 See if the operands have both been converted from subword integer types
2151 and, if so, perhaps change them both back to their original type.
2152 This function is also responsible for converting the two operands
2153 to the proper common type for comparison.
2155 The arguments of this function are all pointers to local variables
2156 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2157 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2159 If this function returns nonzero, it means that the comparison has
2160 a constant value. What this function returns is an expression for
2164 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2165 enum tree_code *rescode_ptr)
2168 tree op0 = *op0_ptr;
2169 tree op1 = *op1_ptr;
2170 int unsignedp0, unsignedp1;
2172 tree primop0, primop1;
2173 enum tree_code code = *rescode_ptr;
2175 /* Throw away any conversions to wider types
2176 already present in the operands. */
2178 primop0 = get_narrower (op0, &unsignedp0);
2179 primop1 = get_narrower (op1, &unsignedp1);
2181 /* Handle the case that OP0 does not *contain* a conversion
2182 but it *requires* conversion to FINAL_TYPE. */
2184 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2185 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2186 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2187 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2189 /* If one of the operands must be floated, we cannot optimize. */
2190 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2191 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2193 /* If first arg is constant, swap the args (changing operation
2194 so value is preserved), for canonicalization. Don't do this if
2195 the second arg is 0. */
2197 if (TREE_CONSTANT (primop0)
2198 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2201 int temi = unsignedp0;
2209 unsignedp0 = unsignedp1;
2232 *rescode_ptr = code;
2235 /* If comparing an integer against a constant more bits wide,
2236 maybe we can deduce a value of 1 or 0 independent of the data.
2237 Or else truncate the constant now
2238 rather than extend the variable at run time.
2240 This is only interesting if the constant is the wider arg.
2241 Also, it is not safe if the constant is unsigned and the
2242 variable arg is signed, since in this case the variable
2243 would be sign-extended and then regarded as unsigned.
2244 Our technique fails in this case because the lowest/highest
2245 possible unsigned results don't follow naturally from the
2246 lowest/highest possible values of the variable operand.
2247 For just EQ_EXPR and NE_EXPR there is another technique that
2248 could be used: see if the constant can be faithfully represented
2249 in the other operand's type, by truncating it and reextending it
2250 and see if that preserves the constant's value. */
2252 if (!real1 && !real2
2253 && TREE_CODE (primop1) == INTEGER_CST
2254 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2256 int min_gt, max_gt, min_lt, max_lt;
2257 tree maxval, minval;
2258 /* 1 if comparison is nominally unsigned. */
2259 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2262 type = c_common_signed_or_unsigned_type (unsignedp0,
2263 TREE_TYPE (primop0));
2265 /* In C, if TYPE is an enumeration, then we need to get its
2266 min/max values from it's underlying integral type, not the
2267 enumerated type itself. In C++, TYPE_MAX_VALUE and
2268 TYPE_MIN_VALUE have already been set correctly on the
2269 enumeration type. */
2270 if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
2271 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2273 maxval = TYPE_MAX_VALUE (type);
2274 minval = TYPE_MIN_VALUE (type);
2276 if (unsignedp && !unsignedp0)
2277 *restype_ptr = c_common_signed_type (*restype_ptr);
2279 if (TREE_TYPE (primop1) != *restype_ptr)
2280 primop1 = convert (*restype_ptr, primop1);
2281 if (type != *restype_ptr)
2283 minval = convert (*restype_ptr, minval);
2284 maxval = convert (*restype_ptr, maxval);
2287 if (unsignedp && unsignedp0)
2289 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2290 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2291 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2292 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2296 min_gt = INT_CST_LT (primop1, minval);
2297 max_gt = INT_CST_LT (primop1, maxval);
2298 min_lt = INT_CST_LT (minval, primop1);
2299 max_lt = INT_CST_LT (maxval, primop1);
2303 /* This used to be a switch, but Genix compiler can't handle that. */
2304 if (code == NE_EXPR)
2306 if (max_lt || min_gt)
2307 val = truthvalue_true_node;
2309 else if (code == EQ_EXPR)
2311 if (max_lt || min_gt)
2312 val = truthvalue_false_node;
2314 else if (code == LT_EXPR)
2317 val = truthvalue_true_node;
2319 val = truthvalue_false_node;
2321 else if (code == GT_EXPR)
2324 val = truthvalue_true_node;
2326 val = truthvalue_false_node;
2328 else if (code == LE_EXPR)
2331 val = truthvalue_true_node;
2333 val = truthvalue_false_node;
2335 else if (code == GE_EXPR)
2338 val = truthvalue_true_node;
2340 val = truthvalue_false_node;
2343 /* If primop0 was sign-extended and unsigned comparison specd,
2344 we did a signed comparison above using the signed type bounds.
2345 But the comparison we output must be unsigned.
2347 Also, for inequalities, VAL is no good; but if the signed
2348 comparison had *any* fixed result, it follows that the
2349 unsigned comparison just tests the sign in reverse
2350 (positive values are LE, negative ones GE).
2351 So we can generate an unsigned comparison
2352 against an extreme value of the signed type. */
2354 if (unsignedp && !unsignedp0)
2361 primop1 = TYPE_MIN_VALUE (type);
2367 primop1 = TYPE_MAX_VALUE (type);
2374 type = c_common_unsigned_type (type);
2377 if (TREE_CODE (primop0) != INTEGER_CST)
2379 if (val == truthvalue_false_node)
2380 warning ("comparison is always false due to limited range of data type");
2381 if (val == truthvalue_true_node)
2382 warning ("comparison is always true due to limited range of data type");
2387 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2388 if (TREE_SIDE_EFFECTS (primop0))
2389 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2393 /* Value is not predetermined, but do the comparison
2394 in the type of the operand that is not constant.
2395 TYPE is already properly set. */
2397 else if (real1 && real2
2398 && (TYPE_PRECISION (TREE_TYPE (primop0))
2399 == TYPE_PRECISION (TREE_TYPE (primop1))))
2400 type = TREE_TYPE (primop0);
2402 /* If args' natural types are both narrower than nominal type
2403 and both extend in the same manner, compare them
2404 in the type of the wider arg.
2405 Otherwise must actually extend both to the nominal
2406 common type lest different ways of extending
2408 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2410 else if (unsignedp0 == unsignedp1 && real1 == real2
2411 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2412 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2414 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2415 type = c_common_signed_or_unsigned_type (unsignedp0
2416 || TREE_UNSIGNED (*restype_ptr),
2418 /* Make sure shorter operand is extended the right way
2419 to match the longer operand. */
2421 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2422 TREE_TYPE (primop0)),
2425 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2426 TREE_TYPE (primop1)),
2431 /* Here we must do the comparison on the nominal type
2432 using the args exactly as we received them. */
2433 type = *restype_ptr;
2437 if (!real1 && !real2 && integer_zerop (primop1)
2438 && TREE_UNSIGNED (*restype_ptr))
2444 /* All unsigned values are >= 0, so we warn if extra warnings
2445 are requested. However, if OP0 is a constant that is
2446 >= 0, the signedness of the comparison isn't an issue,
2447 so suppress the warning. */
2448 if (extra_warnings && !in_system_header
2449 && ! (TREE_CODE (primop0) == INTEGER_CST
2450 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2452 warning ("comparison of unsigned expression >= 0 is always true");
2453 value = truthvalue_true_node;
2457 if (extra_warnings && !in_system_header
2458 && ! (TREE_CODE (primop0) == INTEGER_CST
2459 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2461 warning ("comparison of unsigned expression < 0 is always false");
2462 value = truthvalue_false_node;
2471 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2472 if (TREE_SIDE_EFFECTS (primop0))
2473 return build (COMPOUND_EXPR, TREE_TYPE (value),
2480 *op0_ptr = convert (type, primop0);
2481 *op1_ptr = convert (type, primop1);
2483 *restype_ptr = truthvalue_type_node;
2488 /* Return a tree for the sum or difference (RESULTCODE says which)
2489 of pointer PTROP and integer INTOP. */
2492 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2499 /* The result is a pointer of the same type that is being added. */
2501 tree result_type = TREE_TYPE (ptrop);
2503 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2505 if (pedantic || warn_pointer_arith)
2506 pedwarn ("pointer of type `void *' used in arithmetic");
2507 size_exp = integer_one_node;
2509 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2511 if (pedantic || warn_pointer_arith)
2512 pedwarn ("pointer to a function used in arithmetic");
2513 size_exp = integer_one_node;
2515 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2517 if (pedantic || warn_pointer_arith)
2518 pedwarn ("pointer to member function used in arithmetic");
2519 size_exp = integer_one_node;
2522 size_exp = size_in_bytes (TREE_TYPE (result_type));
2524 /* If what we are about to multiply by the size of the elements
2525 contains a constant term, apply distributive law
2526 and multiply that constant term separately.
2527 This helps produce common subexpressions. */
2529 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2530 && ! TREE_CONSTANT (intop)
2531 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2532 && TREE_CONSTANT (size_exp)
2533 /* If the constant comes from pointer subtraction,
2534 skip this optimization--it would cause an error. */
2535 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2536 /* If the constant is unsigned, and smaller than the pointer size,
2537 then we must skip this optimization. This is because it could cause
2538 an overflow error if the constant is negative but INTOP is not. */
2539 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2540 || (TYPE_PRECISION (TREE_TYPE (intop))
2541 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2543 enum tree_code subcode = resultcode;
2544 tree int_type = TREE_TYPE (intop);
2545 if (TREE_CODE (intop) == MINUS_EXPR)
2546 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2547 /* Convert both subexpression types to the type of intop,
2548 because weird cases involving pointer arithmetic
2549 can result in a sum or difference with different type args. */
2550 ptrop = build_binary_op (subcode, ptrop,
2551 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2552 intop = convert (int_type, TREE_OPERAND (intop, 0));
2555 /* Convert the integer argument to a type the same size as sizetype
2556 so the multiply won't overflow spuriously. */
2558 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2559 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2560 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2561 TREE_UNSIGNED (sizetype)), intop);
2563 /* Replace the integer argument with a suitable product by the object size.
2564 Do this multiplication as signed, then convert to the appropriate
2565 pointer type (actually unsigned integral). */
2567 intop = convert (result_type,
2568 build_binary_op (MULT_EXPR, intop,
2569 convert (TREE_TYPE (intop), size_exp), 1));
2571 /* Create the sum or difference. */
2573 result = build (resultcode, result_type, ptrop, intop);
2575 folded = fold (result);
2576 if (folded == result)
2577 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2581 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2582 or validate its data type for an `if' or `while' statement or ?..: exp.
2584 This preparation consists of taking the ordinary
2585 representation of an expression expr and producing a valid tree
2586 boolean expression describing whether expr is nonzero. We could
2587 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2588 but we optimize comparisons, &&, ||, and !.
2590 The resulting type should always be `truthvalue_type_node'. */
2593 c_common_truthvalue_conversion (tree expr)
2595 if (TREE_CODE (expr) == ERROR_MARK)
2598 if (TREE_CODE (expr) == FUNCTION_DECL)
2599 expr = build_unary_op (ADDR_EXPR, expr, 0);
2601 #if 0 /* This appears to be wrong for C++. */
2602 /* These really should return error_mark_node after 2.4 is stable.
2603 But not all callers handle ERROR_MARK properly. */
2604 switch (TREE_CODE (TREE_TYPE (expr)))
2607 error ("struct type value used where scalar is required");
2608 return truthvalue_false_node;
2611 error ("union type value used where scalar is required");
2612 return truthvalue_false_node;
2615 error ("array type value used where scalar is required");
2616 return truthvalue_false_node;
2623 switch (TREE_CODE (expr))
2626 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2627 case TRUTH_ANDIF_EXPR:
2628 case TRUTH_ORIF_EXPR:
2629 case TRUTH_AND_EXPR:
2631 case TRUTH_XOR_EXPR:
2632 case TRUTH_NOT_EXPR:
2633 TREE_TYPE (expr) = truthvalue_type_node;
2640 return integer_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2643 return real_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2647 if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2648 && ! DECL_WEAK (TREE_OPERAND (expr, 0)))
2650 /* Common Ada/Pascal programmer's mistake. We always warn
2651 about this since it is so bad. */
2652 warning ("the address of `%D', will always evaluate as `true'",
2653 TREE_OPERAND (expr, 0));
2654 return truthvalue_true_node;
2657 /* If we are taking the address of an external decl, it might be
2658 zero if it is weak, so we cannot optimize. */
2659 if (DECL_P (TREE_OPERAND (expr, 0))
2660 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2663 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2664 return build (COMPOUND_EXPR, truthvalue_type_node,
2665 TREE_OPERAND (expr, 0), truthvalue_true_node);
2667 return truthvalue_true_node;
2671 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2672 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2673 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2674 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2680 /* These don't change whether an object is nonzero or zero. */
2681 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2685 /* These don't change whether an object is zero or nonzero, but
2686 we can't ignore them if their second arg has side-effects. */
2687 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2688 return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1),
2689 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2691 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2694 /* Distribute the conversion into the arms of a COND_EXPR. */
2695 return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0),
2696 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2697 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2700 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2701 since that affects how `default_conversion' will behave. */
2702 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2703 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2705 /* Fall through.... */
2707 /* If this is widening the argument, we can ignore it. */
2708 if (TYPE_PRECISION (TREE_TYPE (expr))
2709 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2710 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2714 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2715 aren't guaranteed to the be same for modes that can represent
2716 infinity, since if x and y are both +infinity, or both
2717 -infinity, then x - y is not a number.
2719 Note that this transformation is safe when x or y is NaN.
2720 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2722 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2724 /* Fall through.... */
2726 /* This and MINUS_EXPR can be changed into a comparison of the
2728 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2729 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2730 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2731 TREE_OPERAND (expr, 1), 1);
2732 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2733 fold (build1 (NOP_EXPR,
2734 TREE_TYPE (TREE_OPERAND (expr, 0)),
2735 TREE_OPERAND (expr, 1))), 1);
2738 if (integer_onep (TREE_OPERAND (expr, 1))
2739 && TREE_TYPE (expr) != truthvalue_type_node)
2740 /* Using convert here would cause infinite recursion. */
2741 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2745 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2746 warning ("suggest parentheses around assignment used as truth value");
2753 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2755 tree t = save_expr (expr);
2756 return (build_binary_op
2757 ((TREE_SIDE_EFFECTS (expr)
2758 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2759 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2760 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2764 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2767 static tree builtin_function_2 (const char *, const char *, tree, tree,
2768 int, enum built_in_class, int, int,
2771 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2772 down to the element type of an array. */
2775 c_build_qualified_type (tree type, int type_quals)
2777 if (type == error_mark_node)
2780 if (TREE_CODE (type) == ARRAY_TYPE)
2781 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2783 TYPE_DOMAIN (type));
2785 /* A restrict-qualified pointer type must be a pointer to object or
2786 incomplete type. Note that the use of POINTER_TYPE_P also allows
2787 REFERENCE_TYPEs, which is appropriate for C++. */
2788 if ((type_quals & TYPE_QUAL_RESTRICT)
2789 && (!POINTER_TYPE_P (type)
2790 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2792 error ("invalid use of `restrict'");
2793 type_quals &= ~TYPE_QUAL_RESTRICT;
2796 return build_qualified_type (type, type_quals);
2799 /* Apply the TYPE_QUALS to the new DECL. */
2802 c_apply_type_quals_to_decl (int type_quals, tree decl)
2804 tree type = TREE_TYPE (decl);
2806 if (type == error_mark_node)
2809 if (((type_quals & TYPE_QUAL_CONST)
2810 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2811 /* An object declared 'const' is only readonly after it is
2812 initialized. We don't have any way of expressing this currently,
2813 so we need to be conservative and unset TREE_READONLY for types
2814 with constructors. Otherwise aliasing code will ignore stores in
2815 an inline constructor. */
2816 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2817 TREE_READONLY (decl) = 1;
2818 if (type_quals & TYPE_QUAL_VOLATILE)
2820 TREE_SIDE_EFFECTS (decl) = 1;
2821 TREE_THIS_VOLATILE (decl) = 1;
2823 if (type_quals & TYPE_QUAL_RESTRICT)
2825 while (type && TREE_CODE (type) == ARRAY_TYPE)
2826 /* Allow 'restrict' on arrays of pointers.
2827 FIXME currently we just ignore it. */
2828 type = TREE_TYPE (type);
2830 || !POINTER_TYPE_P (type)
2831 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2832 error ("invalid use of `restrict'");
2833 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2834 /* Indicate we need to make a unique alias set for this pointer.
2835 We can't do it here because it might be pointing to an
2837 DECL_POINTER_ALIAS_SET (decl) = -2;
2841 /* Return the typed-based alias set for T, which may be an expression
2842 or a type. Return -1 if we don't do anything special. */
2845 c_common_get_alias_set (tree t)
2849 /* Permit type-punning when accessing a union, provided the access
2850 is directly through the union. For example, this code does not
2851 permit taking the address of a union member and then storing
2852 through it. Even the type-punning allowed here is a GCC
2853 extension, albeit a common and useful one; the C standard says
2854 that such accesses have implementation-defined behavior. */
2856 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2857 u = TREE_OPERAND (u, 0))
2858 if (TREE_CODE (u) == COMPONENT_REF
2859 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2862 /* That's all the expressions we handle specially. */
2866 /* The C standard guarantees that any object may be accessed via an
2867 lvalue that has character type. */
2868 if (t == char_type_node
2869 || t == signed_char_type_node
2870 || t == unsigned_char_type_node)
2873 /* If it has the may_alias attribute, it can alias anything. */
2874 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2877 /* The C standard specifically allows aliasing between signed and
2878 unsigned variants of the same type. We treat the signed
2879 variant as canonical. */
2880 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2882 tree t1 = c_common_signed_type (t);
2884 /* t1 == t can happen for boolean nodes which are always unsigned. */
2886 return get_alias_set (t1);
2888 else if (POINTER_TYPE_P (t))
2892 /* Unfortunately, there is no canonical form of a pointer type.
2893 In particular, if we have `typedef int I', then `int *', and
2894 `I *' are different types. So, we have to pick a canonical
2895 representative. We do this below.
2897 Technically, this approach is actually more conservative that
2898 it needs to be. In particular, `const int *' and `int *'
2899 should be in different alias sets, according to the C and C++
2900 standard, since their types are not the same, and so,
2901 technically, an `int **' and `const int **' cannot point at
2904 But, the standard is wrong. In particular, this code is
2909 const int* const* cipp = &ipp;
2911 And, it doesn't make sense for that to be legal unless you
2912 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2913 the pointed-to types. This issue has been reported to the
2915 t1 = build_type_no_quals (t);
2917 return get_alias_set (t1);
2923 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2924 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2925 flag controls whether we should diagnose possibly ill-formed
2926 constructs or not. */
2928 c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2930 const char *op_name;
2932 enum tree_code type_code = TREE_CODE (type);
2934 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
2935 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2937 if (type_code == FUNCTION_TYPE)
2939 if (op == SIZEOF_EXPR)
2941 if (complain && (pedantic || warn_pointer_arith))
2942 pedwarn ("invalid application of `sizeof' to a function type");
2943 value = size_one_node;
2946 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2948 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2950 if (type_code == VOID_TYPE
2951 && complain && (pedantic || warn_pointer_arith))
2952 pedwarn ("invalid application of `%s' to a void type", op_name);
2953 value = size_one_node;
2955 else if (!COMPLETE_TYPE_P (type))
2958 error ("invalid application of `%s' to incomplete type `%T' ",
2960 value = size_zero_node;
2964 if (op == SIZEOF_EXPR)
2965 /* Convert in case a char is more than one unit. */
2966 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2967 size_int (TYPE_PRECISION (char_type_node)
2970 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2973 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2974 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2975 never happen. However, this node should really have type
2976 `size_t', which is just a typedef for an ordinary integer type. */
2977 value = fold (build1 (NOP_EXPR, size_type_node, value));
2978 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
2983 /* Implement the __alignof keyword: Return the minimum required
2984 alignment of EXPR, measured in bytes. For VAR_DECL's and
2985 FIELD_DECL's return DECL_ALIGN (which can be set from an
2986 "aligned" __attribute__ specification). */
2989 c_alignof_expr (tree expr)
2993 if (TREE_CODE (expr) == VAR_DECL)
2994 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2996 else if (TREE_CODE (expr) == COMPONENT_REF
2997 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2999 error ("`__alignof' applied to a bit-field");
3002 else if (TREE_CODE (expr) == COMPONENT_REF
3003 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3004 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
3006 else if (TREE_CODE (expr) == INDIRECT_REF)
3008 tree t = TREE_OPERAND (expr, 0);
3010 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3012 while (TREE_CODE (t) == NOP_EXPR
3013 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3017 t = TREE_OPERAND (t, 0);
3018 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3019 if (thisalign > bestalign)
3020 best = t, bestalign = thisalign;
3022 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3025 return c_alignof (TREE_TYPE (expr));
3027 return fold (build1 (NOP_EXPR, size_type_node, t));
3030 /* Handle C and C++ default attributes. */
3032 enum built_in_attribute
3034 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3035 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3036 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3037 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3038 #include "builtin-attrs.def"
3039 #undef DEF_ATTR_NULL_TREE
3041 #undef DEF_ATTR_IDENT
3042 #undef DEF_ATTR_TREE_LIST
3046 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3048 static void c_init_attributes (void);
3050 /* Build tree nodes and builtin functions common to both C and C++ language
3054 c_common_nodes_and_builtins (void)
3058 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3059 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3060 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3061 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3062 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3063 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3064 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3065 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3066 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3067 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3068 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3069 #include "builtin-types.def"
3070 #undef DEF_PRIMITIVE_TYPE
3071 #undef DEF_FUNCTION_TYPE_0
3072 #undef DEF_FUNCTION_TYPE_1
3073 #undef DEF_FUNCTION_TYPE_2
3074 #undef DEF_FUNCTION_TYPE_3
3075 #undef DEF_FUNCTION_TYPE_4
3076 #undef DEF_FUNCTION_TYPE_VAR_0
3077 #undef DEF_FUNCTION_TYPE_VAR_1
3078 #undef DEF_FUNCTION_TYPE_VAR_2
3079 #undef DEF_FUNCTION_TYPE_VAR_3
3080 #undef DEF_POINTER_TYPE
3084 typedef enum builtin_type builtin_type;
3086 tree builtin_types[(int) BT_LAST];
3087 int wchar_type_size;
3088 tree array_domain_type;
3089 tree va_list_ref_type_node;
3090 tree va_list_arg_type_node;
3092 /* Define `int' and `char' first so that dbx will output them first. */
3093 record_builtin_type (RID_INT, NULL, integer_type_node);
3094 record_builtin_type (RID_CHAR, "char", char_type_node);
3096 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3097 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3098 but not C. Are the conditionals here needed? */
3099 if (c_dialect_cxx ())
3100 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3101 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3102 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3103 record_builtin_type (RID_MAX, "long unsigned int",
3104 long_unsigned_type_node);
3105 if (c_dialect_cxx ())
3106 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3107 record_builtin_type (RID_MAX, "long long int",
3108 long_long_integer_type_node);
3109 record_builtin_type (RID_MAX, "long long unsigned int",
3110 long_long_unsigned_type_node);
3111 if (c_dialect_cxx ())
3112 record_builtin_type (RID_MAX, "long long unsigned",
3113 long_long_unsigned_type_node);
3114 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3115 record_builtin_type (RID_MAX, "short unsigned int",
3116 short_unsigned_type_node);
3117 if (c_dialect_cxx ())
3118 record_builtin_type (RID_MAX, "unsigned short",
3119 short_unsigned_type_node);
3121 /* Define both `signed char' and `unsigned char'. */
3122 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3123 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3125 /* These are types that c_common_type_for_size and
3126 c_common_type_for_mode use. */
3127 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3129 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3131 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3133 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3135 #if HOST_BITS_PER_WIDE_INT >= 64
3136 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3137 get_identifier ("__int128_t"),
3140 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3141 unsigned_intQI_type_node));
3142 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3143 unsigned_intHI_type_node));
3144 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3145 unsigned_intSI_type_node));
3146 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3147 unsigned_intDI_type_node));
3148 #if HOST_BITS_PER_WIDE_INT >= 64
3149 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3150 get_identifier ("__uint128_t"),
3151 unsigned_intTI_type_node));
3154 /* Create the widest literal types. */
3155 widest_integer_literal_type_node
3156 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3157 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3158 widest_integer_literal_type_node));
3160 widest_unsigned_literal_type_node
3161 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3162 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3163 widest_unsigned_literal_type_node));
3165 /* `unsigned long' is the standard type for sizeof.
3166 Note that stddef.h uses `unsigned long',
3167 and this must agree, even if long and int are the same size. */
3169 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3170 signed_size_type_node = c_common_signed_type (size_type_node);
3171 set_sizetype (size_type_node);
3173 build_common_tree_nodes_2 (flag_short_double);
3175 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3176 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3177 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3179 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3180 get_identifier ("complex int"),
3181 complex_integer_type_node));
3182 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3183 get_identifier ("complex float"),
3184 complex_float_type_node));
3185 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3186 get_identifier ("complex double"),
3187 complex_double_type_node));
3188 (*lang_hooks.decls.pushdecl)
3189 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3190 complex_long_double_type_node));
3192 /* Types which are common to the fortran compiler and libf2c. When
3193 changing these, you also need to be concerned with f/com.h. */
3195 if (TYPE_PRECISION (float_type_node)
3196 == TYPE_PRECISION (long_integer_type_node))
3198 g77_integer_type_node = long_integer_type_node;
3199 g77_uinteger_type_node = long_unsigned_type_node;
3201 else if (TYPE_PRECISION (float_type_node)
3202 == TYPE_PRECISION (integer_type_node))
3204 g77_integer_type_node = integer_type_node;
3205 g77_uinteger_type_node = unsigned_type_node;
3208 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3210 if (g77_integer_type_node != NULL_TREE)
3212 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3213 get_identifier ("__g77_integer"),
3214 g77_integer_type_node));
3215 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3216 get_identifier ("__g77_uinteger"),
3217 g77_uinteger_type_node));
3220 if (TYPE_PRECISION (float_type_node) * 2
3221 == TYPE_PRECISION (long_integer_type_node))
3223 g77_longint_type_node = long_integer_type_node;
3224 g77_ulongint_type_node = long_unsigned_type_node;
3226 else if (TYPE_PRECISION (float_type_node) * 2
3227 == TYPE_PRECISION (long_long_integer_type_node))
3229 g77_longint_type_node = long_long_integer_type_node;
3230 g77_ulongint_type_node = long_long_unsigned_type_node;
3233 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3235 if (g77_longint_type_node != NULL_TREE)
3237 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3238 get_identifier ("__g77_longint"),
3239 g77_longint_type_node));
3240 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3241 get_identifier ("__g77_ulongint"),
3242 g77_ulongint_type_node));
3245 record_builtin_type (RID_VOID, NULL, void_type_node);
3247 void_zero_node = build_int_2 (0, 0);
3248 TREE_TYPE (void_zero_node) = void_type_node;
3250 void_list_node = build_void_list_node ();
3252 /* Make a type to be the domain of a few array types
3253 whose domains don't really matter.
3254 200 is small enough that it always fits in size_t
3255 and large enough that it can hold most function names for the
3256 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3257 array_domain_type = build_index_type (size_int (200));
3259 /* Make a type for arrays of characters.
3260 With luck nothing will ever really depend on the length of this
3262 char_array_type_node
3263 = build_array_type (char_type_node, array_domain_type);
3265 /* Likewise for arrays of ints. */
3267 = build_array_type (integer_type_node, array_domain_type);
3269 string_type_node = build_pointer_type (char_type_node);
3270 const_string_type_node
3271 = build_pointer_type (build_qualified_type
3272 (char_type_node, TYPE_QUAL_CONST));
3274 /* This is special for C++ so functions can be overloaded. */
3275 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3276 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3277 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3278 if (c_dialect_cxx ())
3280 if (TREE_UNSIGNED (wchar_type_node))
3281 wchar_type_node = make_unsigned_type (wchar_type_size);
3283 wchar_type_node = make_signed_type (wchar_type_size);
3284 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3288 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3289 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3292 /* This is for wide string constants. */
3293 wchar_array_type_node
3294 = build_array_type (wchar_type_node, array_domain_type);
3297 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3300 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3302 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3304 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3306 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3307 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3309 (*lang_hooks.decls.pushdecl)
3310 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3311 va_list_type_node));
3313 (*lang_hooks.decls.pushdecl)
3314 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3315 ptrdiff_type_node));
3317 (*lang_hooks.decls.pushdecl)
3318 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3321 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3323 va_list_arg_type_node = va_list_ref_type_node =
3324 build_pointer_type (TREE_TYPE (va_list_type_node));
3328 va_list_arg_type_node = va_list_type_node;
3329 va_list_ref_type_node = build_reference_type (va_list_type_node);
3332 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3333 builtin_types[(int) ENUM] = VALUE;
3334 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3335 builtin_types[(int) ENUM] \
3336 = build_function_type (builtin_types[(int) RETURN], \
3338 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3339 builtin_types[(int) ENUM] \
3340 = build_function_type (builtin_types[(int) RETURN], \
3341 tree_cons (NULL_TREE, \
3342 builtin_types[(int) ARG1], \
3344 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3345 builtin_types[(int) ENUM] \
3346 = build_function_type \
3347 (builtin_types[(int) RETURN], \
3348 tree_cons (NULL_TREE, \
3349 builtin_types[(int) ARG1], \
3350 tree_cons (NULL_TREE, \
3351 builtin_types[(int) ARG2], \
3353 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3354 builtin_types[(int) ENUM] \
3355 = build_function_type \
3356 (builtin_types[(int) RETURN], \
3357 tree_cons (NULL_TREE, \
3358 builtin_types[(int) ARG1], \
3359 tree_cons (NULL_TREE, \
3360 builtin_types[(int) ARG2], \
3361 tree_cons (NULL_TREE, \
3362 builtin_types[(int) ARG3], \
3364 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3365 builtin_types[(int) ENUM] \
3366 = build_function_type \
3367 (builtin_types[(int) RETURN], \
3368 tree_cons (NULL_TREE, \
3369 builtin_types[(int) ARG1], \
3370 tree_cons (NULL_TREE, \
3371 builtin_types[(int) ARG2], \
3374 builtin_types[(int) ARG3], \
3375 tree_cons (NULL_TREE, \
3376 builtin_types[(int) ARG4], \
3377 void_list_node)))));
3378 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3379 builtin_types[(int) ENUM] \
3380 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3381 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3382 builtin_types[(int) ENUM] \
3383 = build_function_type (builtin_types[(int) RETURN], \
3384 tree_cons (NULL_TREE, \
3385 builtin_types[(int) ARG1], \
3388 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3389 builtin_types[(int) ENUM] \
3390 = build_function_type \
3391 (builtin_types[(int) RETURN], \
3392 tree_cons (NULL_TREE, \
3393 builtin_types[(int) ARG1], \
3394 tree_cons (NULL_TREE, \
3395 builtin_types[(int) ARG2], \
3398 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3399 builtin_types[(int) ENUM] \
3400 = build_function_type \
3401 (builtin_types[(int) RETURN], \
3402 tree_cons (NULL_TREE, \
3403 builtin_types[(int) ARG1], \
3404 tree_cons (NULL_TREE, \
3405 builtin_types[(int) ARG2], \
3406 tree_cons (NULL_TREE, \
3407 builtin_types[(int) ARG3], \
3410 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3411 builtin_types[(int) ENUM] \
3412 = build_pointer_type (builtin_types[(int) TYPE]);
3413 #include "builtin-types.def"
3414 #undef DEF_PRIMITIVE_TYPE
3415 #undef DEF_FUNCTION_TYPE_1
3416 #undef DEF_FUNCTION_TYPE_2
3417 #undef DEF_FUNCTION_TYPE_3
3418 #undef DEF_FUNCTION_TYPE_4
3419 #undef DEF_FUNCTION_TYPE_VAR_0
3420 #undef DEF_FUNCTION_TYPE_VAR_1
3421 #undef DEF_FUNCTION_TYPE_VAR_2
3422 #undef DEF_FUNCTION_TYPE_VAR_3
3423 #undef DEF_POINTER_TYPE
3425 c_init_attributes ();
3427 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3428 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3433 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3437 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3440 ? (NAME + strlen ("__builtin_")) \
3442 built_in_attributes[(int) ATTRS]); \
3444 decl = builtin_function_2 (NAME, \
3445 NAME + strlen ("__builtin_"), \
3446 builtin_types[TYPE], \
3447 builtin_types[LIBTYPE], \
3452 built_in_attributes[(int) ATTRS]); \
3454 built_in_decls[(int) ENUM] = decl; \
3456 implicit_built_in_decls[(int) ENUM] = decl; \
3458 #include "builtins.def"
3461 (*targetm.init_builtins) ();
3463 main_identifier_node = get_identifier ("main");
3467 build_va_arg (tree expr, tree type)
3469 return build1 (VA_ARG_EXPR, type, expr);
3473 /* Linked list of disabled built-in functions. */
3475 typedef struct disabled_builtin
3478 struct disabled_builtin *next;
3480 static disabled_builtin *disabled_builtins = NULL;
3482 static bool builtin_function_disabled_p (const char *);
3484 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3485 begins with "__builtin_", give an error. */
3488 disable_builtin_function (const char *name)
3490 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3491 error ("cannot disable built-in function `%s'", name);
3494 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3496 new->next = disabled_builtins;
3497 disabled_builtins = new;
3502 /* Return true if the built-in function NAME has been disabled, false
3506 builtin_function_disabled_p (const char *name)
3508 disabled_builtin *p;
3509 for (p = disabled_builtins; p != NULL; p = p->next)
3511 if (strcmp (name, p->name) == 0)
3518 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3519 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3520 of these may be NULL (though both being NULL is useless).
3521 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3522 TYPE is the type of the function with the ordinary name. These
3523 may differ if the ordinary name is declared with a looser type to avoid
3524 conflicts with headers. FUNCTION_CODE and CLASS are as for
3525 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3526 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3527 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3528 ATTRS is the tree list representing the builtin's function attributes.
3529 Returns the declaration of BUILTIN_NAME, if any, otherwise
3530 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3531 or if NONANSI_P and flag_no_nonansi_builtin. */
3534 builtin_function_2 (const char *builtin_name, const char *name,
3535 tree builtin_type, tree type, int function_code,
3536 enum built_in_class class, int library_name_p,
3537 int nonansi_p, tree attrs)
3539 tree bdecl = NULL_TREE;
3540 tree decl = NULL_TREE;
3542 if (builtin_name != 0)
3543 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3544 class, library_name_p ? name : NULL, attrs);
3546 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3547 && !(nonansi_p && flag_no_nonansi_builtin))
3548 decl = builtin_function (name, type, function_code, class, NULL, attrs);
3550 return (bdecl != 0 ? bdecl : decl);
3553 /* Nonzero if the type T promotes to int. This is (nearly) the
3554 integral promotions defined in ISO C99 6.3.1.1/2. */
3557 c_promoting_integer_type_p (tree t)
3559 switch (TREE_CODE (t))
3562 return (TYPE_MAIN_VARIANT (t) == char_type_node
3563 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3564 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3565 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3566 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3567 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3570 /* ??? Technically all enumerations not larger than an int
3571 promote to an int. But this is used along code paths
3572 that only want to notice a size change. */
3573 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3583 /* Return 1 if PARMS specifies a fixed number of parameters
3584 and none of their types is affected by default promotions. */
3587 self_promoting_args_p (tree parms)
3590 for (t = parms; t; t = TREE_CHAIN (t))
3592 tree type = TREE_VALUE (t);
3594 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3600 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3603 if (c_promoting_integer_type_p (type))
3609 /* Recursively examines the array elements of TYPE, until a non-array
3610 element type is found. */
3613 strip_array_types (tree type)
3615 while (TREE_CODE (type) == ARRAY_TYPE)
3616 type = TREE_TYPE (type);
3621 /* Recursively remove any '*' or '&' operator from TYPE. */
3623 strip_pointer_operator (tree t)
3625 while (POINTER_TYPE_P (t))
3630 static tree expand_unordered_cmp (tree, tree, enum tree_code, enum tree_code);
3632 /* Expand a call to an unordered comparison function such as
3633 __builtin_isgreater(). FUNCTION is the function's declaration and
3634 PARAMS a list of the values passed. For __builtin_isunordered(),
3635 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3636 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3637 that give the opposite of the desired result. UNORDERED_CODE is
3638 used for modes that can hold NaNs and ORDERED_CODE is used for the
3642 expand_unordered_cmp (tree function, tree params,
3643 enum tree_code unordered_code,
3644 enum tree_code ordered_code)
3646 tree arg0, arg1, type;
3647 enum tree_code code0, code1;
3649 /* Check that we have exactly two arguments. */
3650 if (params == 0 || TREE_CHAIN (params) == 0)
3652 error ("too few arguments to function `%s'",
3653 IDENTIFIER_POINTER (DECL_NAME (function)));
3654 return error_mark_node;
3656 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3658 error ("too many arguments to function `%s'",
3659 IDENTIFIER_POINTER (DECL_NAME (function)));
3660 return error_mark_node;
3663 arg0 = TREE_VALUE (params);
3664 arg1 = TREE_VALUE (TREE_CHAIN (params));
3666 code0 = TREE_CODE (TREE_TYPE (arg0));
3667 code1 = TREE_CODE (TREE_TYPE (arg1));
3669 /* Make sure that the arguments have a common type of REAL. */
3671 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3672 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3673 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3675 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3677 error ("non-floating-point argument to function `%s'",
3678 IDENTIFIER_POINTER (DECL_NAME (function)));
3679 return error_mark_node;
3682 if (unordered_code == UNORDERED_EXPR)
3684 if (MODE_HAS_NANS (TYPE_MODE (type)))
3685 return build_binary_op (unordered_code,
3686 convert (type, arg0),
3687 convert (type, arg1),
3690 return integer_zero_node;
3693 return build_unary_op (TRUTH_NOT_EXPR,
3694 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3697 convert (type, arg0),
3698 convert (type, arg1),
3704 /* Recognize certain built-in functions so we can make tree-codes
3705 other than CALL_EXPR. We do this when it enables fold-const.c
3706 to do something useful. */
3707 /* ??? By rights this should go in builtins.c, but only C and C++
3708 implement build_{binary,unary}_op. Not exactly sure what bits
3709 of functionality are actually needed from those functions, or
3710 where the similar functionality exists in the other front ends. */
3713 expand_tree_builtin (tree function, tree params, tree coerced_params)
3715 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3718 switch (DECL_FUNCTION_CODE (function))
3722 case BUILT_IN_LLABS:
3723 case BUILT_IN_IMAXABS:
3725 case BUILT_IN_FABSL:
3726 case BUILT_IN_FABSF:
3727 if (coerced_params == 0)
3728 return integer_zero_node;
3729 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3732 case BUILT_IN_CONJF:
3733 case BUILT_IN_CONJL:
3734 if (coerced_params == 0)
3735 return integer_zero_node;
3736 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3738 case BUILT_IN_CREAL:
3739 case BUILT_IN_CREALF:
3740 case BUILT_IN_CREALL:
3741 if (coerced_params == 0)
3742 return integer_zero_node;
3743 return non_lvalue (build_unary_op (REALPART_EXPR,
3744 TREE_VALUE (coerced_params), 0));
3746 case BUILT_IN_CIMAG:
3747 case BUILT_IN_CIMAGF:
3748 case BUILT_IN_CIMAGL:
3749 if (coerced_params == 0)
3750 return integer_zero_node;
3751 return non_lvalue (build_unary_op (IMAGPART_EXPR,
3752 TREE_VALUE (coerced_params), 0));
3754 case BUILT_IN_ISGREATER:
3755 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3757 case BUILT_IN_ISGREATEREQUAL:
3758 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3760 case BUILT_IN_ISLESS:
3761 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3763 case BUILT_IN_ISLESSEQUAL:
3764 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3766 case BUILT_IN_ISLESSGREATER:
3767 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3769 case BUILT_IN_ISUNORDERED:
3770 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3779 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3780 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3781 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3782 value, the traversal is aborted, and the value returned by FUNC is
3783 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3784 the node being visited are not walked.
3786 We don't need a without_duplicates variant of this one because the
3787 statement tree is a tree, not a graph. */
3790 walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
3792 enum tree_code code;
3797 #define WALK_SUBTREE(NODE) \
3800 result = walk_stmt_tree (&(NODE), func, data); \
3806 /* Skip empty subtrees. */
3810 /* Skip subtrees below non-statement nodes. */
3811 if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
3814 /* Call the function. */
3816 result = (*func) (tp, &walk_subtrees, data);
3818 /* If we found something, return it. */
3822 /* FUNC may have modified the tree, recheck that we're looking at a
3824 code = TREE_CODE (*tp);
3825 if (!STATEMENT_CODE_P (code))
3828 /* Visit the subtrees unless FUNC decided that there was nothing
3829 interesting below this point in the tree. */
3832 /* Walk over all the sub-trees of this operand. Statement nodes
3833 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3834 len = TREE_CODE_LENGTH (code);
3836 /* Go through the subtrees. We need to do this in forward order so
3837 that the scope of a FOR_EXPR is handled properly. */
3838 for (i = 0; i < len; ++i)
3839 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3842 /* Finally visit the chain. This can be tail-recursion optimized if
3843 we write it this way. */
3844 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3849 /* Used to compare case labels. K1 and K2 are actually tree nodes
3850 representing case labels, or NULL_TREE for a `default' label.
3851 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3852 K2, and 0 if K1 and K2 are equal. */
3855 case_compare (splay_tree_key k1, splay_tree_key k2)
3857 /* Consider a NULL key (such as arises with a `default' label) to be
3858 smaller than anything else. */
3864 return tree_int_cst_compare ((tree) k1, (tree) k2);
3867 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3868 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3869 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3870 case label was declared using the usual C/C++ syntax, rather than
3871 the GNU case range extension. CASES is a tree containing all the
3872 case ranges processed so far; COND is the condition for the
3873 switch-statement itself. Returns the CASE_LABEL created, or
3874 ERROR_MARK_NODE if no CASE_LABEL is created. */
3877 c_add_case_label (splay_tree cases, tree cond, tree low_value,
3883 splay_tree_node node;
3885 /* Create the LABEL_DECL itself. */
3886 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3887 DECL_CONTEXT (label) = current_function_decl;
3889 /* If there was an error processing the switch condition, bail now
3890 before we get more confused. */
3891 if (!cond || cond == error_mark_node)
3893 /* Add a label anyhow so that the back-end doesn't think that
3894 the beginning of the switch is unreachable. */
3896 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3897 return error_mark_node;
3900 if ((low_value && TREE_TYPE (low_value)
3901 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3902 || (high_value && TREE_TYPE (high_value)
3903 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3904 error ("pointers are not permitted as case values");
3906 /* Case ranges are a GNU extension. */
3907 if (high_value && pedantic)
3908 pedwarn ("range expressions in switch statements are non-standard");
3910 type = TREE_TYPE (cond);
3913 low_value = check_case_value (low_value);
3914 low_value = convert_and_check (type, low_value);
3918 high_value = check_case_value (high_value);
3919 high_value = convert_and_check (type, high_value);
3922 /* If an error has occurred, bail out now. */
3923 if (low_value == error_mark_node || high_value == error_mark_node)
3926 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3927 return error_mark_node;
3930 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3931 really a case range, even though it was written that way. Remove
3932 the HIGH_VALUE to simplify later processing. */
3933 if (tree_int_cst_equal (low_value, high_value))
3934 high_value = NULL_TREE;
3935 if (low_value && high_value
3936 && !tree_int_cst_lt (low_value, high_value))
3937 warning ("empty range specified");
3939 /* Look up the LOW_VALUE in the table of case labels we already
3941 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3942 /* If there was not an exact match, check for overlapping ranges.
3943 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3944 that's a `default' label and the only overlap is an exact match. */
3945 if (!node && (low_value || high_value))
3947 splay_tree_node low_bound;
3948 splay_tree_node high_bound;
3950 /* Even though there wasn't an exact match, there might be an
3951 overlap between this case range and another case range.
3952 Since we've (inductively) not allowed any overlapping case
3953 ranges, we simply need to find the greatest low case label
3954 that is smaller that LOW_VALUE, and the smallest low case
3955 label that is greater than LOW_VALUE. If there is an overlap
3956 it will occur in one of these two ranges. */
3957 low_bound = splay_tree_predecessor (cases,
3958 (splay_tree_key) low_value);
3959 high_bound = splay_tree_successor (cases,
3960 (splay_tree_key) low_value);
3962 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3963 the LOW_VALUE, so there is no need to check unless the
3964 LOW_BOUND is in fact itself a case range. */
3966 && CASE_HIGH ((tree) low_bound->value)
3967 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3970 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3971 range is bigger than the low end of the current range, so we
3972 are only interested if the current range is a real range, and
3973 not an ordinary case label. */
3976 && (tree_int_cst_compare ((tree) high_bound->key,
3981 /* If there was an overlap, issue an error. */
3984 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3988 error ("duplicate (or overlapping) case value");
3989 error ("%Jthis is the first entry overlapping that value", duplicate);
3993 error ("duplicate case value") ;
3994 error ("%Jpreviously used here", duplicate);
3998 error ("multiple default labels in one switch");
3999 error ("%Jthis is the first default label", duplicate);
4002 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
4005 /* Add a CASE_LABEL to the statement-tree. */
4006 case_label = add_stmt (build_case_label (low_value, high_value, label));
4007 /* Register this case label in the splay tree. */
4008 splay_tree_insert (cases,
4009 (splay_tree_key) low_value,
4010 (splay_tree_value) case_label);
4015 /* Finish an expression taking the address of LABEL (an
4016 IDENTIFIER_NODE). Returns an expression for the address. */
4019 finish_label_address_expr (tree label)
4024 pedwarn ("taking the address of a label is non-standard");
4026 if (label == error_mark_node)
4027 return error_mark_node;
4029 label = lookup_label (label);
4030 if (label == NULL_TREE)
4031 result = null_pointer_node;
4034 TREE_USED (label) = 1;
4035 result = build1 (ADDR_EXPR, ptr_type_node, label);
4036 TREE_CONSTANT (result) = 1;
4037 /* The current function in not necessarily uninlinable.
4038 Computed gotos are incompatible with inlining, but the value
4039 here could be used only in a diagnostic, for example. */
4045 /* Hook used by expand_expr to expand language-specific tree codes. */
4048 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4049 int modifier /* Actually enum_modifier. */,
4052 switch (TREE_CODE (exp))
4058 bool preserve_result = false;
4060 if (STMT_EXPR_WARN_UNUSED_RESULT (exp) && target == const0_rtx)
4062 tree stmt = STMT_EXPR_STMT (exp);
4065 for (scope = COMPOUND_BODY (stmt);
4066 scope && TREE_CODE (scope) != SCOPE_STMT;
4067 scope = TREE_CHAIN (scope));
4069 if (scope && SCOPE_STMT_BLOCK (scope))
4070 warning ("%Hignoring return value of `%D', "
4071 "declared with attribute warn_unused_result",
4072 &expr_wfl_stack->location,
4073 BLOCK_ABSTRACT_ORIGIN (SCOPE_STMT_BLOCK (scope)));
4075 warning ("%Hignoring return value of function "
4076 "declared with attribute warn_unused_result",
4077 &expr_wfl_stack->location);
4080 /* Since expand_expr_stmt calls free_temp_slots after every
4081 expression statement, we must call push_temp_slots here.
4082 Otherwise, any temporaries in use now would be considered
4083 out-of-scope after the first EXPR_STMT from within the
4086 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4088 /* If we want the result of this expression, find the last
4089 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4090 if (target != const0_rtx
4091 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4092 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4094 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4095 tree last = TREE_CHAIN (expr);
4097 while (TREE_CHAIN (last))
4100 last = TREE_CHAIN (last);
4103 if (TREE_CODE (last) == SCOPE_STMT
4104 && TREE_CODE (expr) == EXPR_STMT)
4106 /* Otherwise, note that we want the value from the last
4108 TREE_ADDRESSABLE (expr) = 1;
4109 preserve_result = true;
4113 expand_stmt (STMT_EXPR_STMT (exp));
4114 expand_end_stmt_expr (rtl_expr);
4116 result = expand_expr_real (rtl_expr, target, tmode, modifier, alt_rtl);
4117 if (preserve_result && GET_CODE (result) == MEM)
4119 if (GET_MODE (result) != BLKmode)
4120 result = copy_to_reg (result);
4122 preserve_temp_slots (result);
4125 /* If the statment-expression does not have a scope, then the
4126 new temporaries we created within it must live beyond the
4127 statement-expression. */
4128 if (STMT_EXPR_NO_SCOPE (exp))
4129 preserve_temp_slots (NULL_RTX);
4136 case COMPOUND_LITERAL_EXPR:
4138 /* Initialize the anonymous variable declared in the compound
4139 literal, then return the variable. */
4140 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4141 emit_local_var (decl);
4142 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4153 /* Hook used by safe_from_p to handle language-specific tree codes. */
4156 c_safe_from_p (rtx target, tree exp)
4158 /* We can see statements here when processing the body of a
4159 statement-expression. For a declaration statement declaring a
4160 variable, look at the variable's initializer. */
4161 if (TREE_CODE (exp) == DECL_STMT)
4163 tree decl = DECL_STMT_DECL (exp);
4165 if (TREE_CODE (decl) == VAR_DECL
4166 && DECL_INITIAL (decl)
4167 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4171 /* For any statement, we must follow the statement-chain. */
4172 if (STATEMENT_CODE_P (TREE_CODE (exp)) && TREE_CHAIN (exp))
4173 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4175 /* Assume everything else is safe. */
4179 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4182 c_common_unsafe_for_reeval (tree exp)
4184 /* Statement expressions may not be reevaluated, likewise compound
4186 if (TREE_CODE (exp) == STMT_EXPR
4187 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4190 /* Walk all other expressions. */
4194 /* Hook used by staticp to handle language-specific tree codes. */
4197 c_staticp (tree exp)
4199 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4200 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4206 /* Given a boolean expression ARG, return a tree representing an increment
4207 or decrement (as indicated by CODE) of ARG. The front end must check for
4208 invalid cases (e.g., decrement in C++). */
4210 boolean_increment (enum tree_code code, tree arg)
4213 tree true_res = boolean_true_node;
4215 arg = stabilize_reference (arg);
4218 case PREINCREMENT_EXPR:
4219 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4221 case POSTINCREMENT_EXPR:
4222 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4223 arg = save_expr (arg);
4224 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4225 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4227 case PREDECREMENT_EXPR:
4228 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4230 case POSTDECREMENT_EXPR:
4231 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4232 arg = save_expr (arg);
4233 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4234 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4239 TREE_SIDE_EFFECTS (val) = 1;
4243 /* Built-in macros for stddef.h, that require macros defined in this
4246 c_stddef_cpp_builtins(void)
4248 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4249 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4250 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4251 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4255 c_init_attributes (void)
4257 /* Fill in the built_in_attributes array. */
4258 #define DEF_ATTR_NULL_TREE(ENUM) \
4259 built_in_attributes[(int) ENUM] = NULL_TREE;
4260 #define DEF_ATTR_INT(ENUM, VALUE) \
4261 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4262 #define DEF_ATTR_IDENT(ENUM, STRING) \
4263 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4264 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4265 built_in_attributes[(int) ENUM] \
4266 = tree_cons (built_in_attributes[(int) PURPOSE], \
4267 built_in_attributes[(int) VALUE], \
4268 built_in_attributes[(int) CHAIN]);
4269 #include "builtin-attrs.def"
4270 #undef DEF_ATTR_NULL_TREE
4272 #undef DEF_ATTR_IDENT
4273 #undef DEF_ATTR_TREE_LIST
4276 /* Attribute handlers common to C front ends. */
4278 /* Handle a "packed" attribute; arguments as in
4279 struct attribute_spec.handler. */
4282 handle_packed_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4283 int flags, bool *no_add_attrs)
4287 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4288 *node = build_type_copy (*node);
4289 TYPE_PACKED (*node) = 1;
4290 if (TYPE_MAIN_VARIANT (*node) == *node)
4292 /* If it is the main variant, then pack the other variants
4293 too. This happens in,
4296 struct Foo const *ptr; // creates a variant w/o packed flag
4297 } __ attribute__((packed)); // packs it now.
4301 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
4302 TYPE_PACKED (probe) = 1;
4306 else if (TREE_CODE (*node) == FIELD_DECL)
4307 DECL_PACKED (*node) = 1;
4308 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4309 used for DECL_REGISTER. It wouldn't mean anything anyway.
4310 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4311 that changes what the typedef is typing. */
4314 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4315 *no_add_attrs = true;
4321 /* Handle a "nocommon" attribute; arguments as in
4322 struct attribute_spec.handler. */
4325 handle_nocommon_attribute (tree *node, tree name,
4326 tree args ATTRIBUTE_UNUSED,
4327 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4329 if (TREE_CODE (*node) == VAR_DECL)
4330 DECL_COMMON (*node) = 0;
4333 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4334 *no_add_attrs = true;
4340 /* Handle a "common" attribute; arguments as in
4341 struct attribute_spec.handler. */
4344 handle_common_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4345 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4347 if (TREE_CODE (*node) == VAR_DECL)
4348 DECL_COMMON (*node) = 1;
4351 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4352 *no_add_attrs = true;
4358 /* Handle a "noreturn" attribute; arguments as in
4359 struct attribute_spec.handler. */
4362 handle_noreturn_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4363 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4365 tree type = TREE_TYPE (*node);
4367 /* See FIXME comment in c_common_attribute_table. */
4368 if (TREE_CODE (*node) == FUNCTION_DECL)
4369 TREE_THIS_VOLATILE (*node) = 1;
4370 else if (TREE_CODE (type) == POINTER_TYPE
4371 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4373 = build_pointer_type
4374 (build_type_variant (TREE_TYPE (type),
4375 TREE_READONLY (TREE_TYPE (type)), 1));
4378 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4379 *no_add_attrs = true;
4385 /* Handle a "noinline" attribute; arguments as in
4386 struct attribute_spec.handler. */
4389 handle_noinline_attribute (tree *node, tree name,
4390 tree args ATTRIBUTE_UNUSED,
4391 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4393 if (TREE_CODE (*node) == FUNCTION_DECL)
4394 DECL_UNINLINABLE (*node) = 1;
4397 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4398 *no_add_attrs = true;
4404 /* Handle a "always_inline" attribute; arguments as in
4405 struct attribute_spec.handler. */
4408 handle_always_inline_attribute (tree *node, tree name,
4409 tree args ATTRIBUTE_UNUSED,
4410 int flags ATTRIBUTE_UNUSED,
4413 if (TREE_CODE (*node) == FUNCTION_DECL)
4415 /* Do nothing else, just set the attribute. We'll get at
4416 it later with lookup_attribute. */
4420 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4421 *no_add_attrs = true;
4427 /* Handle a "used" attribute; arguments as in
4428 struct attribute_spec.handler. */
4431 handle_used_attribute (tree *pnode, tree name, tree args ATTRIBUTE_UNUSED,
4432 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4436 if (TREE_CODE (node) == FUNCTION_DECL
4437 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4439 TREE_USED (node) = 1;
4443 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4444 *no_add_attrs = true;
4450 /* Handle a "unused" attribute; arguments as in
4451 struct attribute_spec.handler. */
4454 handle_unused_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4455 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4461 if (TREE_CODE (decl) == PARM_DECL
4462 || TREE_CODE (decl) == VAR_DECL
4463 || TREE_CODE (decl) == FUNCTION_DECL
4464 || TREE_CODE (decl) == LABEL_DECL
4465 || TREE_CODE (decl) == TYPE_DECL)
4466 TREE_USED (decl) = 1;
4469 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4470 *no_add_attrs = true;
4475 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4476 *node = build_type_copy (*node);
4477 TREE_USED (*node) = 1;
4483 /* Handle a "const" attribute; arguments as in
4484 struct attribute_spec.handler. */
4487 handle_const_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4488 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4490 tree type = TREE_TYPE (*node);
4492 /* See FIXME comment on noreturn in c_common_attribute_table. */
4493 if (TREE_CODE (*node) == FUNCTION_DECL)
4494 TREE_READONLY (*node) = 1;
4495 else if (TREE_CODE (type) == POINTER_TYPE
4496 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4498 = build_pointer_type
4499 (build_type_variant (TREE_TYPE (type), 1,
4500 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4503 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4504 *no_add_attrs = true;
4510 /* Handle a "transparent_union" attribute; arguments as in
4511 struct attribute_spec.handler. */
4514 handle_transparent_union_attribute (tree *node, tree name,
4515 tree args ATTRIBUTE_UNUSED, int flags,
4518 tree decl = NULL_TREE;
4525 type = &TREE_TYPE (decl);
4526 is_type = TREE_CODE (*node) == TYPE_DECL;
4528 else if (TYPE_P (*node))
4529 type = node, is_type = 1;
4532 && TREE_CODE (*type) == UNION_TYPE
4534 || (TYPE_FIELDS (*type) != 0
4535 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4537 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4538 *type = build_type_copy (*type);
4539 TYPE_TRANSPARENT_UNION (*type) = 1;
4541 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4542 && TREE_CODE (*type) == UNION_TYPE
4543 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4544 DECL_TRANSPARENT_UNION (decl) = 1;
4547 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4548 *no_add_attrs = true;
4554 /* Handle a "constructor" attribute; arguments as in
4555 struct attribute_spec.handler. */
4558 handle_constructor_attribute (tree *node, tree name,
4559 tree args ATTRIBUTE_UNUSED,
4560 int flags ATTRIBUTE_UNUSED,
4564 tree type = TREE_TYPE (decl);
4566 if (TREE_CODE (decl) == FUNCTION_DECL
4567 && TREE_CODE (type) == FUNCTION_TYPE
4568 && decl_function_context (decl) == 0)
4570 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4571 TREE_USED (decl) = 1;
4575 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4576 *no_add_attrs = true;
4582 /* Handle a "destructor" attribute; arguments as in
4583 struct attribute_spec.handler. */
4586 handle_destructor_attribute (tree *node, tree name,
4587 tree args ATTRIBUTE_UNUSED,
4588 int flags ATTRIBUTE_UNUSED,
4592 tree type = TREE_TYPE (decl);
4594 if (TREE_CODE (decl) == FUNCTION_DECL
4595 && TREE_CODE (type) == FUNCTION_TYPE
4596 && decl_function_context (decl) == 0)
4598 DECL_STATIC_DESTRUCTOR (decl) = 1;
4599 TREE_USED (decl) = 1;
4603 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4604 *no_add_attrs = true;
4610 /* Handle a "mode" attribute; arguments as in
4611 struct attribute_spec.handler. */
4614 handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4615 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4619 *no_add_attrs = true;
4621 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4622 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4626 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4627 int len = strlen (p);
4628 enum machine_mode mode = VOIDmode;
4632 if (len > 4 && p[0] == '_' && p[1] == '_'
4633 && p[len - 1] == '_' && p[len - 2] == '_')
4635 char *newp = alloca (len - 1);
4637 strcpy (newp, &p[2]);
4638 newp[len - 4] = '\0';
4642 /* Change this type to have a type with the specified mode.
4643 First check for the special modes. */
4644 if (! strcmp (p, "byte"))
4646 else if (!strcmp (p, "word"))
4648 else if (! strcmp (p, "pointer"))
4651 for (j = 0; j < NUM_MACHINE_MODES; j++)
4652 if (!strcmp (p, GET_MODE_NAME (j)))
4654 mode = (enum machine_mode) j;
4658 if (mode == VOIDmode)
4659 error ("unknown machine mode `%s'", p);
4660 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
4661 (mode, TREE_UNSIGNED (type))))
4662 error ("no data type for mode `%s'", p);
4663 else if ((TREE_CODE (type) == POINTER_TYPE
4664 || TREE_CODE (type) == REFERENCE_TYPE)
4665 && !(*targetm.valid_pointer_mode) (mode))
4666 error ("invalid pointer mode `%s'", p);
4669 /* If this is a vector, make sure we either have hardware
4670 support, or we can emulate it. */
4671 if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
4673 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
4677 if (TREE_CODE (type) == POINTER_TYPE)
4679 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
4683 else if (TREE_CODE (type) == REFERENCE_TYPE)
4685 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
4689 else if (TREE_CODE (type) == ENUMERAL_TYPE)
4691 /* For enumeral types, copy the precision from the integer
4692 type returned above. If not an INTEGER_TYPE, we can't use
4693 this mode for this type. */
4694 if (TREE_CODE (typefm) != INTEGER_TYPE)
4696 error ("cannot use mode %qs for enumeral types", p);
4700 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4701 type = build_type_copy (type);
4703 /* We cannot use layout_type here, because that will attempt
4704 to re-layout all variants, corrupting our original. */
4705 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4706 TYPE_MIN_VALUE (type) = TYPE_MIN_VALUE (typefm);
4707 TYPE_MAX_VALUE (type) = TYPE_MAX_VALUE (typefm);
4708 TYPE_SIZE (type) = TYPE_SIZE (typefm);
4709 TYPE_SIZE_UNIT (type) = TYPE_SIZE_UNIT (typefm);
4710 TYPE_MODE (type) = TYPE_MODE (typefm);
4711 if (!TYPE_USER_ALIGN (type))
4712 TYPE_ALIGN (type) = TYPE_ALIGN (typefm);
4716 else if (VECTOR_MODE_P (mode)
4717 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4718 : TREE_CODE (type) != TREE_CODE (typefm))
4721 error ("mode `%s' applied to inappropriate type", p);
4727 /* No need to layout the type here. The caller should do this. */
4734 /* Handle a "section" attribute; arguments as in
4735 struct attribute_spec.handler. */
4738 handle_section_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4739 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4743 if (targetm.have_named_sections)
4745 if ((TREE_CODE (decl) == FUNCTION_DECL
4746 || TREE_CODE (decl) == VAR_DECL)
4747 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4749 if (TREE_CODE (decl) == VAR_DECL
4750 && current_function_decl != NULL_TREE
4751 && ! TREE_STATIC (decl))
4753 error ("%Jsection attribute cannot be specified for "
4754 "local variables", decl);
4755 *no_add_attrs = true;
4758 /* The decl may have already been given a section attribute
4759 from a previous declaration. Ensure they match. */
4760 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4761 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4762 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4764 error ("%Jsection of '%D' conflicts with previous declaration",
4766 *no_add_attrs = true;
4769 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4773 error ("%Jsection attribute not allowed for '%D'", *node, *node);
4774 *no_add_attrs = true;
4779 error ("%Jsection attributes are not supported for this target", *node);
4780 *no_add_attrs = true;
4786 /* Handle a "aligned" attribute; arguments as in
4787 struct attribute_spec.handler. */
4790 handle_aligned_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4791 int flags, bool *no_add_attrs)
4793 tree decl = NULL_TREE;
4796 tree align_expr = (args ? TREE_VALUE (args)
4797 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4803 type = &TREE_TYPE (decl);
4804 is_type = TREE_CODE (*node) == TYPE_DECL;
4806 else if (TYPE_P (*node))
4807 type = node, is_type = 1;
4809 /* Strip any NOPs of any kind. */
4810 while (TREE_CODE (align_expr) == NOP_EXPR
4811 || TREE_CODE (align_expr) == CONVERT_EXPR
4812 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4813 align_expr = TREE_OPERAND (align_expr, 0);
4815 if (TREE_CODE (align_expr) != INTEGER_CST)
4817 error ("requested alignment is not a constant");
4818 *no_add_attrs = true;
4820 else if ((i = tree_log2 (align_expr)) == -1)
4822 error ("requested alignment is not a power of 2");
4823 *no_add_attrs = true;
4825 else if (i > HOST_BITS_PER_INT - 2)
4827 error ("requested alignment is too large");
4828 *no_add_attrs = true;
4832 /* If we have a TYPE_DECL, then copy the type, so that we
4833 don't accidentally modify a builtin type. See pushdecl. */
4834 if (decl && TREE_TYPE (decl) != error_mark_node
4835 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4837 tree tt = TREE_TYPE (decl);
4838 *type = build_type_copy (*type);
4839 DECL_ORIGINAL_TYPE (decl) = tt;
4840 TYPE_NAME (*type) = decl;
4841 TREE_USED (*type) = TREE_USED (decl);
4842 TREE_TYPE (decl) = *type;
4844 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4845 *type = build_type_copy (*type);
4847 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4848 TYPE_USER_ALIGN (*type) = 1;
4850 else if (TREE_CODE (decl) != VAR_DECL
4851 && TREE_CODE (decl) != FIELD_DECL)
4853 error ("%Jalignment may not be specified for '%D'", decl, decl);
4854 *no_add_attrs = true;
4858 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4859 DECL_USER_ALIGN (decl) = 1;
4865 /* Handle a "weak" attribute; arguments as in
4866 struct attribute_spec.handler. */
4869 handle_weak_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
4870 tree args ATTRIBUTE_UNUSED,
4871 int flags ATTRIBUTE_UNUSED,
4872 bool *no_add_attrs ATTRIBUTE_UNUSED)
4874 declare_weak (*node);
4879 /* Handle an "alias" attribute; arguments as in
4880 struct attribute_spec.handler. */
4883 handle_alias_attribute (tree *node, tree name, tree args,
4884 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4888 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4889 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
4891 error ("%J'%D' defined both normally and as an alias", decl, decl);
4892 *no_add_attrs = true;
4894 else if (decl_function_context (decl) == 0)
4898 id = TREE_VALUE (args);
4899 if (TREE_CODE (id) != STRING_CST)
4901 error ("alias arg not a string");
4902 *no_add_attrs = true;
4905 id = get_identifier (TREE_STRING_POINTER (id));
4906 /* This counts as a use of the object pointed to. */
4909 if (TREE_CODE (decl) == FUNCTION_DECL)
4910 DECL_INITIAL (decl) = error_mark_node;
4912 DECL_EXTERNAL (decl) = 0;
4916 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4917 *no_add_attrs = true;
4923 /* Handle an "visibility" attribute; arguments as in
4924 struct attribute_spec.handler. */
4927 handle_visibility_attribute (tree *node, tree name, tree args,
4928 int flags ATTRIBUTE_UNUSED,
4932 tree id = TREE_VALUE (args);
4934 *no_add_attrs = true;
4936 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
4938 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4942 if (TREE_CODE (id) != STRING_CST)
4944 error ("visibility arg not a string");
4948 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4949 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4950 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4951 DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4952 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4953 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4954 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4955 DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4957 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4962 /* Handle an "tls_model" attribute; arguments as in
4963 struct attribute_spec.handler. */
4966 handle_tls_model_attribute (tree *node, tree name, tree args,
4967 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4971 if (! DECL_THREAD_LOCAL (decl))
4973 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4974 *no_add_attrs = true;
4980 id = TREE_VALUE (args);
4981 if (TREE_CODE (id) != STRING_CST)
4983 error ("tls_model arg not a string");
4984 *no_add_attrs = true;
4987 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
4988 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
4989 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
4990 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4992 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4993 *no_add_attrs = true;
5001 /* Handle a "no_instrument_function" attribute; arguments as in
5002 struct attribute_spec.handler. */
5005 handle_no_instrument_function_attribute (tree *node, tree name,
5006 tree args ATTRIBUTE_UNUSED,
5007 int flags ATTRIBUTE_UNUSED,
5012 if (TREE_CODE (decl) != FUNCTION_DECL)
5014 error ("%J'%E' attribute applies only to functions", decl, name);
5015 *no_add_attrs = true;
5017 else if (DECL_INITIAL (decl))
5019 error ("%Jcan't set '%E' attribute after definition", decl, name);
5020 *no_add_attrs = true;
5023 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5028 /* Handle a "malloc" attribute; arguments as in
5029 struct attribute_spec.handler. */
5032 handle_malloc_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5033 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5035 if (TREE_CODE (*node) == FUNCTION_DECL)
5036 DECL_IS_MALLOC (*node) = 1;
5037 /* ??? TODO: Support types. */
5040 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5041 *no_add_attrs = true;
5047 /* Handle a "no_limit_stack" attribute; arguments as in
5048 struct attribute_spec.handler. */
5051 handle_no_limit_stack_attribute (tree *node, tree name,
5052 tree args ATTRIBUTE_UNUSED,
5053 int flags ATTRIBUTE_UNUSED,
5058 if (TREE_CODE (decl) != FUNCTION_DECL)
5060 error ("%J'%E' attribute applies only to functions", decl, name);
5061 *no_add_attrs = true;
5063 else if (DECL_INITIAL (decl))
5065 error ("%Jcan't set '%E' attribute after definition", decl, name);
5066 *no_add_attrs = true;
5069 DECL_NO_LIMIT_STACK (decl) = 1;
5074 /* Handle a "pure" attribute; arguments as in
5075 struct attribute_spec.handler. */
5078 handle_pure_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5079 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5081 if (TREE_CODE (*node) == FUNCTION_DECL)
5082 DECL_IS_PURE (*node) = 1;
5083 /* ??? TODO: Support types. */
5086 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5087 *no_add_attrs = true;
5093 /* Handle a "deprecated" attribute; arguments as in
5094 struct attribute_spec.handler. */
5097 handle_deprecated_attribute (tree *node, tree name,
5098 tree args ATTRIBUTE_UNUSED, int flags,
5101 tree type = NULL_TREE;
5103 const char *what = NULL;
5108 type = TREE_TYPE (decl);
5110 if (TREE_CODE (decl) == TYPE_DECL
5111 || TREE_CODE (decl) == PARM_DECL
5112 || TREE_CODE (decl) == VAR_DECL
5113 || TREE_CODE (decl) == FUNCTION_DECL
5114 || TREE_CODE (decl) == FIELD_DECL)
5115 TREE_DEPRECATED (decl) = 1;
5119 else if (TYPE_P (*node))
5121 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5122 *node = build_type_copy (*node);
5123 TREE_DEPRECATED (*node) = 1;
5131 *no_add_attrs = true;
5132 if (type && TYPE_NAME (type))
5134 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5135 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5136 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5137 && DECL_NAME (TYPE_NAME (type)))
5138 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5141 warning ("`%s' attribute ignored for `%s'",
5142 IDENTIFIER_POINTER (name), what);
5144 warning ("`%s' attribute ignored",
5145 IDENTIFIER_POINTER (name));
5151 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5152 to prevent us from duplicating type nodes unnecessarily.
5153 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5154 since we want to distinguish types that are essentially identical (except
5155 for their debug representation), we use a local list here. */
5156 static GTY(()) tree vector_type_node_list = 0;
5158 /* Handle a "vector_size" attribute; arguments as in
5159 struct attribute_spec.handler. */
5162 handle_vector_size_attribute (tree *node, tree name, tree args,
5163 int flags ATTRIBUTE_UNUSED,
5166 unsigned HOST_WIDE_INT vecsize, nunits;
5167 enum machine_mode mode, orig_mode, new_mode;
5168 tree type = *node, new_type = NULL_TREE;
5169 tree type_list_node;
5171 *no_add_attrs = true;
5173 if (! host_integerp (TREE_VALUE (args), 1))
5175 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5179 /* Get the vector size (in bytes). */
5180 vecsize = tree_low_cst (TREE_VALUE (args), 1);
5182 /* We need to provide for vector pointers, vector arrays, and
5183 functions returning vectors. For example:
5185 __attribute__((vector_size(16))) short *foo;
5187 In this case, the mode is SI, but the type being modified is
5188 HI, so we need to look further. */
5190 while (POINTER_TYPE_P (type)
5191 || TREE_CODE (type) == FUNCTION_TYPE
5192 || TREE_CODE (type) == METHOD_TYPE
5193 || TREE_CODE (type) == ARRAY_TYPE)
5194 type = TREE_TYPE (type);
5196 /* Get the mode of the type being modified. */
5197 orig_mode = TYPE_MODE (type);
5199 if (TREE_CODE (type) == RECORD_TYPE
5200 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5201 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5202 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5204 error ("invalid vector type for attribute `%s'",
5205 IDENTIFIER_POINTER (name));
5209 /* Calculate how many units fit in the vector. */
5210 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5212 /* Find a suitably sized vector. */
5213 new_mode = VOIDmode;
5214 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5216 : MODE_VECTOR_FLOAT);
5218 mode = GET_MODE_WIDER_MODE (mode))
5219 if (vecsize == GET_MODE_SIZE (mode)
5220 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5226 if (new_mode == VOIDmode)
5228 error ("no vector mode with the size and type specified could be found");
5232 for (type_list_node = vector_type_node_list; type_list_node;
5233 type_list_node = TREE_CHAIN (type_list_node))
5235 tree other_type = TREE_VALUE (type_list_node);
5236 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
5237 tree fields = TYPE_FIELDS (record);
5238 tree field_type = TREE_TYPE (fields);
5239 tree array_type = TREE_TYPE (field_type);
5240 if (TREE_CODE (fields) != FIELD_DECL
5241 || TREE_CODE (field_type) != ARRAY_TYPE)
5244 if (TYPE_MODE (other_type) == mode && type == array_type)
5246 new_type = other_type;
5251 if (new_type == NULL_TREE)
5253 tree index, array, rt, list_node;
5255 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
5256 TREE_UNSIGNED (type));
5260 error ("no vector mode with the size and type specified could be found");
5264 new_type = build_type_copy (new_type);
5266 /* If this is a vector, make sure we either have hardware
5267 support, or we can emulate it. */
5268 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5269 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5270 && !vector_mode_valid_p (mode))
5272 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5276 /* Set the debug information here, because this is the only
5277 place where we know the underlying type for a vector made
5278 with vector_size. For debugging purposes we pretend a vector
5279 is an array within a structure. */
5280 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
5281 array = build_array_type (type, build_index_type (index));
5282 rt = make_node (RECORD_TYPE);
5284 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
5285 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
5287 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
5289 list_node = build_tree_list (NULL, new_type);
5290 TREE_CHAIN (list_node) = vector_type_node_list;
5291 vector_type_node_list = list_node;
5294 /* Build back pointers if needed. */
5295 *node = reconstruct_complex_type (*node, new_type);
5300 /* Handle the "nonnull" attribute. */
5302 handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
5303 tree args, int flags ATTRIBUTE_UNUSED,
5307 unsigned HOST_WIDE_INT attr_arg_num;
5309 /* If no arguments are specified, all pointer arguments should be
5310 non-null. Verify a full prototype is given so that the arguments
5311 will have the correct types when we actually check them later. */
5314 if (! TYPE_ARG_TYPES (type))
5316 error ("nonnull attribute without arguments on a non-prototype");
5317 *no_add_attrs = true;
5322 /* Argument list specified. Verify that each argument number references
5323 a pointer argument. */
5324 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5327 unsigned HOST_WIDE_INT arg_num, ck_num;
5329 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5331 error ("nonnull argument has invalid operand number (arg %lu)",
5332 (unsigned long) attr_arg_num);
5333 *no_add_attrs = true;
5337 argument = TYPE_ARG_TYPES (type);
5340 for (ck_num = 1; ; ck_num++)
5342 if (! argument || ck_num == arg_num)
5344 argument = TREE_CHAIN (argument);
5348 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5350 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5351 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5352 *no_add_attrs = true;
5356 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5358 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5359 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5360 *no_add_attrs = true;
5369 /* Check the argument list of a function call for null in argument slots
5370 that are marked as requiring a non-null pointer argument. */
5373 check_function_nonnull (tree attrs, tree params)
5375 tree a, args, param;
5378 for (a = attrs; a; a = TREE_CHAIN (a))
5380 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5382 args = TREE_VALUE (a);
5384 /* Walk the argument list. If we encounter an argument number we
5385 should check for non-null, do it. If the attribute has no args,
5386 then every pointer argument is checked (in which case the check
5387 for pointer type is done in check_nonnull_arg). */
5388 for (param = params, param_num = 1; ;
5389 param_num++, param = TREE_CHAIN (param))
5393 if (! args || nonnull_check_p (args, param_num))
5394 check_function_arguments_recurse (check_nonnull_arg, NULL,
5402 /* Helper for check_function_nonnull; given a list of operands which
5403 must be non-null in ARGS, determine if operand PARAM_NUM should be
5407 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5409 unsigned HOST_WIDE_INT arg_num;
5411 for (; args; args = TREE_CHAIN (args))
5413 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5416 if (arg_num == param_num)
5422 /* Check that the function argument PARAM (which is operand number
5423 PARAM_NUM) is non-null. This is called by check_function_nonnull
5424 via check_function_arguments_recurse. */
5427 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED, tree param,
5428 unsigned HOST_WIDE_INT param_num)
5430 /* Just skip checking the argument if it's not a pointer. This can
5431 happen if the "nonnull" attribute was given without an operand
5432 list (which means to check every pointer argument). */
5434 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5437 if (integer_zerop (param))
5438 warning ("null argument where non-null required (arg %lu)",
5439 (unsigned long) param_num);
5442 /* Helper for nonnull attribute handling; fetch the operand number
5443 from the attribute argument list. */
5446 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5448 /* Strip any conversions from the arg number and verify they
5450 while (TREE_CODE (arg_num_expr) == NOP_EXPR
5451 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
5452 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
5453 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
5455 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5456 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5459 *valp = TREE_INT_CST_LOW (arg_num_expr);
5463 /* Handle a "nothrow" attribute; arguments as in
5464 struct attribute_spec.handler. */
5467 handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5468 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5470 if (TREE_CODE (*node) == FUNCTION_DECL)
5471 TREE_NOTHROW (*node) = 1;
5472 /* ??? TODO: Support types. */
5475 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5476 *no_add_attrs = true;
5482 /* Handle a "cleanup" attribute; arguments as in
5483 struct attribute_spec.handler. */
5486 handle_cleanup_attribute (tree *node, tree name, tree args,
5487 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5490 tree cleanup_id, cleanup_decl;
5492 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5493 for global destructors in C++. This requires infrastructure that
5494 we don't have generically at the moment. It's also not a feature
5495 we'd be missing too much, since we do have attribute constructor. */
5496 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5498 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5499 *no_add_attrs = true;
5503 /* Verify that the argument is a function in scope. */
5504 /* ??? We could support pointers to functions here as well, if
5505 that was considered desirable. */
5506 cleanup_id = TREE_VALUE (args);
5507 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5509 error ("cleanup arg not an identifier");
5510 *no_add_attrs = true;
5513 cleanup_decl = lookup_name (cleanup_id);
5514 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5516 error ("cleanup arg not a function");
5517 *no_add_attrs = true;
5521 /* That the function has proper type is checked with the
5522 eventual call to build_function_call. */
5527 /* Handle a "warn_unused_result" attribute. No special handling. */
5530 handle_warn_unused_result_attribute (tree *node, tree name,
5531 tree args ATTRIBUTE_UNUSED,
5532 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5534 /* Ignore the attribute for functions not returning any value. */
5535 if (VOID_TYPE_P (TREE_TYPE (*node)))
5537 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5538 *no_add_attrs = true;
5544 /* Check for valid arguments being passed to a function. */
5546 check_function_arguments (tree attrs, tree params)
5548 /* Check for null being passed in a pointer argument that must be
5549 non-null. We also need to do this if format checking is enabled. */
5552 check_function_nonnull (attrs, params);
5554 /* Check for errors in format strings. */
5557 check_function_format (NULL, attrs, params);
5560 /* Generic argument checking recursion routine. PARAM is the argument to
5561 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5562 once the argument is resolved. CTX is context for the callback. */
5564 check_function_arguments_recurse (void (*callback)
5565 (void *, tree, unsigned HOST_WIDE_INT),
5566 void *ctx, tree param,
5567 unsigned HOST_WIDE_INT param_num)
5569 if (TREE_CODE (param) == NOP_EXPR)
5571 /* Strip coercion. */
5572 check_function_arguments_recurse (callback, ctx,
5573 TREE_OPERAND (param, 0), param_num);
5577 if (TREE_CODE (param) == CALL_EXPR)
5579 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5581 bool found_format_arg = false;
5583 /* See if this is a call to a known internationalization function
5584 that modifies a format arg. Such a function may have multiple
5585 format_arg attributes (for example, ngettext). */
5587 for (attrs = TYPE_ATTRIBUTES (type);
5589 attrs = TREE_CHAIN (attrs))
5590 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5593 tree format_num_expr;
5597 /* Extract the argument number, which was previously checked
5599 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5600 while (TREE_CODE (format_num_expr) == NOP_EXPR
5601 || TREE_CODE (format_num_expr) == CONVERT_EXPR
5602 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5603 format_num_expr = TREE_OPERAND (format_num_expr, 0);
5605 if (TREE_CODE (format_num_expr) != INTEGER_CST
5606 || TREE_INT_CST_HIGH (format_num_expr) != 0)
5609 format_num = TREE_INT_CST_LOW (format_num_expr);
5611 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5613 inner_args = TREE_CHAIN (inner_args), i++)
5614 if (i == format_num)
5616 check_function_arguments_recurse (callback, ctx,
5617 TREE_VALUE (inner_args),
5619 found_format_arg = true;
5624 /* If we found a format_arg attribute and did a recursive check,
5625 we are done with checking this argument. Otherwise, we continue
5626 and this will be considered a non-literal. */
5627 if (found_format_arg)
5631 if (TREE_CODE (param) == COND_EXPR)
5633 /* Check both halves of the conditional expression. */
5634 check_function_arguments_recurse (callback, ctx,
5635 TREE_OPERAND (param, 1), param_num);
5636 check_function_arguments_recurse (callback, ctx,
5637 TREE_OPERAND (param, 2), param_num);
5641 (*callback) (ctx, param, param_num);
5644 /* Function to help qsort sort FIELD_DECLs by name order. */
5647 field_decl_cmp (const void *x_p, const void *y_p)
5649 const tree *const x = x_p;
5650 const tree *const y = y_p;
5651 if (DECL_NAME (*x) == DECL_NAME (*y))
5652 /* A nontype is "greater" than a type. */
5653 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5654 if (DECL_NAME (*x) == NULL_TREE)
5656 if (DECL_NAME (*y) == NULL_TREE)
5658 if (DECL_NAME (*x) < DECL_NAME (*y))
5664 gt_pointer_operator new_value;
5668 /* This routine compares two fields like field_decl_cmp but using the
5669 pointer operator in resort_data. */
5672 resort_field_decl_cmp (const void *x_p, const void *y_p)
5674 const tree *const x = x_p;
5675 const tree *const y = y_p;
5677 if (DECL_NAME (*x) == DECL_NAME (*y))
5678 /* A nontype is "greater" than a type. */
5679 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5680 if (DECL_NAME (*x) == NULL_TREE)
5682 if (DECL_NAME (*y) == NULL_TREE)
5685 tree d1 = DECL_NAME (*x);
5686 tree d2 = DECL_NAME (*y);
5687 resort_data.new_value (&d1, resort_data.cookie);
5688 resort_data.new_value (&d2, resort_data.cookie);
5695 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5698 resort_sorted_fields (void *obj,
5699 void *orig_obj ATTRIBUTE_UNUSED ,
5700 gt_pointer_operator new_value,
5703 struct sorted_fields_type *sf = obj;
5704 resort_data.new_value = new_value;
5705 resort_data.cookie = cookie;
5706 qsort (&sf->elts[0], sf->len, sizeof (tree),
5707 resort_field_decl_cmp);
5710 /* Used by estimate_num_insns. Estimate number of instructions seen
5711 by given statement. */
5713 c_estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
5718 if (TYPE_P (x) || DECL_P (x))
5723 /* Assume that constants and references counts nothing. These should
5724 be majorized by amount of operations among them we count later
5725 and are common target of CSE and similar optimizations. */
5726 if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
5727 || TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
5729 switch (TREE_CODE (x))
5731 /* Recognize assignments of large structures and constructors of
5738 size = int_size_in_bytes (TREE_TYPE (x));
5740 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
5743 *count += ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
5748 tree decl = get_callee_fndecl (x);
5750 if (decl && DECL_BUILT_IN (decl))
5751 switch (DECL_FUNCTION_CODE (decl))
5753 case BUILT_IN_CONSTANT_P:
5756 case BUILT_IN_EXPECT:
5764 /* Few special cases of expensive operations. This is usefull
5765 to avoid inlining on functions having too many of these. */
5766 case TRUNC_DIV_EXPR:
5768 case FLOOR_DIV_EXPR:
5769 case ROUND_DIV_EXPR:
5770 case TRUNC_MOD_EXPR:
5772 case FLOOR_MOD_EXPR:
5773 case ROUND_MOD_EXPR:
5777 /* Various containers that will produce no code themselves. */
5784 case IDENTIFIER_NODE:
5785 case PLACEHOLDER_EXPR:
5786 case WITH_CLEANUP_EXPR:
5787 case CLEANUP_POINT_EXPR:
5789 case VIEW_CONVERT_EXPR:
5795 case TRY_CATCH_EXPR:
5796 case TRY_FINALLY_EXPR:
5799 case LABELED_BLOCK_EXPR:
5800 case EXIT_BLOCK_EXPR:
5801 case EXPR_WITH_FILE_LOCATION:
5818 /* Do not account static initializers. */
5819 if (TREE_STATIC (TREE_OPERAND (x, 0)))
5828 /* Estimate number of instructions that will be created by expanding the body. */
5830 c_estimate_num_insns (tree decl)
5833 walk_tree_without_duplicates (&DECL_SAVED_TREE (decl), c_estimate_num_insns_1, &num);
5837 /* Used by c_decl_uninit to find where expressions like x = x + 1; */
5840 c_decl_uninit_1 (tree *t, int *walk_sub_trees, void *x)
5842 /* If x = EXP(&x)EXP, then do not warn about the use of x. */
5843 if (TREE_CODE (*t) == ADDR_EXPR && TREE_OPERAND (*t, 0) == x)
5845 *walk_sub_trees = 0;
5853 /* Find out if a variable is uninitialized based on DECL_INITIAL. */
5856 c_decl_uninit (tree t)
5858 /* int x = x; is GCC extension to turn off this warning, only if warn_init_self is zero. */
5859 if (DECL_INITIAL (t) == t)
5860 return warn_init_self ? true : false;
5862 /* Walk the trees looking for the variable itself. */
5863 if (walk_tree_without_duplicates (&DECL_INITIAL (t), c_decl_uninit_1, t))
5868 /* Issue the error given by MSGID, indicating that it occurred before
5869 TOKEN, which had the associated VALUE. */
5872 c_parse_error (const char *msgid, enum cpp_ttype token, tree value)
5874 const char *string = _(msgid);
5876 if (token == CPP_EOF)
5877 error ("%s at end of input", string);
5878 else if (token == CPP_CHAR || token == CPP_WCHAR)
5880 unsigned int val = TREE_INT_CST_LOW (value);
5881 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5882 if (val <= UCHAR_MAX && ISGRAPH (val))
5883 error ("%s before %s'%c'", string, ell, val);
5885 error ("%s before %s'\\x%x'", string, ell, val);
5887 else if (token == CPP_STRING
5888 || token == CPP_WSTRING)
5889 error ("%s before string constant", string);
5890 else if (token == CPP_NUMBER)
5891 error ("%s before numeric constant", string);
5892 else if (token == CPP_NAME)
5893 error ("%s before \"%s\"", string, IDENTIFIER_POINTER (value));
5894 else if (token < N_TTYPES)
5895 error ("%s before '%s' token", string, cpp_type2name (token));
5897 error ("%s", string);
5900 #include "gt-c-common.h"