1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
46 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
48 /* We let tm.h override the types used here, to handle trivial differences
49 such as the choice of unsigned int or long unsigned int for size_t.
50 When machines start needing nontrivial differences in the size type,
51 it would be best to do something here to figure out automatically
52 from other information what type to use. */
55 #define SIZE_TYPE "long unsigned int"
59 #define WCHAR_TYPE "int"
62 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
63 #define MODIFIED_WCHAR_TYPE \
64 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
67 #define PTRDIFF_TYPE "long int"
71 #define WINT_TYPE "unsigned int"
75 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
77 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
85 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
86 ? "long unsigned int" \
87 : "long long unsigned int"))
90 /* The following symbols are subsumed in the c_global_trees array, and
91 listed here individually for documentation purposes.
93 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
95 tree short_integer_type_node;
96 tree long_integer_type_node;
97 tree long_long_integer_type_node;
99 tree short_unsigned_type_node;
100 tree long_unsigned_type_node;
101 tree long_long_unsigned_type_node;
103 tree truthvalue_type_node;
104 tree truthvalue_false_node;
105 tree truthvalue_true_node;
107 tree ptrdiff_type_node;
109 tree unsigned_char_type_node;
110 tree signed_char_type_node;
111 tree wchar_type_node;
112 tree signed_wchar_type_node;
113 tree unsigned_wchar_type_node;
115 tree float_type_node;
116 tree double_type_node;
117 tree long_double_type_node;
119 tree complex_integer_type_node;
120 tree complex_float_type_node;
121 tree complex_double_type_node;
122 tree complex_long_double_type_node;
124 tree intQI_type_node;
125 tree intHI_type_node;
126 tree intSI_type_node;
127 tree intDI_type_node;
128 tree intTI_type_node;
130 tree unsigned_intQI_type_node;
131 tree unsigned_intHI_type_node;
132 tree unsigned_intSI_type_node;
133 tree unsigned_intDI_type_node;
134 tree unsigned_intTI_type_node;
136 tree widest_integer_literal_type_node;
137 tree widest_unsigned_literal_type_node;
139 Nodes for types `void *' and `const void *'.
141 tree ptr_type_node, const_ptr_type_node;
143 Nodes for types `char *' and `const char *'.
145 tree string_type_node, const_string_type_node;
147 Type `char[SOMENUMBER]'.
148 Used when an array of char is needed and the size is irrelevant.
150 tree char_array_type_node;
152 Type `int[SOMENUMBER]' or something like it.
153 Used when an array of int needed and the size is irrelevant.
155 tree int_array_type_node;
157 Type `wchar_t[SOMENUMBER]' or something like it.
158 Used when a wide string literal is created.
160 tree wchar_array_type_node;
162 Type `int ()' -- used for implicit declaration of functions.
164 tree default_function_type;
166 A VOID_TYPE node, packaged in a TREE_LIST.
170 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
171 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
172 VAR_DECLS, but C++ does.)
174 tree function_name_decl_node;
175 tree pretty_function_name_decl_node;
176 tree c99_function_name_decl_node;
178 Stack of nested function name VAR_DECLs.
180 tree saved_function_name_decls;
184 tree c_global_trees
[CTI_MAX
];
186 /* TRUE if a code represents a statement. The front end init
187 langhook should take care of initialization of this array. */
189 bool statement_code_p
[MAX_TREE_CODES
];
191 /* Switches common to the C front ends. */
193 /* Nonzero if prepreprocessing only. */
195 int flag_preprocess_only
;
197 /* Nonzero means don't output line number information. */
199 char flag_no_line_commands
;
201 /* Nonzero causes -E output not to be done, but directives such as
202 #define that have side effects are still obeyed. */
206 /* Nonzero means dump macros in some fashion. */
208 char flag_dump_macros
;
210 /* Nonzero means pass #include lines through to the output. */
212 char flag_dump_includes
;
214 /* The file name to which we should write a precompiled header, or
215 NULL if no header will be written in this compile. */
217 const char *pch_file
;
219 /* Nonzero if an ISO standard was selected. It rejects macros in the
223 /* Nonzero if -undef was given. It suppresses target built-in macros
227 /* Nonzero means don't recognize the non-ANSI builtin functions. */
231 /* Nonzero means don't recognize the non-ANSI builtin functions.
234 int flag_no_nonansi_builtin
;
236 /* Nonzero means give `double' the same size as `float'. */
238 int flag_short_double
;
240 /* Nonzero means give `wchar_t' the same size as `short'. */
242 int flag_short_wchar
;
244 /* Nonzero means allow Microsoft extensions without warnings or errors. */
245 int flag_ms_extensions
;
247 /* Nonzero means don't recognize the keyword `asm'. */
251 /* Nonzero means give string constants the type `const char *', as mandated
254 int flag_const_strings
;
256 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
258 int flag_signed_bitfields
= 1;
259 int explicit_flag_signed_bitfields
;
261 /* Nonzero means warn about pointer casts that can drop a type qualifier
262 from the pointer target type. */
266 /* Warn about functions which might be candidates for format attributes. */
268 int warn_missing_format_attribute
;
270 /* Nonzero means warn about sizeof(function) or addition/subtraction
271 of function pointers. */
273 int warn_pointer_arith
;
275 /* Nonzero means warn for any global function def
276 without separate previous prototype decl. */
278 int warn_missing_prototypes
;
280 /* Warn if adding () is suggested. */
282 int warn_parentheses
;
284 /* Warn if initializer is not completely bracketed. */
286 int warn_missing_braces
;
288 /* Warn about comparison of signed and unsigned values.
289 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified
290 (in which case -Wextra gets to decide). */
292 int warn_sign_compare
= -1;
294 /* Nonzero means warn about usage of long long when `-pedantic'. */
296 int warn_long_long
= 1;
298 /* Nonzero means warn about deprecated conversion from string constant to
301 int warn_write_strings
;
303 /* Nonzero means warn about multiple (redundant) decls for the same single
304 variable or function. */
306 int warn_redundant_decls
;
308 /* Warn about testing equality of floating point numbers. */
310 int warn_float_equal
;
312 /* Warn about a subscript that has type char. */
314 int warn_char_subscripts
;
316 /* Warn if a type conversion is done that might have confusing results. */
320 /* Warn about #pragma directives that are not recognized. */
322 int warn_unknown_pragmas
; /* Tri state variable. */
324 /* Warn about format/argument anomalies in calls to formatted I/O functions
325 (*printf, *scanf, strftime, strfmon, etc.). */
329 /* Warn about Y2K problems with strftime formats. */
333 /* Warn about excess arguments to formats. */
335 int warn_format_extra_args
;
337 /* Warn about zero-length formats. */
339 int warn_format_zero_length
;
341 /* Warn about non-literal format arguments. */
343 int warn_format_nonliteral
;
345 /* Warn about possible security problems with calls to format functions. */
347 int warn_format_security
;
349 /* Zero means that faster, ...NonNil variants of objc_msgSend...
350 calls will be used in ObjC; passing nil receivers to such calls
351 will most likely result in crashes. */
352 int flag_nil_receivers
= 1;
354 /* Nonzero means that we will allow new ObjC exception syntax (@throw,
355 @try, etc.) in source code. */
356 int flag_objc_exceptions
= 0;
358 /* Nonzero means that code generation will be altered to support
359 "zero-link" execution. This currently affects ObjC only, but may
360 affect other languages in the future. */
361 int flag_zero_link
= 0;
363 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
364 unit. It will inform the ObjC runtime that class definition(s) herein
365 contained are to replace one(s) previously loaded. */
366 int flag_replace_objc_classes
= 0;
368 /* C/ObjC language option variables. */
371 /* Nonzero means message about use of implicit function declarations;
372 1 means warning; 2 means error. */
374 int mesg_implicit_function_declaration
= -1;
376 /* Nonzero means allow type mismatches in conditional expressions;
377 just make their values `void'. */
379 int flag_cond_mismatch
;
381 /* Nonzero means enable C89 Amendment 1 features. */
385 /* Nonzero means use the ISO C99 dialect of C. */
389 /* Nonzero means that we have builtin functions, and main is an int. */
393 /* Nonzero means warn when casting a function call to a type that does
394 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
395 when there is no previous declaration of sqrt or malloc. */
397 int warn_bad_function_cast
;
399 /* Warn about traditional constructs whose meanings changed in ANSI C. */
401 int warn_traditional
;
403 /* Nonzero means warn for a declaration found after a statement. */
405 int warn_declaration_after_statement
;
407 /* Nonzero means warn for non-prototype function decls
408 or non-prototyped defs without previous prototype. */
410 int warn_strict_prototypes
;
412 /* Nonzero means warn for any global function def
413 without separate previous decl. */
415 int warn_missing_declarations
;
417 /* Nonzero means warn about declarations of objects not at
418 file-scope level and about *all* declarations of functions (whether
419 or static) not at file-scope level. Note that we exclude
420 implicit function declarations. To get warnings about those, use
423 int warn_nested_externs
;
425 /* Warn if main is suspicious. */
429 /* Nonzero means warn about possible violations of sequence point rules. */
431 int warn_sequence_point
;
433 /* Nonzero means warn about uninitialized variable when it is initialized with itself.
434 For example: int i = i;, GCC will not warn about this when warn_init_self is nonzero. */
438 /* Nonzero means to warn about compile-time division by zero. */
439 int warn_div_by_zero
= 1;
441 /* Nonzero means warn about use of implicit int. */
443 int warn_implicit_int
;
445 /* Warn about NULL being passed to argument slots marked as requiring
450 /* Warn about old-style parameter declaration. */
452 int warn_old_style_definition
;
455 /* ObjC language option variables. */
458 /* Open and close the file for outputting class declarations, if
461 int flag_gen_declaration
;
463 /* Generate code for GNU or NeXT runtime environment. */
465 #ifdef NEXT_OBJC_RUNTIME
466 int flag_next_runtime
= 1;
468 int flag_next_runtime
= 0;
471 /* Tells the compiler that this is a special run. Do not perform any
472 compiling, instead we are to test some platform dependent features
473 and output a C header file with appropriate definitions. */
475 int print_struct_values
;
477 /* ???. Undocumented. */
479 const char *constant_string_class_name
;
481 /* Warn if multiple methods are seen for the same selector, but with
482 different argument types. Performs the check on the whole selector
483 table at the end of compilation. */
487 /* Warn if a @selector() is found, and no method with that selector
488 has been previously declared. The check is done on each
489 @selector() as soon as it is found - so it warns about forward
492 int warn_undeclared_selector
;
494 /* Warn if methods required by a protocol are not implemented in the
495 class adopting it. When turned off, methods inherited to that
496 class are also considered implemented. */
498 int warn_protocol
= 1;
501 /* C++ language option variables. */
504 /* Nonzero means don't recognize any extension keywords. */
506 int flag_no_gnu_keywords
;
508 /* Nonzero means do emit exported implementations of functions even if
509 they can be inlined. */
511 int flag_implement_inlines
= 1;
513 /* Nonzero means that implicit instantiations will be emitted if needed. */
515 int flag_implicit_templates
= 1;
517 /* Nonzero means that implicit instantiations of inline templates will be
518 emitted if needed, even if instantiations of non-inline templates
521 int flag_implicit_inline_templates
= 1;
523 /* Nonzero means generate separate instantiation control files and
524 juggle them at link time. */
526 int flag_use_repository
;
528 /* Nonzero if we want to issue diagnostics that the standard says are not
531 int flag_optional_diags
= 1;
533 /* Nonzero means we should attempt to elide constructors when possible. */
535 int flag_elide_constructors
= 1;
537 /* Nonzero means that member functions defined in class scope are
538 inline by default. */
540 int flag_default_inline
= 1;
542 /* Controls whether compiler generates 'type descriptor' that give
543 run-time type information. */
547 /* Nonzero if we want to conserve space in the .o files. We do this
548 by putting uninitialized data and runtime initialized data into
549 .common instead of .data at the expense of not flagging multiple
552 int flag_conserve_space
;
554 /* Nonzero if we want to obey access control semantics. */
556 int flag_access_control
= 1;
558 /* Nonzero if we want to check the return value of new and avoid calling
559 constructors if it is a null pointer. */
563 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
564 initialization variables.
565 0: Old rules, set by -fno-for-scope.
566 2: New ISO rules, set by -ffor-scope.
567 1: Try to implement new ISO rules, but with backup compatibility
568 (and warnings). This is the default, for now. */
570 int flag_new_for_scope
= 1;
572 /* Nonzero if we want to emit defined symbols with common-like linkage as
573 weak symbols where possible, in order to conform to C++ semantics.
574 Otherwise, emit them as local symbols. */
578 /* 0 means we want the preprocessor to not emit line directives for
579 the current working directory. 1 means we want it to do it. -1
580 means we should decide depending on whether debugging information
581 is being emitted or not. */
583 int flag_working_directory
= -1;
585 /* Nonzero to use __cxa_atexit, rather than atexit, to register
586 destructors for local statics and global objects. */
588 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
590 /* Nonzero means make the default pedwarns warnings instead of errors.
591 The value of this flag is ignored if -pedantic is specified. */
595 /* Nonzero means to implement standard semantics for exception
596 specifications, calling unexpected if an exception is thrown that
597 doesn't match the specification. Zero means to treat them as
598 assertions and optimize accordingly, but not check them. */
600 int flag_enforce_eh_specs
= 1;
602 /* Nonzero means warn about things that will change when compiling
603 with an ABI-compliant compiler. */
607 /* Nonzero means warn about invalid uses of offsetof. */
609 int warn_invalid_offsetof
= 1;
611 /* Nonzero means warn about implicit declarations. */
613 int warn_implicit
= 1;
615 /* Nonzero means warn when all ctors or dtors are private, and the class
618 int warn_ctor_dtor_privacy
= 0;
620 /* Nonzero means warn in function declared in derived class has the
621 same name as a virtual in the base class, but fails to match the
622 type signature of any virtual function in the base class. */
624 int warn_overloaded_virtual
;
626 /* Nonzero means warn when declaring a class that has a non virtual
627 destructor, when it really ought to have a virtual one. */
631 /* Nonzero means warn when the compiler will reorder code. */
635 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
639 /* Nonzero means warn when we convert a pointer to member function
640 into a pointer to (void or function). */
642 int warn_pmf2ptr
= 1;
644 /* Nonzero means warn about violation of some Effective C++ style rules. */
648 /* Nonzero means warn where overload resolution chooses a promotion from
649 unsigned to signed over a conversion to an unsigned of the same size. */
653 /* Nonzero means warn when an old-style cast is used. */
655 int warn_old_style_cast
;
657 /* Nonzero means warn when non-templatized friend functions are
658 declared within a template */
660 int warn_nontemplate_friend
= 1;
662 /* Nonzero means complain about deprecated features. */
664 int warn_deprecated
= 1;
666 /* Maximum template instantiation depth. This limit is rather
667 arbitrary, but it exists to limit the time it takes to notice
668 infinite template instantiations. */
670 int max_tinst_depth
= 500;
674 /* The elements of `ridpointers' are identifier nodes for the reserved
675 type names and storage classes. It is indexed by a RID_... value. */
678 tree (*make_fname_decl
) (tree
, int);
680 /* If non-NULL, the address of a language-specific function that takes
681 any action required right before expand_function_end is called. */
682 void (*lang_expand_function_end
) (void);
684 /* Nonzero means the expression being parsed will never be evaluated.
685 This is a count, since unevaluated expressions can nest. */
688 /* Information about how a function name is generated. */
691 tree
*const decl
; /* pointer to the VAR_DECL. */
692 const unsigned rid
; /* RID number for the identifier. */
693 const int pretty
; /* How pretty is it? */
696 /* The three ways of getting then name of the current function. */
698 const struct fname_var_t fname_vars
[] =
700 /* C99 compliant __func__, must be first. */
701 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
702 /* GCC __FUNCTION__ compliant. */
703 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
704 /* GCC __PRETTY_FUNCTION__ compliant. */
705 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
709 static int constant_fits_type_p (tree
, tree
);
711 /* Keep a stack of if statements. We record the number of compound
712 statements seen up to the if keyword, as well as the line number
713 and file of the if. If a potentially ambiguous else is seen, that
714 fact is recorded; the warning is issued when we can be sure that
715 the enclosing if statement does not have an else branch. */
724 static if_elt
*if_stack
;
726 /* Amount of space in the if statement stack. */
727 static int if_stack_space
= 0;
730 static int if_stack_pointer
= 0;
732 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
733 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
734 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
735 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
736 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
737 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
739 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
740 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
741 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
742 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
744 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
745 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
746 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
747 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
748 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
749 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
750 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
751 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
753 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
755 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
757 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
758 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
760 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
761 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
763 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
765 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
766 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
767 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
768 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
771 static void check_function_nonnull (tree
, tree
);
772 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
773 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
774 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
775 static int resort_field_decl_cmp (const void *, const void *);
777 /* Table of machine-independent attributes common to all C-like languages. */
778 const struct attribute_spec c_common_attribute_table
[] =
780 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
781 { "packed", 0, 0, false, false, false,
782 handle_packed_attribute
},
783 { "nocommon", 0, 0, true, false, false,
784 handle_nocommon_attribute
},
785 { "common", 0, 0, true, false, false,
786 handle_common_attribute
},
787 /* FIXME: logically, noreturn attributes should be listed as
788 "false, true, true" and apply to function types. But implementing this
789 would require all the places in the compiler that use TREE_THIS_VOLATILE
790 on a decl to identify non-returning functions to be located and fixed
791 to check the function type instead. */
792 { "noreturn", 0, 0, true, false, false,
793 handle_noreturn_attribute
},
794 { "volatile", 0, 0, true, false, false,
795 handle_noreturn_attribute
},
796 { "noinline", 0, 0, true, false, false,
797 handle_noinline_attribute
},
798 { "always_inline", 0, 0, true, false, false,
799 handle_always_inline_attribute
},
800 { "used", 0, 0, true, false, false,
801 handle_used_attribute
},
802 { "unused", 0, 0, false, false, false,
803 handle_unused_attribute
},
804 /* The same comments as for noreturn attributes apply to const ones. */
805 { "const", 0, 0, true, false, false,
806 handle_const_attribute
},
807 { "transparent_union", 0, 0, false, false, false,
808 handle_transparent_union_attribute
},
809 { "constructor", 0, 0, true, false, false,
810 handle_constructor_attribute
},
811 { "destructor", 0, 0, true, false, false,
812 handle_destructor_attribute
},
813 { "mode", 1, 1, false, true, false,
814 handle_mode_attribute
},
815 { "section", 1, 1, true, false, false,
816 handle_section_attribute
},
817 { "aligned", 0, 1, false, false, false,
818 handle_aligned_attribute
},
819 { "weak", 0, 0, true, false, false,
820 handle_weak_attribute
},
821 { "alias", 1, 1, true, false, false,
822 handle_alias_attribute
},
823 { "no_instrument_function", 0, 0, true, false, false,
824 handle_no_instrument_function_attribute
},
825 { "malloc", 0, 0, true, false, false,
826 handle_malloc_attribute
},
827 { "no_stack_limit", 0, 0, true, false, false,
828 handle_no_limit_stack_attribute
},
829 { "pure", 0, 0, true, false, false,
830 handle_pure_attribute
},
831 { "deprecated", 0, 0, false, false, false,
832 handle_deprecated_attribute
},
833 { "vector_size", 1, 1, false, true, false,
834 handle_vector_size_attribute
},
835 { "visibility", 1, 1, true, false, false,
836 handle_visibility_attribute
},
837 { "tls_model", 1, 1, true, false, false,
838 handle_tls_model_attribute
},
839 { "nonnull", 0, -1, false, true, true,
840 handle_nonnull_attribute
},
841 { "nothrow", 0, 0, true, false, false,
842 handle_nothrow_attribute
},
843 { "may_alias", 0, 0, false, true, false, NULL
},
844 { "cleanup", 1, 1, true, false, false,
845 handle_cleanup_attribute
},
846 { "warn_unused_result", 0, 0, false, true, true,
847 handle_warn_unused_result_attribute
},
848 { NULL
, 0, 0, false, false, false, NULL
}
851 /* Give the specifications for the format attributes, used by C and all
854 const struct attribute_spec c_common_format_attribute_table
[] =
856 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
857 { "format", 3, 3, false, true, true,
858 handle_format_attribute
},
859 { "format_arg", 1, 1, false, true, true,
860 handle_format_arg_attribute
},
861 { NULL
, 0, 0, false, false, false, NULL
}
864 /* Record the start of an if-then, and record the start of it
865 for ambiguous else detection.
867 COND is the condition for the if-then statement.
869 IF_STMT is the statement node that has already been created for
870 this if-then statement. It is created before parsing the
871 condition to keep line number information accurate. */
874 c_expand_start_cond (tree cond
, int compstmt_count
, tree if_stmt
)
876 /* Make sure there is enough space on the stack. */
877 if (if_stack_space
== 0)
880 if_stack
= xmalloc (10 * sizeof (if_elt
));
882 else if (if_stack_space
== if_stack_pointer
)
884 if_stack_space
+= 10;
885 if_stack
= xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
888 IF_COND (if_stmt
) = cond
;
891 /* Record this if statement. */
892 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
893 if_stack
[if_stack_pointer
].locus
= input_location
;
894 if_stack
[if_stack_pointer
].needs_warning
= 0;
895 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
899 /* Called after the then-clause for an if-statement is processed. */
904 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
905 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
908 /* Record the end of an if-then. Optionally warn if a nested
909 if statement had an ambiguous else clause. */
912 c_expand_end_cond (void)
915 if (if_stack
[if_stack_pointer
].needs_warning
)
916 warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
917 &if_stack
[if_stack_pointer
].locus
);
918 last_expr_type
= NULL_TREE
;
921 /* Called between the then-clause and the else-clause
922 of an if-then-else. */
925 c_expand_start_else (void)
927 /* An ambiguous else warning must be generated for the enclosing if
928 statement, unless we see an else branch for that one, too. */
930 && if_stack_pointer
> 1
931 && (if_stack
[if_stack_pointer
- 1].compstmt_count
932 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
933 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
935 /* Even if a nested if statement had an else branch, it can't be
936 ambiguous if this one also has an else. So don't warn in that
937 case. Also don't warn for any if statements nested in this else. */
938 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
939 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
942 /* Called after the else-clause for an if-statement is processed. */
947 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
948 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
951 /* Begin an if-statement. Returns a newly created IF_STMT if
954 Unlike the C++ front-end, we do not call add_stmt here; it is
955 probably safe to do so, but I am not very familiar with this
956 code so I am being extra careful not to change its behavior
957 beyond what is strictly necessary for correctness. */
960 c_begin_if_stmt (void)
963 r
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
967 /* Begin a while statement. Returns a newly created WHILE_STMT if
970 Unlike the C++ front-end, we do not call add_stmt here; it is
971 probably safe to do so, but I am not very familiar with this
972 code so I am being extra careful not to change its behavior
973 beyond what is strictly necessary for correctness. */
976 c_begin_while_stmt (void)
979 r
= build_stmt (WHILE_STMT
, NULL_TREE
, NULL_TREE
);
984 c_finish_while_stmt_cond (tree cond
, tree while_stmt
)
986 WHILE_COND (while_stmt
) = cond
;
989 /* Push current bindings for the function name VAR_DECLS. */
992 start_fname_decls (void)
995 tree saved
= NULL_TREE
;
997 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
999 tree decl
= *fname_vars
[ix
].decl
;
1003 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
1004 *fname_vars
[ix
].decl
= NULL_TREE
;
1007 if (saved
|| saved_function_name_decls
)
1008 /* Normally they'll have been NULL, so only push if we've got a
1009 stack, or they are non-NULL. */
1010 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
1011 saved_function_name_decls
);
1014 /* Finish up the current bindings, adding them into the
1015 current function's statement tree. This is done by wrapping the
1016 function's body in a COMPOUND_STMT containing these decls too. This
1017 must be done _before_ finish_stmt_tree is called. If there is no
1018 current function, we must be at file scope and no statements are
1019 involved. Pop the previous bindings. */
1022 finish_fname_decls (void)
1025 tree body
= NULL_TREE
;
1026 tree stack
= saved_function_name_decls
;
1028 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
1029 body
= chainon (TREE_VALUE (stack
), body
);
1033 /* They were called into existence, so add to statement tree. Add
1034 the DECL_STMTs inside the outermost scope. */
1035 tree
*p
= &DECL_SAVED_TREE (current_function_decl
);
1036 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1037 while (TREE_CODE (*p
) != COMPOUND_STMT
)
1039 if (TREE_CODE (*p
) == EXPR_STMT
)
1040 p
= &TREE_CHAIN (*p
);
1042 p
= &TREE_OPERAND(*p
, 0);
1045 p
= &COMPOUND_BODY (*p
);
1046 if (TREE_CODE (*p
) == SCOPE_STMT
)
1047 p
= &TREE_CHAIN (*p
);
1049 body
= chainon (body
, *p
);
1053 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1054 *fname_vars
[ix
].decl
= NULL_TREE
;
1058 /* We had saved values, restore them. */
1061 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
1063 tree decl
= TREE_PURPOSE (saved
);
1064 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
1066 *fname_vars
[ix
].decl
= decl
;
1068 stack
= TREE_CHAIN (stack
);
1070 saved_function_name_decls
= stack
;
1073 /* Return the text name of the current function, suitably prettified
1077 fname_as_string (int pretty_p
)
1079 const char *name
= "top level";
1088 if (current_function_decl
)
1089 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
1094 /* Return the VAR_DECL for a const char array naming the current
1095 function. If the VAR_DECL has not yet been created, create it
1096 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1097 ID is its name (unfortunately C and C++ hold the RID values of
1098 keywords in different places, so we can't derive RID from ID in
1099 this language independent code. */
1102 fname_decl (unsigned int rid
, tree id
)
1105 tree decl
= NULL_TREE
;
1107 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1108 if (fname_vars
[ix
].rid
== rid
)
1111 decl
= *fname_vars
[ix
].decl
;
1114 tree saved_last_tree
= last_tree
;
1115 /* If a tree is built here, it would normally have the lineno of
1116 the current statement. Later this tree will be moved to the
1117 beginning of the function and this line number will be wrong.
1118 To avoid this problem set the lineno to 0 here; that prevents
1119 it from appearing in the RTL. */
1120 int saved_lineno
= input_line
;
1123 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
1124 if (last_tree
!= saved_last_tree
)
1126 /* We created some statement tree for the decl. This belongs
1127 at the start of the function, so remove it now and reinsert
1128 it after the function is complete. */
1129 tree stmts
= TREE_CHAIN (saved_last_tree
);
1131 TREE_CHAIN (saved_last_tree
) = NULL_TREE
;
1132 last_tree
= saved_last_tree
;
1133 saved_function_name_decls
= tree_cons (decl
, stmts
,
1134 saved_function_name_decls
);
1136 *fname_vars
[ix
].decl
= decl
;
1137 input_line
= saved_lineno
;
1139 if (!ix
&& !current_function_decl
)
1140 pedwarn ("%J'%D' is not defined outside of function scope", decl
, decl
);
1145 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1148 fix_string_type (tree value
)
1150 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1151 const int wide_flag
= TREE_TYPE (value
) == wchar_array_type_node
;
1152 const int nchars_max
= flag_isoc99
? 4095 : 509;
1153 int length
= TREE_STRING_LENGTH (value
);
1156 /* Compute the number of elements, for the array type. */
1157 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
1159 if (pedantic
&& nchars
- 1 > nchars_max
&& !c_dialect_cxx ())
1160 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1161 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
1163 /* Create the array type for the string constant.
1164 -Wwrite-strings says make the string constant an array of const char
1165 so that copying it to a non-const pointer will get a warning.
1166 For C++, this is the standard behavior. */
1167 if (flag_const_strings
)
1170 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
1173 = build_array_type (elements
,
1174 build_index_type (build_int_2 (nchars
- 1, 0)));
1178 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
1179 build_index_type (build_int_2 (nchars
- 1, 0)));
1181 TREE_CONSTANT (value
) = 1;
1182 TREE_READONLY (value
) = 1;
1183 TREE_STATIC (value
) = 1;
1187 /* Print a warning if a constant expression had overflow in folding.
1188 Invoke this function on every expression that the language
1189 requires to be a constant expression.
1190 Note the ANSI C standard says it is erroneous for a
1191 constant expression to overflow. */
1194 constant_expression_warning (tree value
)
1196 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1197 || TREE_CODE (value
) == VECTOR_CST
1198 || TREE_CODE (value
) == COMPLEX_CST
)
1199 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
1200 pedwarn ("overflow in constant expression");
1203 /* Print a warning if an expression had overflow in folding.
1204 Invoke this function on every expression that
1205 (1) appears in the source code, and
1206 (2) might be a constant expression that overflowed, and
1207 (3) is not already checked by convert_and_check;
1208 however, do not invoke this function on operands of explicit casts. */
1211 overflow_warning (tree value
)
1213 if ((TREE_CODE (value
) == INTEGER_CST
1214 || (TREE_CODE (value
) == COMPLEX_CST
1215 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
1216 && TREE_OVERFLOW (value
))
1218 TREE_OVERFLOW (value
) = 0;
1219 if (skip_evaluation
== 0)
1220 warning ("integer overflow in expression");
1222 else if ((TREE_CODE (value
) == REAL_CST
1223 || (TREE_CODE (value
) == COMPLEX_CST
1224 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
1225 && TREE_OVERFLOW (value
))
1227 TREE_OVERFLOW (value
) = 0;
1228 if (skip_evaluation
== 0)
1229 warning ("floating point overflow in expression");
1231 else if (TREE_CODE (value
) == VECTOR_CST
&& TREE_OVERFLOW (value
))
1233 TREE_OVERFLOW (value
) = 0;
1234 if (skip_evaluation
== 0)
1235 warning ("vector overflow in expression");
1239 /* Print a warning if a large constant is truncated to unsigned,
1240 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1241 Invoke this function on every expression that might be implicitly
1242 converted to an unsigned type. */
1245 unsigned_conversion_warning (tree result
, tree operand
)
1247 tree type
= TREE_TYPE (result
);
1249 if (TREE_CODE (operand
) == INTEGER_CST
1250 && TREE_CODE (type
) == INTEGER_TYPE
1251 && TREE_UNSIGNED (type
)
1252 && skip_evaluation
== 0
1253 && !int_fits_type_p (operand
, type
))
1255 if (!int_fits_type_p (operand
, c_common_signed_type (type
)))
1256 /* This detects cases like converting -129 or 256 to unsigned char. */
1257 warning ("large integer implicitly truncated to unsigned type");
1258 else if (warn_conversion
)
1259 warning ("negative integer implicitly converted to unsigned type");
1263 /* Nonzero if constant C has a value that is permissible
1264 for type TYPE (an INTEGER_TYPE). */
1267 constant_fits_type_p (tree c
, tree type
)
1269 if (TREE_CODE (c
) == INTEGER_CST
)
1270 return int_fits_type_p (c
, type
);
1272 c
= convert (type
, c
);
1273 return !TREE_OVERFLOW (c
);
1276 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1277 Invoke this function on every expression that is converted implicitly,
1278 i.e. because of language rules and not because of an explicit cast. */
1281 convert_and_check (tree type
, tree expr
)
1283 tree t
= convert (type
, expr
);
1284 if (TREE_CODE (t
) == INTEGER_CST
)
1286 if (TREE_OVERFLOW (t
))
1288 TREE_OVERFLOW (t
) = 0;
1290 /* Do not diagnose overflow in a constant expression merely
1291 because a conversion overflowed. */
1292 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
1294 /* No warning for converting 0x80000000 to int. */
1295 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1296 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1297 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1298 /* If EXPR fits in the unsigned version of TYPE,
1299 don't warn unless pedantic. */
1301 || TREE_UNSIGNED (type
)
1302 || ! constant_fits_type_p (expr
,
1303 c_common_unsigned_type (type
)))
1304 && skip_evaluation
== 0)
1305 warning ("overflow in implicit constant conversion");
1308 unsigned_conversion_warning (t
, expr
);
1313 /* A node in a list that describes references to variables (EXPR), which are
1314 either read accesses if WRITER is zero, or write accesses, in which case
1315 WRITER is the parent of EXPR. */
1322 /* Used to implement a cache the results of a call to verify_tree. We only
1323 use this for SAVE_EXPRs. */
1326 struct tlist_cache
*next
;
1327 struct tlist
*cache_before_sp
;
1328 struct tlist
*cache_after_sp
;
1332 /* Obstack to use when allocating tlist structures, and corresponding
1334 static struct obstack tlist_obstack
;
1335 static char *tlist_firstobj
= 0;
1337 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1339 static struct tlist
*warned_ids
;
1340 /* SAVE_EXPRs need special treatment. We process them only once and then
1341 cache the results. */
1342 static struct tlist_cache
*save_expr_cache
;
1344 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
1345 static void merge_tlist (struct tlist
**, struct tlist
*, int);
1346 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
1347 static int warning_candidate_p (tree
);
1348 static void warn_for_collisions (struct tlist
*);
1349 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
1350 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
1351 static void verify_sequence_points (tree
);
1353 /* Create a new struct tlist and fill in its fields. */
1354 static struct tlist
*
1355 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1358 l
= obstack_alloc (&tlist_obstack
, sizeof *l
);
1365 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1366 is nonnull, we ignore any node we find which has a writer equal to it. */
1369 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1373 struct tlist
*next
= add
->next
;
1376 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
1377 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1382 /* Merge the nodes of ADD into TO. This merging process is done so that for
1383 each variable that already exists in TO, no new node is added; however if
1384 there is a write access recorded in ADD, and an occurrence on TO is only
1385 a read access, then the occurrence in TO will be modified to record the
1389 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1391 struct tlist
**end
= to
;
1394 end
= &(*end
)->next
;
1400 struct tlist
*next
= add
->next
;
1402 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1403 if (tmp2
->expr
== add
->expr
)
1407 tmp2
->writer
= add
->writer
;
1411 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1412 end
= &(*end
)->next
;
1419 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1420 references in list LIST conflict with it, excluding reads if ONLY writers
1424 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1429 /* Avoid duplicate warnings. */
1430 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1431 if (tmp
->expr
== written
)
1436 if (list
->expr
== written
1437 && list
->writer
!= writer
1438 && (! only_writes
|| list
->writer
))
1440 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1441 warning ("operation on `%s' may be undefined",
1442 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
1448 /* Given a list LIST of references to variables, find whether any of these
1449 can cause conflicts due to missing sequence points. */
1452 warn_for_collisions (struct tlist
*list
)
1456 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1459 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1463 /* Return nonzero if X is a tree that can be verified by the sequence point
1466 warning_candidate_p (tree x
)
1468 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1471 /* Walk the tree X, and record accesses to variables. If X is written by the
1472 parent tree, WRITER is the parent.
1473 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1474 expression or its only operand forces a sequence point, then everything up
1475 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1477 Once we return, we will have emitted warnings if any subexpression before
1478 such a sequence point could be undefined. On a higher level, however, the
1479 sequence point may not be relevant, and we'll merge the two lists.
1481 Example: (b++, a) + b;
1482 The call that processes the COMPOUND_EXPR will store the increment of B
1483 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1484 processes the PLUS_EXPR will need to merge the two lists so that
1485 eventually, all accesses end up on the same list (and we'll warn about the
1486 unordered subexpressions b++ and b.
1488 A note on merging. If we modify the former example so that our expression
1491 care must be taken not simply to add all three expressions into the final
1492 PNO_SP list. The function merge_tlist takes care of that by merging the
1493 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1494 way, so that no more than one access to B is recorded. */
1497 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
1500 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1501 enum tree_code code
;
1504 /* X may be NULL if it is the operand of an empty statement expression
1510 code
= TREE_CODE (x
);
1511 class = TREE_CODE_CLASS (code
);
1513 if (warning_candidate_p (x
))
1515 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1525 case TRUTH_ANDIF_EXPR
:
1526 case TRUTH_ORIF_EXPR
:
1527 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1528 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1529 warn_for_collisions (tmp_nosp
);
1530 merge_tlist (pbefore_sp
, tmp_before
, 0);
1531 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1532 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1533 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1537 tmp_before
= tmp_list2
= 0;
1538 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1539 warn_for_collisions (tmp_list2
);
1540 merge_tlist (pbefore_sp
, tmp_before
, 0);
1541 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1543 tmp_list3
= tmp_nosp
= 0;
1544 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1545 warn_for_collisions (tmp_nosp
);
1546 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1548 tmp_list3
= tmp_list2
= 0;
1549 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1550 warn_for_collisions (tmp_list2
);
1551 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1552 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1553 two first, to avoid warning for (a ? b++ : b++). */
1554 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1555 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1558 case PREDECREMENT_EXPR
:
1559 case PREINCREMENT_EXPR
:
1560 case POSTDECREMENT_EXPR
:
1561 case POSTINCREMENT_EXPR
:
1562 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1566 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1567 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1568 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1569 /* Expressions inside the LHS are not ordered wrt. the sequence points
1570 in the RHS. Example:
1572 Despite the fact that the modification of "a" is in the before_sp
1573 list (tmp_before), it conflicts with the use of "a" in the LHS.
1574 We can handle this by adding the contents of tmp_list3
1575 to those of tmp_before, and redoing the collision warnings for that
1577 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1578 warn_for_collisions (tmp_before
);
1579 /* Exclude the LHS itself here; we first have to merge it into the
1580 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1581 didn't exclude the LHS, we'd get it twice, once as a read and once
1583 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1584 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1586 merge_tlist (pbefore_sp
, tmp_before
, 0);
1587 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1588 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1589 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1593 /* We need to warn about conflicts among arguments and conflicts between
1594 args and the function address. Side effects of the function address,
1595 however, are not ordered by the sequence point of the call. */
1596 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1597 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1598 if (TREE_OPERAND (x
, 1))
1599 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1600 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1601 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1602 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1603 warn_for_collisions (tmp_before
);
1604 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1608 /* Scan all the list, e.g. indices of multi dimensional array. */
1611 tmp_before
= tmp_nosp
= 0;
1612 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1613 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1614 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1621 struct tlist_cache
*t
;
1622 for (t
= save_expr_cache
; t
; t
= t
->next
)
1628 t
= obstack_alloc (&tlist_obstack
, sizeof *t
);
1629 t
->next
= save_expr_cache
;
1631 save_expr_cache
= t
;
1633 tmp_before
= tmp_nosp
= 0;
1634 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1635 warn_for_collisions (tmp_nosp
);
1640 struct tlist
*t
= tmp_nosp
;
1642 merge_tlist (&tmp_list3
, t
, 0);
1644 t
->cache_before_sp
= tmp_before
;
1645 t
->cache_after_sp
= tmp_list3
;
1647 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1648 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1657 if (first_rtl_op (code
) == 0)
1659 x
= TREE_OPERAND (x
, 0);
1675 int max
= first_rtl_op (TREE_CODE (x
));
1676 for (lp
= 0; lp
< max
; lp
++)
1678 tmp_before
= tmp_nosp
= 0;
1679 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1680 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1681 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1688 /* Try to warn for undefined behavior in EXPR due to missing sequence
1692 verify_sequence_points (tree expr
)
1694 struct tlist
*before_sp
= 0, *after_sp
= 0;
1697 save_expr_cache
= 0;
1698 if (tlist_firstobj
== 0)
1700 gcc_obstack_init (&tlist_obstack
);
1701 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1704 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1705 warn_for_collisions (after_sp
);
1706 obstack_free (&tlist_obstack
, tlist_firstobj
);
1710 c_expand_expr_stmt (tree expr
)
1712 /* Do default conversion if safe and possibly important,
1713 in case within ({...}). */
1714 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1715 && (flag_isoc99
|| lvalue_p (expr
)))
1716 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1717 expr
= default_conversion (expr
);
1719 if (warn_sequence_point
)
1720 verify_sequence_points (expr
);
1722 if (TREE_TYPE (expr
) != error_mark_node
1723 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1724 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1725 error ("expression statement has incomplete type");
1727 last_expr_type
= TREE_TYPE (expr
);
1728 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1731 /* Validate the expression after `case' and apply default promotions. */
1734 check_case_value (tree value
)
1736 if (value
== NULL_TREE
)
1739 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1740 STRIP_TYPE_NOPS (value
);
1741 /* In C++, the following is allowed:
1744 switch (...) { case i: ... }
1746 So, we try to reduce the VALUE to a constant that way. */
1747 if (c_dialect_cxx ())
1749 value
= decl_constant_value (value
);
1750 STRIP_TYPE_NOPS (value
);
1751 value
= fold (value
);
1754 if (TREE_CODE (value
) != INTEGER_CST
1755 && value
!= error_mark_node
)
1757 error ("case label does not reduce to an integer constant");
1758 value
= error_mark_node
;
1761 /* Promote char or short to int. */
1762 value
= default_conversion (value
);
1764 constant_expression_warning (value
);
1769 /* Return an integer type with BITS bits of precision,
1770 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1773 c_common_type_for_size (unsigned int bits
, int unsignedp
)
1775 if (bits
== TYPE_PRECISION (integer_type_node
))
1776 return unsignedp
? unsigned_type_node
: integer_type_node
;
1778 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1779 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1781 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1782 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1784 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1785 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1787 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1788 return (unsignedp
? long_long_unsigned_type_node
1789 : long_long_integer_type_node
);
1791 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1792 return (unsignedp
? widest_unsigned_literal_type_node
1793 : widest_integer_literal_type_node
);
1795 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1796 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1798 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1799 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1801 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1802 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1804 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1805 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1810 /* Used for communication between c_common_type_for_mode and
1811 c_register_builtin_type. */
1812 static GTY(()) tree registered_builtin_types
;
1814 /* Return a data type that has machine mode MODE.
1815 If the mode is an integer,
1816 then UNSIGNEDP selects between signed and unsigned types. */
1819 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
1823 if (mode
== TYPE_MODE (integer_type_node
))
1824 return unsignedp
? unsigned_type_node
: integer_type_node
;
1826 if (mode
== TYPE_MODE (signed_char_type_node
))
1827 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1829 if (mode
== TYPE_MODE (short_integer_type_node
))
1830 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1832 if (mode
== TYPE_MODE (long_integer_type_node
))
1833 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1835 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1836 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1838 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1839 return unsignedp
? widest_unsigned_literal_type_node
1840 : widest_integer_literal_type_node
;
1843 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1846 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1849 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1852 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1854 #if HOST_BITS_PER_WIDE_INT >= 64
1855 if (mode
== TYPE_MODE (intTI_type_node
))
1856 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1859 if (mode
== TYPE_MODE (float_type_node
))
1860 return float_type_node
;
1862 if (mode
== TYPE_MODE (double_type_node
))
1863 return double_type_node
;
1865 if (mode
== TYPE_MODE (long_double_type_node
))
1866 return long_double_type_node
;
1868 if (mode
== TYPE_MODE (void_type_node
))
1869 return void_type_node
;
1871 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1872 return unsignedp
? make_unsigned_type (mode
) : make_signed_type (mode
);
1874 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1875 return unsignedp
? make_unsigned_type (mode
) : make_signed_type (mode
);
1877 if (VECTOR_MODE_P (mode
))
1879 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
1880 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
1881 if (inner_type
!= NULL_TREE
)
1882 return build_vector_type_for_mode (inner_type
, mode
);
1885 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1886 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
1887 return TREE_VALUE (t
);
1892 /* Return an unsigned type the same as TYPE in other respects. */
1894 c_common_unsigned_type (tree type
)
1896 tree type1
= TYPE_MAIN_VARIANT (type
);
1897 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1898 return unsigned_char_type_node
;
1899 if (type1
== integer_type_node
)
1900 return unsigned_type_node
;
1901 if (type1
== short_integer_type_node
)
1902 return short_unsigned_type_node
;
1903 if (type1
== long_integer_type_node
)
1904 return long_unsigned_type_node
;
1905 if (type1
== long_long_integer_type_node
)
1906 return long_long_unsigned_type_node
;
1907 if (type1
== widest_integer_literal_type_node
)
1908 return widest_unsigned_literal_type_node
;
1909 #if HOST_BITS_PER_WIDE_INT >= 64
1910 if (type1
== intTI_type_node
)
1911 return unsigned_intTI_type_node
;
1913 if (type1
== intDI_type_node
)
1914 return unsigned_intDI_type_node
;
1915 if (type1
== intSI_type_node
)
1916 return unsigned_intSI_type_node
;
1917 if (type1
== intHI_type_node
)
1918 return unsigned_intHI_type_node
;
1919 if (type1
== intQI_type_node
)
1920 return unsigned_intQI_type_node
;
1922 return c_common_signed_or_unsigned_type (1, type
);
1925 /* Return a signed type the same as TYPE in other respects. */
1928 c_common_signed_type (tree type
)
1930 tree type1
= TYPE_MAIN_VARIANT (type
);
1931 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1932 return signed_char_type_node
;
1933 if (type1
== unsigned_type_node
)
1934 return integer_type_node
;
1935 if (type1
== short_unsigned_type_node
)
1936 return short_integer_type_node
;
1937 if (type1
== long_unsigned_type_node
)
1938 return long_integer_type_node
;
1939 if (type1
== long_long_unsigned_type_node
)
1940 return long_long_integer_type_node
;
1941 if (type1
== widest_unsigned_literal_type_node
)
1942 return widest_integer_literal_type_node
;
1943 #if HOST_BITS_PER_WIDE_INT >= 64
1944 if (type1
== unsigned_intTI_type_node
)
1945 return intTI_type_node
;
1947 if (type1
== unsigned_intDI_type_node
)
1948 return intDI_type_node
;
1949 if (type1
== unsigned_intSI_type_node
)
1950 return intSI_type_node
;
1951 if (type1
== unsigned_intHI_type_node
)
1952 return intHI_type_node
;
1953 if (type1
== unsigned_intQI_type_node
)
1954 return intQI_type_node
;
1956 return c_common_signed_or_unsigned_type (0, type
);
1959 /* Return a type the same as TYPE except unsigned or
1960 signed according to UNSIGNEDP. */
1963 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
1965 if (! INTEGRAL_TYPE_P (type
)
1966 || TREE_UNSIGNED (type
) == unsignedp
)
1969 /* Must check the mode of the types, not the precision. Enumeral types
1970 in C++ have precision set to match their range, but may use a wider
1971 mode to match an ABI. If we change modes, we may wind up with bad
1974 if (TYPE_MODE (type
) == TYPE_MODE (signed_char_type_node
))
1975 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1976 if (TYPE_MODE (type
) == TYPE_MODE (integer_type_node
))
1977 return unsignedp
? unsigned_type_node
: integer_type_node
;
1978 if (TYPE_MODE (type
) == TYPE_MODE (short_integer_type_node
))
1979 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1980 if (TYPE_MODE (type
) == TYPE_MODE (long_integer_type_node
))
1981 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1982 if (TYPE_MODE (type
) == TYPE_MODE (long_long_integer_type_node
))
1983 return (unsignedp
? long_long_unsigned_type_node
1984 : long_long_integer_type_node
);
1985 if (TYPE_MODE (type
) == TYPE_MODE (widest_integer_literal_type_node
))
1986 return (unsignedp
? widest_unsigned_literal_type_node
1987 : widest_integer_literal_type_node
);
1989 #if HOST_BITS_PER_WIDE_INT >= 64
1990 if (TYPE_MODE (type
) == TYPE_MODE (intTI_type_node
))
1991 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1993 if (TYPE_MODE (type
) == TYPE_MODE (intDI_type_node
))
1994 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1995 if (TYPE_MODE (type
) == TYPE_MODE (intSI_type_node
))
1996 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1997 if (TYPE_MODE (type
) == TYPE_MODE (intHI_type_node
))
1998 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1999 if (TYPE_MODE (type
) == TYPE_MODE (intQI_type_node
))
2000 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2005 /* The C version of the register_builtin_type langhook. */
2008 c_register_builtin_type (tree type
, const char* name
)
2012 decl
= build_decl (TYPE_DECL
, get_identifier (name
), type
);
2013 DECL_ARTIFICIAL (decl
) = 1;
2014 if (!TYPE_NAME (type
))
2015 TYPE_NAME (type
) = decl
;
2018 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
2022 /* Return the minimum number of bits needed to represent VALUE in a
2023 signed or unsigned type, UNSIGNEDP says which. */
2026 min_precision (tree value
, int unsignedp
)
2030 /* If the value is negative, compute its negative minus 1. The latter
2031 adjustment is because the absolute value of the largest negative value
2032 is one larger than the largest positive value. This is equivalent to
2033 a bit-wise negation, so use that operation instead. */
2035 if (tree_int_cst_sgn (value
) < 0)
2036 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
2038 /* Return the number of bits needed, taking into account the fact
2039 that we need one more bit for a signed than unsigned type. */
2041 if (integer_zerop (value
))
2044 log
= tree_floor_log2 (value
);
2046 return log
+ 1 + ! unsignedp
;
2049 /* Print an error message for invalid operands to arith operation
2050 CODE. NOP_EXPR is used as a special case (see
2051 c_common_truthvalue_conversion). */
2054 binary_op_error (enum tree_code code
)
2061 error ("invalid truth-value expression");
2065 opname
= "+"; break;
2067 opname
= "-"; break;
2069 opname
= "*"; break;
2071 opname
= "max"; break;
2073 opname
= "min"; break;
2075 opname
= "=="; break;
2077 opname
= "!="; break;
2079 opname
= "<="; break;
2081 opname
= ">="; break;
2083 opname
= "<"; break;
2085 opname
= ">"; break;
2087 opname
= "<<"; break;
2089 opname
= ">>"; break;
2090 case TRUNC_MOD_EXPR
:
2091 case FLOOR_MOD_EXPR
:
2092 opname
= "%"; break;
2093 case TRUNC_DIV_EXPR
:
2094 case FLOOR_DIV_EXPR
:
2095 opname
= "/"; break;
2097 opname
= "&"; break;
2099 opname
= "|"; break;
2100 case TRUTH_ANDIF_EXPR
:
2101 opname
= "&&"; break;
2102 case TRUTH_ORIF_EXPR
:
2103 opname
= "||"; break;
2105 opname
= "^"; break;
2108 opname
= "rotate"; break;
2110 opname
= "unknown"; break;
2112 error ("invalid operands to binary %s", opname
);
2115 /* Subroutine of build_binary_op, used for comparison operations.
2116 See if the operands have both been converted from subword integer types
2117 and, if so, perhaps change them both back to their original type.
2118 This function is also responsible for converting the two operands
2119 to the proper common type for comparison.
2121 The arguments of this function are all pointers to local variables
2122 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2123 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2125 If this function returns nonzero, it means that the comparison has
2126 a constant value. What this function returns is an expression for
2130 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
2131 enum tree_code
*rescode_ptr
)
2134 tree op0
= *op0_ptr
;
2135 tree op1
= *op1_ptr
;
2136 int unsignedp0
, unsignedp1
;
2138 tree primop0
, primop1
;
2139 enum tree_code code
= *rescode_ptr
;
2141 /* Throw away any conversions to wider types
2142 already present in the operands. */
2144 primop0
= get_narrower (op0
, &unsignedp0
);
2145 primop1
= get_narrower (op1
, &unsignedp1
);
2147 /* Handle the case that OP0 does not *contain* a conversion
2148 but it *requires* conversion to FINAL_TYPE. */
2150 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2151 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
2152 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2153 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
2155 /* If one of the operands must be floated, we cannot optimize. */
2156 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2157 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2159 /* If first arg is constant, swap the args (changing operation
2160 so value is preserved), for canonicalization. Don't do this if
2161 the second arg is 0. */
2163 if (TREE_CONSTANT (primop0
)
2164 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
2167 int temi
= unsignedp0
;
2175 unsignedp0
= unsignedp1
;
2198 *rescode_ptr
= code
;
2201 /* If comparing an integer against a constant more bits wide,
2202 maybe we can deduce a value of 1 or 0 independent of the data.
2203 Or else truncate the constant now
2204 rather than extend the variable at run time.
2206 This is only interesting if the constant is the wider arg.
2207 Also, it is not safe if the constant is unsigned and the
2208 variable arg is signed, since in this case the variable
2209 would be sign-extended and then regarded as unsigned.
2210 Our technique fails in this case because the lowest/highest
2211 possible unsigned results don't follow naturally from the
2212 lowest/highest possible values of the variable operand.
2213 For just EQ_EXPR and NE_EXPR there is another technique that
2214 could be used: see if the constant can be faithfully represented
2215 in the other operand's type, by truncating it and reextending it
2216 and see if that preserves the constant's value. */
2218 if (!real1
&& !real2
2219 && TREE_CODE (primop1
) == INTEGER_CST
2220 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2222 int min_gt
, max_gt
, min_lt
, max_lt
;
2223 tree maxval
, minval
;
2224 /* 1 if comparison is nominally unsigned. */
2225 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
2228 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2229 TREE_TYPE (primop0
));
2231 /* In C, if TYPE is an enumeration, then we need to get its
2232 min/max values from its underlying integral type, not the
2233 enumerated type itself. In C++, TYPE_MAX_VALUE and
2234 TYPE_MIN_VALUE have already been set correctly on the
2235 enumeration type. */
2236 if (!c_dialect_cxx() && TREE_CODE (type
) == ENUMERAL_TYPE
)
2237 type
= c_common_type_for_size (TYPE_PRECISION (type
), unsignedp0
);
2239 maxval
= TYPE_MAX_VALUE (type
);
2240 minval
= TYPE_MIN_VALUE (type
);
2242 if (unsignedp
&& !unsignedp0
)
2243 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2245 if (TREE_TYPE (primop1
) != *restype_ptr
)
2246 primop1
= convert (*restype_ptr
, primop1
);
2247 if (type
!= *restype_ptr
)
2249 minval
= convert (*restype_ptr
, minval
);
2250 maxval
= convert (*restype_ptr
, maxval
);
2253 if (unsignedp
&& unsignedp0
)
2255 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2256 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2257 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2258 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2262 min_gt
= INT_CST_LT (primop1
, minval
);
2263 max_gt
= INT_CST_LT (primop1
, maxval
);
2264 min_lt
= INT_CST_LT (minval
, primop1
);
2265 max_lt
= INT_CST_LT (maxval
, primop1
);
2269 /* This used to be a switch, but Genix compiler can't handle that. */
2270 if (code
== NE_EXPR
)
2272 if (max_lt
|| min_gt
)
2273 val
= truthvalue_true_node
;
2275 else if (code
== EQ_EXPR
)
2277 if (max_lt
|| min_gt
)
2278 val
= truthvalue_false_node
;
2280 else if (code
== LT_EXPR
)
2283 val
= truthvalue_true_node
;
2285 val
= truthvalue_false_node
;
2287 else if (code
== GT_EXPR
)
2290 val
= truthvalue_true_node
;
2292 val
= truthvalue_false_node
;
2294 else if (code
== LE_EXPR
)
2297 val
= truthvalue_true_node
;
2299 val
= truthvalue_false_node
;
2301 else if (code
== GE_EXPR
)
2304 val
= truthvalue_true_node
;
2306 val
= truthvalue_false_node
;
2309 /* If primop0 was sign-extended and unsigned comparison specd,
2310 we did a signed comparison above using the signed type bounds.
2311 But the comparison we output must be unsigned.
2313 Also, for inequalities, VAL is no good; but if the signed
2314 comparison had *any* fixed result, it follows that the
2315 unsigned comparison just tests the sign in reverse
2316 (positive values are LE, negative ones GE).
2317 So we can generate an unsigned comparison
2318 against an extreme value of the signed type. */
2320 if (unsignedp
&& !unsignedp0
)
2327 primop1
= TYPE_MIN_VALUE (type
);
2333 primop1
= TYPE_MAX_VALUE (type
);
2340 type
= c_common_unsigned_type (type
);
2343 if (TREE_CODE (primop0
) != INTEGER_CST
)
2345 if (val
== truthvalue_false_node
)
2346 warning ("comparison is always false due to limited range of data type");
2347 if (val
== truthvalue_true_node
)
2348 warning ("comparison is always true due to limited range of data type");
2353 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2354 if (TREE_SIDE_EFFECTS (primop0
))
2355 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2359 /* Value is not predetermined, but do the comparison
2360 in the type of the operand that is not constant.
2361 TYPE is already properly set. */
2363 else if (real1
&& real2
2364 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2365 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2366 type
= TREE_TYPE (primop0
);
2368 /* If args' natural types are both narrower than nominal type
2369 and both extend in the same manner, compare them
2370 in the type of the wider arg.
2371 Otherwise must actually extend both to the nominal
2372 common type lest different ways of extending
2374 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2376 else if (unsignedp0
== unsignedp1
&& real1
== real2
2377 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2378 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2380 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2381 type
= c_common_signed_or_unsigned_type (unsignedp0
2382 || TREE_UNSIGNED (*restype_ptr
),
2384 /* Make sure shorter operand is extended the right way
2385 to match the longer operand. */
2387 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2388 TREE_TYPE (primop0
)),
2391 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2392 TREE_TYPE (primop1
)),
2397 /* Here we must do the comparison on the nominal type
2398 using the args exactly as we received them. */
2399 type
= *restype_ptr
;
2403 if (!real1
&& !real2
&& integer_zerop (primop1
)
2404 && TREE_UNSIGNED (*restype_ptr
))
2410 /* All unsigned values are >= 0, so we warn if extra warnings
2411 are requested. However, if OP0 is a constant that is
2412 >= 0, the signedness of the comparison isn't an issue,
2413 so suppress the warning. */
2414 if (extra_warnings
&& !in_system_header
2415 && ! (TREE_CODE (primop0
) == INTEGER_CST
2416 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2418 warning ("comparison of unsigned expression >= 0 is always true");
2419 value
= truthvalue_true_node
;
2423 if (extra_warnings
&& !in_system_header
2424 && ! (TREE_CODE (primop0
) == INTEGER_CST
2425 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2427 warning ("comparison of unsigned expression < 0 is always false");
2428 value
= truthvalue_false_node
;
2437 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2438 if (TREE_SIDE_EFFECTS (primop0
))
2439 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2446 *op0_ptr
= convert (type
, primop0
);
2447 *op1_ptr
= convert (type
, primop1
);
2449 *restype_ptr
= truthvalue_type_node
;
2454 /* Return a tree for the sum or difference (RESULTCODE says which)
2455 of pointer PTROP and integer INTOP. */
2458 pointer_int_sum (enum tree_code resultcode
, tree ptrop
, tree intop
)
2465 /* The result is a pointer of the same type that is being added. */
2467 tree result_type
= TREE_TYPE (ptrop
);
2469 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2471 if (pedantic
|| warn_pointer_arith
)
2472 pedwarn ("pointer of type `void *' used in arithmetic");
2473 size_exp
= integer_one_node
;
2475 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2477 if (pedantic
|| warn_pointer_arith
)
2478 pedwarn ("pointer to a function used in arithmetic");
2479 size_exp
= integer_one_node
;
2481 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2483 if (pedantic
|| warn_pointer_arith
)
2484 pedwarn ("pointer to member function used in arithmetic");
2485 size_exp
= integer_one_node
;
2488 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2490 /* If what we are about to multiply by the size of the elements
2491 contains a constant term, apply distributive law
2492 and multiply that constant term separately.
2493 This helps produce common subexpressions. */
2495 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2496 && ! TREE_CONSTANT (intop
)
2497 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2498 && TREE_CONSTANT (size_exp
)
2499 /* If the constant comes from pointer subtraction,
2500 skip this optimization--it would cause an error. */
2501 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2502 /* If the constant is unsigned, and smaller than the pointer size,
2503 then we must skip this optimization. This is because it could cause
2504 an overflow error if the constant is negative but INTOP is not. */
2505 && (! TREE_UNSIGNED (TREE_TYPE (intop
))
2506 || (TYPE_PRECISION (TREE_TYPE (intop
))
2507 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2509 enum tree_code subcode
= resultcode
;
2510 tree int_type
= TREE_TYPE (intop
);
2511 if (TREE_CODE (intop
) == MINUS_EXPR
)
2512 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2513 /* Convert both subexpression types to the type of intop,
2514 because weird cases involving pointer arithmetic
2515 can result in a sum or difference with different type args. */
2516 ptrop
= build_binary_op (subcode
, ptrop
,
2517 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2518 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2521 /* Convert the integer argument to a type the same size as sizetype
2522 so the multiply won't overflow spuriously. */
2524 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2525 || TREE_UNSIGNED (TREE_TYPE (intop
)) != TREE_UNSIGNED (sizetype
))
2526 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2527 TREE_UNSIGNED (sizetype
)), intop
);
2529 /* Replace the integer argument with a suitable product by the object size.
2530 Do this multiplication as signed, then convert to the appropriate
2531 pointer type (actually unsigned integral). */
2533 intop
= convert (result_type
,
2534 build_binary_op (MULT_EXPR
, intop
,
2535 convert (TREE_TYPE (intop
), size_exp
), 1));
2537 /* Create the sum or difference. */
2539 result
= build (resultcode
, result_type
, ptrop
, intop
);
2541 folded
= fold (result
);
2542 if (folded
== result
)
2543 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
2547 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2548 or validate its data type for an `if' or `while' statement or ?..: exp.
2550 This preparation consists of taking the ordinary
2551 representation of an expression expr and producing a valid tree
2552 boolean expression describing whether expr is nonzero. We could
2553 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2554 but we optimize comparisons, &&, ||, and !.
2556 The resulting type should always be `truthvalue_type_node'. */
2559 c_common_truthvalue_conversion (tree expr
)
2561 if (TREE_CODE (expr
) == ERROR_MARK
)
2564 if (TREE_CODE (expr
) == FUNCTION_DECL
)
2565 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
2567 switch (TREE_CODE (expr
))
2570 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2571 case TRUTH_ANDIF_EXPR
:
2572 case TRUTH_ORIF_EXPR
:
2573 case TRUTH_AND_EXPR
:
2575 case TRUTH_XOR_EXPR
:
2576 case TRUTH_NOT_EXPR
:
2577 TREE_TYPE (expr
) = truthvalue_type_node
;
2584 return integer_zerop (expr
) ? truthvalue_false_node
: truthvalue_true_node
;
2587 return real_zerop (expr
) ? truthvalue_false_node
: truthvalue_true_node
;
2591 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == FUNCTION_DECL
2592 && ! DECL_WEAK (TREE_OPERAND (expr
, 0)))
2594 /* Common Ada/Pascal programmer's mistake. We always warn
2595 about this since it is so bad. */
2596 warning ("the address of `%D', will always evaluate as `true'",
2597 TREE_OPERAND (expr
, 0));
2598 return truthvalue_true_node
;
2601 /* If we are taking the address of an external decl, it might be
2602 zero if it is weak, so we cannot optimize. */
2603 if (DECL_P (TREE_OPERAND (expr
, 0))
2604 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2607 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2608 return build (COMPOUND_EXPR
, truthvalue_type_node
,
2609 TREE_OPERAND (expr
, 0), truthvalue_true_node
);
2611 return truthvalue_true_node
;
2615 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2616 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2617 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2618 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2624 /* These don't change whether an object is nonzero or zero. */
2625 return lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0));
2629 /* These don't change whether an object is zero or nonzero, but
2630 we can't ignore them if their second arg has side-effects. */
2631 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2632 return build (COMPOUND_EXPR
, truthvalue_type_node
, TREE_OPERAND (expr
, 1),
2633 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2635 return lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0));
2638 /* Distribute the conversion into the arms of a COND_EXPR. */
2639 return fold (build (COND_EXPR
, truthvalue_type_node
, TREE_OPERAND (expr
, 0),
2640 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2641 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2644 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2645 since that affects how `default_conversion' will behave. */
2646 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2647 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2649 /* Fall through.... */
2651 /* If this is widening the argument, we can ignore it. */
2652 if (TYPE_PRECISION (TREE_TYPE (expr
))
2653 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2654 return lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0));
2658 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2659 aren't guaranteed to the be same for modes that can represent
2660 infinity, since if x and y are both +infinity, or both
2661 -infinity, then x - y is not a number.
2663 Note that this transformation is safe when x or y is NaN.
2664 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2666 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))))
2668 /* Fall through.... */
2670 /* This and MINUS_EXPR can be changed into a comparison of the
2672 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2673 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2674 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2675 TREE_OPERAND (expr
, 1), 1);
2676 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2677 fold (build1 (NOP_EXPR
,
2678 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2679 TREE_OPERAND (expr
, 1))), 1);
2682 if (integer_onep (TREE_OPERAND (expr
, 1))
2683 && TREE_TYPE (expr
) != truthvalue_type_node
)
2684 /* Using convert here would cause infinite recursion. */
2685 return build1 (NOP_EXPR
, truthvalue_type_node
, expr
);
2689 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2690 warning ("suggest parentheses around assignment used as truth value");
2697 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2699 tree t
= save_expr (expr
);
2700 return (build_binary_op
2701 ((TREE_SIDE_EFFECTS (expr
)
2702 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2703 lang_hooks
.truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2704 lang_hooks
.truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2708 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2711 static tree
builtin_function_2 (const char *, const char *, tree
, tree
,
2712 int, enum built_in_class
, int, int,
2715 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2716 down to the element type of an array. */
2719 c_build_qualified_type (tree type
, int type_quals
)
2721 if (type
== error_mark_node
)
2724 if (TREE_CODE (type
) == ARRAY_TYPE
)
2725 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2727 TYPE_DOMAIN (type
));
2729 /* A restrict-qualified pointer type must be a pointer to object or
2730 incomplete type. Note that the use of POINTER_TYPE_P also allows
2731 REFERENCE_TYPEs, which is appropriate for C++. */
2732 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2733 && (!POINTER_TYPE_P (type
)
2734 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2736 error ("invalid use of `restrict'");
2737 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2740 return build_qualified_type (type
, type_quals
);
2743 /* Apply the TYPE_QUALS to the new DECL. */
2746 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
2748 tree type
= TREE_TYPE (decl
);
2750 if (type
== error_mark_node
)
2753 if (((type_quals
& TYPE_QUAL_CONST
)
2754 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
2755 /* An object declared 'const' is only readonly after it is
2756 initialized. We don't have any way of expressing this currently,
2757 so we need to be conservative and unset TREE_READONLY for types
2758 with constructors. Otherwise aliasing code will ignore stores in
2759 an inline constructor. */
2760 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
2761 TREE_READONLY (decl
) = 1;
2762 if (type_quals
& TYPE_QUAL_VOLATILE
)
2764 TREE_SIDE_EFFECTS (decl
) = 1;
2765 TREE_THIS_VOLATILE (decl
) = 1;
2767 if (type_quals
& TYPE_QUAL_RESTRICT
)
2769 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
2770 /* Allow 'restrict' on arrays of pointers.
2771 FIXME currently we just ignore it. */
2772 type
= TREE_TYPE (type
);
2774 || !POINTER_TYPE_P (type
)
2775 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
2776 error ("invalid use of `restrict'");
2777 else if (flag_strict_aliasing
&& type
== TREE_TYPE (decl
))
2778 /* Indicate we need to make a unique alias set for this pointer.
2779 We can't do it here because it might be pointing to an
2781 DECL_POINTER_ALIAS_SET (decl
) = -2;
2785 /* Return the typed-based alias set for T, which may be an expression
2786 or a type. Return -1 if we don't do anything special. */
2789 c_common_get_alias_set (tree t
)
2793 /* Permit type-punning when accessing a union, provided the access
2794 is directly through the union. For example, this code does not
2795 permit taking the address of a union member and then storing
2796 through it. Even the type-punning allowed here is a GCC
2797 extension, albeit a common and useful one; the C standard says
2798 that such accesses have implementation-defined behavior. */
2800 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2801 u
= TREE_OPERAND (u
, 0))
2802 if (TREE_CODE (u
) == COMPONENT_REF
2803 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2806 /* That's all the expressions we handle specially. */
2810 /* The C standard guarantees that any object may be accessed via an
2811 lvalue that has character type. */
2812 if (t
== char_type_node
2813 || t
== signed_char_type_node
2814 || t
== unsigned_char_type_node
)
2817 /* If it has the may_alias attribute, it can alias anything. */
2818 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
2821 /* The C standard specifically allows aliasing between signed and
2822 unsigned variants of the same type. We treat the signed
2823 variant as canonical. */
2824 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
2826 tree t1
= c_common_signed_type (t
);
2828 /* t1 == t can happen for boolean nodes which are always unsigned. */
2830 return get_alias_set (t1
);
2832 else if (POINTER_TYPE_P (t
))
2836 /* Unfortunately, there is no canonical form of a pointer type.
2837 In particular, if we have `typedef int I', then `int *', and
2838 `I *' are different types. So, we have to pick a canonical
2839 representative. We do this below.
2841 Technically, this approach is actually more conservative that
2842 it needs to be. In particular, `const int *' and `int *'
2843 should be in different alias sets, according to the C and C++
2844 standard, since their types are not the same, and so,
2845 technically, an `int **' and `const int **' cannot point at
2848 But, the standard is wrong. In particular, this code is
2853 const int* const* cipp = ipp;
2855 And, it doesn't make sense for that to be legal unless you
2856 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2857 the pointed-to types. This issue has been reported to the
2859 t1
= build_type_no_quals (t
);
2861 return get_alias_set (t1
);
2867 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2868 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2869 flag controls whether we should diagnose possibly ill-formed
2870 constructs or not. */
2872 c_sizeof_or_alignof_type (tree type
, enum tree_code op
, int complain
)
2874 const char *op_name
;
2876 enum tree_code type_code
= TREE_CODE (type
);
2878 my_friendly_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
, 20020720);
2879 op_name
= op
== SIZEOF_EXPR
? "sizeof" : "__alignof__";
2881 if (type_code
== FUNCTION_TYPE
)
2883 if (op
== SIZEOF_EXPR
)
2885 if (complain
&& (pedantic
|| warn_pointer_arith
))
2886 pedwarn ("invalid application of `sizeof' to a function type");
2887 value
= size_one_node
;
2890 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2892 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
2894 if (type_code
== VOID_TYPE
2895 && complain
&& (pedantic
|| warn_pointer_arith
))
2896 pedwarn ("invalid application of `%s' to a void type", op_name
);
2897 value
= size_one_node
;
2899 else if (!COMPLETE_TYPE_P (type
))
2902 error ("invalid application of `%s' to an incomplete type", op_name
);
2903 value
= size_zero_node
;
2907 if (op
== SIZEOF_EXPR
)
2908 /* Convert in case a char is more than one unit. */
2909 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
2910 size_int (TYPE_PRECISION (char_type_node
)
2913 value
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
2916 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2917 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2918 never happen. However, this node should really have type
2919 `size_t', which is just a typedef for an ordinary integer type. */
2920 value
= fold (build1 (NOP_EXPR
, size_type_node
, value
));
2921 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)), 20001021);
2926 /* Implement the __alignof keyword: Return the minimum required
2927 alignment of EXPR, measured in bytes. For VAR_DECL's and
2928 FIELD_DECL's return DECL_ALIGN (which can be set from an
2929 "aligned" __attribute__ specification). */
2932 c_alignof_expr (tree expr
)
2936 if (TREE_CODE (expr
) == VAR_DECL
)
2937 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
2939 else if (TREE_CODE (expr
) == COMPONENT_REF
2940 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
2942 error ("`__alignof' applied to a bit-field");
2945 else if (TREE_CODE (expr
) == COMPONENT_REF
2946 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
2947 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
2949 else if (TREE_CODE (expr
) == INDIRECT_REF
)
2951 tree t
= TREE_OPERAND (expr
, 0);
2953 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2955 while (TREE_CODE (t
) == NOP_EXPR
2956 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
2960 t
= TREE_OPERAND (t
, 0);
2961 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2962 if (thisalign
> bestalign
)
2963 best
= t
, bestalign
= thisalign
;
2965 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
2968 return c_alignof (TREE_TYPE (expr
));
2970 return fold (build1 (NOP_EXPR
, size_type_node
, t
));
2973 /* Handle C and C++ default attributes. */
2975 enum built_in_attribute
2977 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2978 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2979 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2980 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2981 #include "builtin-attrs.def"
2982 #undef DEF_ATTR_NULL_TREE
2984 #undef DEF_ATTR_IDENT
2985 #undef DEF_ATTR_TREE_LIST
2989 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
2991 static void c_init_attributes (void);
2993 /* Build tree nodes and builtin functions common to both C and C++ language
2997 c_common_nodes_and_builtins (void)
3001 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3002 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3003 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3004 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3005 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3006 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3007 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3008 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3009 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3010 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3011 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3012 #include "builtin-types.def"
3013 #undef DEF_PRIMITIVE_TYPE
3014 #undef DEF_FUNCTION_TYPE_0
3015 #undef DEF_FUNCTION_TYPE_1
3016 #undef DEF_FUNCTION_TYPE_2
3017 #undef DEF_FUNCTION_TYPE_3
3018 #undef DEF_FUNCTION_TYPE_4
3019 #undef DEF_FUNCTION_TYPE_VAR_0
3020 #undef DEF_FUNCTION_TYPE_VAR_1
3021 #undef DEF_FUNCTION_TYPE_VAR_2
3022 #undef DEF_FUNCTION_TYPE_VAR_3
3023 #undef DEF_POINTER_TYPE
3027 typedef enum builtin_type builtin_type
;
3029 tree builtin_types
[(int) BT_LAST
];
3030 int wchar_type_size
;
3031 tree array_domain_type
;
3032 tree va_list_ref_type_node
;
3033 tree va_list_arg_type_node
;
3035 /* Define `int' and `char' first so that dbx will output them first. */
3036 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3037 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3039 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3040 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3041 but not C. Are the conditionals here needed? */
3042 if (c_dialect_cxx ())
3043 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3044 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3045 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3046 record_builtin_type (RID_MAX
, "long unsigned int",
3047 long_unsigned_type_node
);
3048 if (c_dialect_cxx ())
3049 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3050 record_builtin_type (RID_MAX
, "long long int",
3051 long_long_integer_type_node
);
3052 record_builtin_type (RID_MAX
, "long long unsigned int",
3053 long_long_unsigned_type_node
);
3054 if (c_dialect_cxx ())
3055 record_builtin_type (RID_MAX
, "long long unsigned",
3056 long_long_unsigned_type_node
);
3057 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3058 record_builtin_type (RID_MAX
, "short unsigned int",
3059 short_unsigned_type_node
);
3060 if (c_dialect_cxx ())
3061 record_builtin_type (RID_MAX
, "unsigned short",
3062 short_unsigned_type_node
);
3064 /* Define both `signed char' and `unsigned char'. */
3065 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3066 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3068 /* These are types that c_common_type_for_size and
3069 c_common_type_for_mode use. */
3070 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3072 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3074 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3076 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3078 #if HOST_BITS_PER_WIDE_INT >= 64
3079 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3080 get_identifier ("__int128_t"),
3083 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3084 unsigned_intQI_type_node
));
3085 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3086 unsigned_intHI_type_node
));
3087 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3088 unsigned_intSI_type_node
));
3089 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3090 unsigned_intDI_type_node
));
3091 #if HOST_BITS_PER_WIDE_INT >= 64
3092 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3093 get_identifier ("__uint128_t"),
3094 unsigned_intTI_type_node
));
3097 /* Create the widest literal types. */
3098 widest_integer_literal_type_node
3099 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3100 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3101 widest_integer_literal_type_node
));
3103 widest_unsigned_literal_type_node
3104 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3105 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3106 widest_unsigned_literal_type_node
));
3108 /* `unsigned long' is the standard type for sizeof.
3109 Note that stddef.h uses `unsigned long',
3110 and this must agree, even if long and int are the same size. */
3112 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3113 signed_size_type_node
= c_common_signed_type (size_type_node
);
3114 set_sizetype (size_type_node
);
3116 build_common_tree_nodes_2 (flag_short_double
);
3118 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3119 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3120 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3122 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3123 get_identifier ("complex int"),
3124 complex_integer_type_node
));
3125 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3126 get_identifier ("complex float"),
3127 complex_float_type_node
));
3128 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3129 get_identifier ("complex double"),
3130 complex_double_type_node
));
3131 lang_hooks
.decls
.pushdecl
3132 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3133 complex_long_double_type_node
));
3135 /* Types which are common to the fortran compiler and libf2c. When
3136 changing these, you also need to be concerned with f/com.h. */
3138 if (TYPE_PRECISION (float_type_node
)
3139 == TYPE_PRECISION (long_integer_type_node
))
3141 g77_integer_type_node
= long_integer_type_node
;
3142 g77_uinteger_type_node
= long_unsigned_type_node
;
3144 else if (TYPE_PRECISION (float_type_node
)
3145 == TYPE_PRECISION (integer_type_node
))
3147 g77_integer_type_node
= integer_type_node
;
3148 g77_uinteger_type_node
= unsigned_type_node
;
3151 g77_integer_type_node
= g77_uinteger_type_node
= NULL_TREE
;
3153 if (g77_integer_type_node
!= NULL_TREE
)
3155 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3156 get_identifier ("__g77_integer"),
3157 g77_integer_type_node
));
3158 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3159 get_identifier ("__g77_uinteger"),
3160 g77_uinteger_type_node
));
3163 if (TYPE_PRECISION (float_type_node
) * 2
3164 == TYPE_PRECISION (long_integer_type_node
))
3166 g77_longint_type_node
= long_integer_type_node
;
3167 g77_ulongint_type_node
= long_unsigned_type_node
;
3169 else if (TYPE_PRECISION (float_type_node
) * 2
3170 == TYPE_PRECISION (long_long_integer_type_node
))
3172 g77_longint_type_node
= long_long_integer_type_node
;
3173 g77_ulongint_type_node
= long_long_unsigned_type_node
;
3176 g77_longint_type_node
= g77_ulongint_type_node
= NULL_TREE
;
3178 if (g77_longint_type_node
!= NULL_TREE
)
3180 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3181 get_identifier ("__g77_longint"),
3182 g77_longint_type_node
));
3183 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3184 get_identifier ("__g77_ulongint"),
3185 g77_ulongint_type_node
));
3188 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3190 void_zero_node
= build_int_2 (0, 0);
3191 TREE_TYPE (void_zero_node
) = void_type_node
;
3193 void_list_node
= build_void_list_node ();
3195 /* Make a type to be the domain of a few array types
3196 whose domains don't really matter.
3197 200 is small enough that it always fits in size_t
3198 and large enough that it can hold most function names for the
3199 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3200 array_domain_type
= build_index_type (size_int (200));
3202 /* Make a type for arrays of characters.
3203 With luck nothing will ever really depend on the length of this
3205 char_array_type_node
3206 = build_array_type (char_type_node
, array_domain_type
);
3208 /* Likewise for arrays of ints. */
3210 = build_array_type (integer_type_node
, array_domain_type
);
3212 string_type_node
= build_pointer_type (char_type_node
);
3213 const_string_type_node
3214 = build_pointer_type (build_qualified_type
3215 (char_type_node
, TYPE_QUAL_CONST
));
3217 /* This is special for C++ so functions can be overloaded. */
3218 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3219 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3220 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3221 if (c_dialect_cxx ())
3223 if (TREE_UNSIGNED (wchar_type_node
))
3224 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3226 wchar_type_node
= make_signed_type (wchar_type_size
);
3227 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3231 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3232 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3235 /* This is for wide string constants. */
3236 wchar_array_type_node
3237 = build_array_type (wchar_type_node
, array_domain_type
);
3240 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3243 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3245 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3247 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3249 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3250 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3252 lang_hooks
.decls
.pushdecl
3253 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3254 va_list_type_node
));
3256 lang_hooks
.decls
.pushdecl
3257 (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
3258 ptrdiff_type_node
));
3260 lang_hooks
.decls
.pushdecl
3261 (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
3264 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3266 va_list_arg_type_node
= va_list_ref_type_node
=
3267 build_pointer_type (TREE_TYPE (va_list_type_node
));
3271 va_list_arg_type_node
= va_list_type_node
;
3272 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3275 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3276 builtin_types[(int) ENUM] = VALUE;
3277 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3278 builtin_types[(int) ENUM] \
3279 = build_function_type (builtin_types[(int) RETURN], \
3281 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3282 builtin_types[(int) ENUM] \
3283 = build_function_type (builtin_types[(int) RETURN], \
3284 tree_cons (NULL_TREE, \
3285 builtin_types[(int) ARG1], \
3287 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3288 builtin_types[(int) ENUM] \
3289 = build_function_type \
3290 (builtin_types[(int) RETURN], \
3291 tree_cons (NULL_TREE, \
3292 builtin_types[(int) ARG1], \
3293 tree_cons (NULL_TREE, \
3294 builtin_types[(int) ARG2], \
3296 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3297 builtin_types[(int) ENUM] \
3298 = build_function_type \
3299 (builtin_types[(int) RETURN], \
3300 tree_cons (NULL_TREE, \
3301 builtin_types[(int) ARG1], \
3302 tree_cons (NULL_TREE, \
3303 builtin_types[(int) ARG2], \
3304 tree_cons (NULL_TREE, \
3305 builtin_types[(int) ARG3], \
3307 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3308 builtin_types[(int) ENUM] \
3309 = build_function_type \
3310 (builtin_types[(int) RETURN], \
3311 tree_cons (NULL_TREE, \
3312 builtin_types[(int) ARG1], \
3313 tree_cons (NULL_TREE, \
3314 builtin_types[(int) ARG2], \
3317 builtin_types[(int) ARG3], \
3318 tree_cons (NULL_TREE, \
3319 builtin_types[(int) ARG4], \
3320 void_list_node)))));
3321 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3322 builtin_types[(int) ENUM] \
3323 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3324 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3325 builtin_types[(int) ENUM] \
3326 = build_function_type (builtin_types[(int) RETURN], \
3327 tree_cons (NULL_TREE, \
3328 builtin_types[(int) ARG1], \
3331 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3332 builtin_types[(int) ENUM] \
3333 = build_function_type \
3334 (builtin_types[(int) RETURN], \
3335 tree_cons (NULL_TREE, \
3336 builtin_types[(int) ARG1], \
3337 tree_cons (NULL_TREE, \
3338 builtin_types[(int) ARG2], \
3341 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3342 builtin_types[(int) ENUM] \
3343 = build_function_type \
3344 (builtin_types[(int) RETURN], \
3345 tree_cons (NULL_TREE, \
3346 builtin_types[(int) ARG1], \
3347 tree_cons (NULL_TREE, \
3348 builtin_types[(int) ARG2], \
3349 tree_cons (NULL_TREE, \
3350 builtin_types[(int) ARG3], \
3353 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3354 builtin_types[(int) ENUM] \
3355 = build_pointer_type (builtin_types[(int) TYPE]);
3356 #include "builtin-types.def"
3357 #undef DEF_PRIMITIVE_TYPE
3358 #undef DEF_FUNCTION_TYPE_1
3359 #undef DEF_FUNCTION_TYPE_2
3360 #undef DEF_FUNCTION_TYPE_3
3361 #undef DEF_FUNCTION_TYPE_4
3362 #undef DEF_FUNCTION_TYPE_VAR_0
3363 #undef DEF_FUNCTION_TYPE_VAR_1
3364 #undef DEF_FUNCTION_TYPE_VAR_2
3365 #undef DEF_FUNCTION_TYPE_VAR_3
3366 #undef DEF_POINTER_TYPE
3368 c_init_attributes ();
3370 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3371 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3376 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3380 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3383 ? (NAME + strlen ("__builtin_")) \
3385 built_in_attributes[(int) ATTRS]); \
3387 decl = builtin_function_2 (NAME, \
3388 NAME + strlen ("__builtin_"), \
3389 builtin_types[TYPE], \
3390 builtin_types[LIBTYPE], \
3395 built_in_attributes[(int) ATTRS]); \
3397 built_in_decls[(int) ENUM] = decl; \
3399 implicit_built_in_decls[(int) ENUM] = decl; \
3401 #include "builtins.def"
3404 targetm
.init_builtins ();
3406 main_identifier_node
= get_identifier ("main");
3410 build_va_arg (tree expr
, tree type
)
3412 return build1 (VA_ARG_EXPR
, type
, expr
);
3416 /* Linked list of disabled built-in functions. */
3418 typedef struct disabled_builtin
3421 struct disabled_builtin
*next
;
3423 static disabled_builtin
*disabled_builtins
= NULL
;
3425 static bool builtin_function_disabled_p (const char *);
3427 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3428 begins with "__builtin_", give an error. */
3431 disable_builtin_function (const char *name
)
3433 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3434 error ("cannot disable built-in function `%s'", name
);
3437 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
3439 new->next
= disabled_builtins
;
3440 disabled_builtins
= new;
3445 /* Return true if the built-in function NAME has been disabled, false
3449 builtin_function_disabled_p (const char *name
)
3451 disabled_builtin
*p
;
3452 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3454 if (strcmp (name
, p
->name
) == 0)
3461 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3462 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3463 of these may be NULL (though both being NULL is useless).
3464 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3465 TYPE is the type of the function with the ordinary name. These
3466 may differ if the ordinary name is declared with a looser type to avoid
3467 conflicts with headers. FUNCTION_CODE and CLASS are as for
3468 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3469 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3470 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3471 ATTRS is the tree list representing the builtin's function attributes.
3472 Returns the declaration of BUILTIN_NAME, if any, otherwise
3473 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3474 or if NONANSI_P and flag_no_nonansi_builtin. */
3477 builtin_function_2 (const char *builtin_name
, const char *name
,
3478 tree builtin_type
, tree type
, int function_code
,
3479 enum built_in_class
class, int library_name_p
,
3480 int nonansi_p
, tree attrs
)
3482 tree bdecl
= NULL_TREE
;
3483 tree decl
= NULL_TREE
;
3485 if (builtin_name
!= 0)
3486 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
3487 class, library_name_p
? name
: NULL
, attrs
);
3489 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
3490 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3491 decl
= builtin_function (name
, type
, function_code
, class, NULL
, attrs
);
3493 return (bdecl
!= 0 ? bdecl
: decl
);
3496 /* Nonzero if the type T promotes to int. This is (nearly) the
3497 integral promotions defined in ISO C99 6.3.1.1/2. */
3500 c_promoting_integer_type_p (tree t
)
3502 switch (TREE_CODE (t
))
3505 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3506 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3507 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3508 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3509 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3510 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3513 /* ??? Technically all enumerations not larger than an int
3514 promote to an int. But this is used along code paths
3515 that only want to notice a size change. */
3516 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3526 /* Return 1 if PARMS specifies a fixed number of parameters
3527 and none of their types is affected by default promotions. */
3530 self_promoting_args_p (tree parms
)
3533 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3535 tree type
= TREE_VALUE (t
);
3537 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3543 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3546 if (c_promoting_integer_type_p (type
))
3552 /* Recursively examines the array elements of TYPE, until a non-array
3553 element type is found. */
3556 strip_array_types (tree type
)
3558 while (TREE_CODE (type
) == ARRAY_TYPE
)
3559 type
= TREE_TYPE (type
);
3564 /* Recursively remove any '*' or '&' operator from TYPE. */
3566 strip_pointer_operator (tree t
)
3568 while (POINTER_TYPE_P (t
))
3573 static tree
expand_unordered_cmp (tree
, tree
, enum tree_code
, enum tree_code
);
3575 /* Expand a call to an unordered comparison function such as
3576 __builtin_isgreater(). FUNCTION is the function's declaration and
3577 PARAMS a list of the values passed. For __builtin_isunordered(),
3578 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3579 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3580 that give the opposite of the desired result. UNORDERED_CODE is
3581 used for modes that can hold NaNs and ORDERED_CODE is used for the
3585 expand_unordered_cmp (tree function
, tree params
,
3586 enum tree_code unordered_code
,
3587 enum tree_code ordered_code
)
3589 tree arg0
, arg1
, type
;
3590 enum tree_code code0
, code1
;
3592 /* Check that we have exactly two arguments. */
3593 if (params
== 0 || TREE_CHAIN (params
) == 0)
3595 error ("too few arguments to function `%s'",
3596 IDENTIFIER_POINTER (DECL_NAME (function
)));
3597 return error_mark_node
;
3599 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3601 error ("too many arguments to function `%s'",
3602 IDENTIFIER_POINTER (DECL_NAME (function
)));
3603 return error_mark_node
;
3606 arg0
= TREE_VALUE (params
);
3607 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3609 code0
= TREE_CODE (TREE_TYPE (arg0
));
3610 code1
= TREE_CODE (TREE_TYPE (arg1
));
3612 /* Make sure that the arguments have a common type of REAL. */
3614 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3615 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3616 type
= common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
));
3618 if (type
== 0 || TREE_CODE (type
) != REAL_TYPE
)
3620 error ("non-floating-point argument to function `%s'",
3621 IDENTIFIER_POINTER (DECL_NAME (function
)));
3622 return error_mark_node
;
3625 if (unordered_code
== UNORDERED_EXPR
)
3627 if (MODE_HAS_NANS (TYPE_MODE (type
)))
3628 return build_binary_op (unordered_code
,
3629 convert (type
, arg0
),
3630 convert (type
, arg1
),
3633 return integer_zero_node
;
3636 return build_unary_op (TRUTH_NOT_EXPR
,
3637 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type
))
3640 convert (type
, arg0
),
3641 convert (type
, arg1
),
3647 /* Recognize certain built-in functions so we can make tree-codes
3648 other than CALL_EXPR. We do this when it enables fold-const.c
3649 to do something useful. */
3650 /* ??? By rights this should go in builtins.c, but only C and C++
3651 implement build_{binary,unary}_op. Not exactly sure what bits
3652 of functionality are actually needed from those functions, or
3653 where the similar functionality exists in the other front ends. */
3656 expand_tree_builtin (tree function
, tree params
, tree coerced_params
)
3658 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
3661 switch (DECL_FUNCTION_CODE (function
))
3665 case BUILT_IN_LLABS
:
3666 case BUILT_IN_IMAXABS
:
3668 case BUILT_IN_FABSL
:
3669 case BUILT_IN_FABSF
:
3670 if (coerced_params
== 0)
3671 return integer_zero_node
;
3672 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3675 case BUILT_IN_CONJF
:
3676 case BUILT_IN_CONJL
:
3677 if (coerced_params
== 0)
3678 return integer_zero_node
;
3679 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3681 case BUILT_IN_CREAL
:
3682 case BUILT_IN_CREALF
:
3683 case BUILT_IN_CREALL
:
3684 if (coerced_params
== 0)
3685 return integer_zero_node
;
3686 return non_lvalue (build_unary_op (REALPART_EXPR
,
3687 TREE_VALUE (coerced_params
), 0));
3689 case BUILT_IN_CIMAG
:
3690 case BUILT_IN_CIMAGF
:
3691 case BUILT_IN_CIMAGL
:
3692 if (coerced_params
== 0)
3693 return integer_zero_node
;
3694 return non_lvalue (build_unary_op (IMAGPART_EXPR
,
3695 TREE_VALUE (coerced_params
), 0));
3697 case BUILT_IN_ISGREATER
:
3698 return expand_unordered_cmp (function
, params
, UNLE_EXPR
, LE_EXPR
);
3700 case BUILT_IN_ISGREATEREQUAL
:
3701 return expand_unordered_cmp (function
, params
, UNLT_EXPR
, LT_EXPR
);
3703 case BUILT_IN_ISLESS
:
3704 return expand_unordered_cmp (function
, params
, UNGE_EXPR
, GE_EXPR
);
3706 case BUILT_IN_ISLESSEQUAL
:
3707 return expand_unordered_cmp (function
, params
, UNGT_EXPR
, GT_EXPR
);
3709 case BUILT_IN_ISLESSGREATER
:
3710 return expand_unordered_cmp (function
, params
, UNEQ_EXPR
, EQ_EXPR
);
3712 case BUILT_IN_ISUNORDERED
:
3713 return expand_unordered_cmp (function
, params
, UNORDERED_EXPR
, NOP_EXPR
);
3722 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3723 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3724 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3725 value, the traversal is aborted, and the value returned by FUNC is
3726 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3727 the node being visited are not walked.
3729 We don't need a without_duplicates variant of this one because the
3730 statement tree is a tree, not a graph. */
3733 walk_stmt_tree (tree
*tp
, walk_tree_fn func
, void *data
)
3735 enum tree_code code
;
3740 #define WALK_SUBTREE(NODE) \
3743 result = walk_stmt_tree (&(NODE), func, data); \
3749 /* Skip empty subtrees. */
3753 /* Skip subtrees below non-statement nodes. */
3754 if (!STATEMENT_CODE_P (TREE_CODE (*tp
)))
3757 /* Call the function. */
3759 result
= (*func
) (tp
, &walk_subtrees
, data
);
3761 /* If we found something, return it. */
3765 /* FUNC may have modified the tree, recheck that we're looking at a
3767 code
= TREE_CODE (*tp
);
3768 if (!STATEMENT_CODE_P (code
))
3771 /* Visit the subtrees unless FUNC decided that there was nothing
3772 interesting below this point in the tree. */
3775 /* Walk over all the sub-trees of this operand. Statement nodes
3776 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3777 len
= TREE_CODE_LENGTH (code
);
3779 /* Go through the subtrees. We need to do this in forward order so
3780 that the scope of a FOR_EXPR is handled properly. */
3781 for (i
= 0; i
< len
; ++i
)
3782 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3785 /* Finally visit the chain. This can be tail-recursion optimized if
3786 we write it this way. */
3787 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3792 /* Used to compare case labels. K1 and K2 are actually tree nodes
3793 representing case labels, or NULL_TREE for a `default' label.
3794 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3795 K2, and 0 if K1 and K2 are equal. */
3798 case_compare (splay_tree_key k1
, splay_tree_key k2
)
3800 /* Consider a NULL key (such as arises with a `default' label) to be
3801 smaller than anything else. */
3807 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3810 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3811 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3812 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3813 case label was declared using the usual C/C++ syntax, rather than
3814 the GNU case range extension. CASES is a tree containing all the
3815 case ranges processed so far; COND is the condition for the
3816 switch-statement itself. Returns the CASE_LABEL created, or
3817 ERROR_MARK_NODE if no CASE_LABEL is created. */
3820 c_add_case_label (splay_tree cases
, tree cond
, tree low_value
,
3826 splay_tree_node node
;
3828 /* Create the LABEL_DECL itself. */
3829 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3830 DECL_CONTEXT (label
) = current_function_decl
;
3832 /* If there was an error processing the switch condition, bail now
3833 before we get more confused. */
3834 if (!cond
|| cond
== error_mark_node
)
3836 /* Add a label anyhow so that the back-end doesn't think that
3837 the beginning of the switch is unreachable. */
3839 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3840 return error_mark_node
;
3843 if ((low_value
&& TREE_TYPE (low_value
)
3844 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3845 || (high_value
&& TREE_TYPE (high_value
)
3846 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3847 error ("pointers are not permitted as case values");
3849 /* Case ranges are a GNU extension. */
3850 if (high_value
&& pedantic
)
3851 pedwarn ("range expressions in switch statements are non-standard");
3853 type
= TREE_TYPE (cond
);
3856 low_value
= check_case_value (low_value
);
3857 low_value
= convert_and_check (type
, low_value
);
3861 high_value
= check_case_value (high_value
);
3862 high_value
= convert_and_check (type
, high_value
);
3865 /* If an error has occurred, bail out now. */
3866 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
3869 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3870 return error_mark_node
;
3873 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3874 really a case range, even though it was written that way. Remove
3875 the HIGH_VALUE to simplify later processing. */
3876 if (tree_int_cst_equal (low_value
, high_value
))
3877 high_value
= NULL_TREE
;
3878 if (low_value
&& high_value
3879 && !tree_int_cst_lt (low_value
, high_value
))
3880 warning ("empty range specified");
3882 /* Look up the LOW_VALUE in the table of case labels we already
3884 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3885 /* If there was not an exact match, check for overlapping ranges.
3886 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3887 that's a `default' label and the only overlap is an exact match. */
3888 if (!node
&& (low_value
|| high_value
))
3890 splay_tree_node low_bound
;
3891 splay_tree_node high_bound
;
3893 /* Even though there wasn't an exact match, there might be an
3894 overlap between this case range and another case range.
3895 Since we've (inductively) not allowed any overlapping case
3896 ranges, we simply need to find the greatest low case label
3897 that is smaller that LOW_VALUE, and the smallest low case
3898 label that is greater than LOW_VALUE. If there is an overlap
3899 it will occur in one of these two ranges. */
3900 low_bound
= splay_tree_predecessor (cases
,
3901 (splay_tree_key
) low_value
);
3902 high_bound
= splay_tree_successor (cases
,
3903 (splay_tree_key
) low_value
);
3905 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3906 the LOW_VALUE, so there is no need to check unless the
3907 LOW_BOUND is in fact itself a case range. */
3909 && CASE_HIGH ((tree
) low_bound
->value
)
3910 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3913 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3914 range is bigger than the low end of the current range, so we
3915 are only interested if the current range is a real range, and
3916 not an ordinary case label. */
3919 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3924 /* If there was an overlap, issue an error. */
3927 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
3931 error ("duplicate (or overlapping) case value");
3932 error ("%Jthis is the first entry overlapping that value", duplicate
);
3936 error ("duplicate case value") ;
3937 error ("%Jpreviously used here", duplicate
);
3941 error ("multiple default labels in one switch");
3942 error ("%Jthis is the first default label", duplicate
);
3945 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3948 /* Add a CASE_LABEL to the statement-tree. */
3949 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3950 /* Register this case label in the splay tree. */
3951 splay_tree_insert (cases
,
3952 (splay_tree_key
) low_value
,
3953 (splay_tree_value
) case_label
);
3958 /* Finish an expression taking the address of LABEL (an
3959 IDENTIFIER_NODE). Returns an expression for the address. */
3962 finish_label_address_expr (tree label
)
3967 pedwarn ("taking the address of a label is non-standard");
3969 if (label
== error_mark_node
)
3970 return error_mark_node
;
3972 label
= lookup_label (label
);
3973 if (label
== NULL_TREE
)
3974 result
= null_pointer_node
;
3977 TREE_USED (label
) = 1;
3978 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
3979 TREE_CONSTANT (result
) = 1;
3980 /* The current function in not necessarily uninlinable.
3981 Computed gotos are incompatible with inlining, but the value
3982 here could be used only in a diagnostic, for example. */
3988 /* Hook used by expand_expr to expand language-specific tree codes. */
3991 c_expand_expr (tree exp
, rtx target
, enum machine_mode tmode
,
3992 int modifier
/* Actually enum_modifier. */,
3995 switch (TREE_CODE (exp
))
4001 bool preserve_result
= false;
4003 if (STMT_EXPR_WARN_UNUSED_RESULT (exp
) && target
== const0_rtx
)
4005 tree stmt
= STMT_EXPR_STMT (exp
);
4008 for (scope
= COMPOUND_BODY (stmt
);
4009 scope
&& TREE_CODE (scope
) != SCOPE_STMT
;
4010 scope
= TREE_CHAIN (scope
));
4012 if (scope
&& SCOPE_STMT_BLOCK (scope
))
4013 warning ("%Hignoring return value of `%D', "
4014 "declared with attribute warn_unused_result",
4015 &expr_wfl_stack
->location
,
4016 BLOCK_ABSTRACT_ORIGIN (SCOPE_STMT_BLOCK (scope
)));
4018 warning ("%Hignoring return value of function "
4019 "declared with attribute warn_unused_result",
4020 &expr_wfl_stack
->location
);
4023 /* Since expand_expr_stmt calls free_temp_slots after every
4024 expression statement, we must call push_temp_slots here.
4025 Otherwise, any temporaries in use now would be considered
4026 out-of-scope after the first EXPR_STMT from within the
4029 rtl_expr
= expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp
));
4031 /* If we want the result of this expression, find the last
4032 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4033 if (target
!= const0_rtx
4034 && TREE_CODE (STMT_EXPR_STMT (exp
)) == COMPOUND_STMT
4035 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp
))) == SCOPE_STMT
)
4037 tree expr
= COMPOUND_BODY (STMT_EXPR_STMT (exp
));
4038 tree last
= TREE_CHAIN (expr
);
4040 while (TREE_CHAIN (last
))
4043 last
= TREE_CHAIN (last
);
4046 if (TREE_CODE (last
) == SCOPE_STMT
4047 && TREE_CODE (expr
) == EXPR_STMT
)
4049 /* Otherwise, note that we want the value from the last
4051 TREE_ADDRESSABLE (expr
) = 1;
4052 preserve_result
= true;
4056 expand_stmt (STMT_EXPR_STMT (exp
));
4057 expand_end_stmt_expr (rtl_expr
);
4059 result
= expand_expr_real (rtl_expr
, target
, tmode
, modifier
, alt_rtl
);
4060 if (preserve_result
&& GET_CODE (result
) == MEM
)
4062 if (GET_MODE (result
) != BLKmode
)
4063 result
= copy_to_reg (result
);
4065 preserve_temp_slots (result
);
4068 /* If the statment-expression does not have a scope, then the
4069 new temporaries we created within it must live beyond the
4070 statement-expression. */
4071 if (STMT_EXPR_NO_SCOPE (exp
))
4072 preserve_temp_slots (NULL_RTX
);
4079 case COMPOUND_LITERAL_EXPR
:
4081 /* Initialize the anonymous variable declared in the compound
4082 literal, then return the variable. */
4083 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4084 emit_local_var (decl
);
4085 return expand_expr_real (decl
, target
, tmode
, modifier
, alt_rtl
);
4096 /* Hook used by safe_from_p to handle language-specific tree codes. */
4099 c_safe_from_p (rtx target
, tree exp
)
4101 /* We can see statements here when processing the body of a
4102 statement-expression. For a declaration statement declaring a
4103 variable, look at the variable's initializer. */
4104 if (TREE_CODE (exp
) == DECL_STMT
)
4106 tree decl
= DECL_STMT_DECL (exp
);
4108 if (TREE_CODE (decl
) == VAR_DECL
4109 && DECL_INITIAL (decl
)
4110 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
4114 /* For any statement, we must follow the statement-chain. */
4115 if (STATEMENT_CODE_P (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
4116 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
4118 /* Assume everything else is safe. */
4122 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4125 c_common_unsafe_for_reeval (tree exp
)
4127 /* Statement expressions may not be reevaluated, likewise compound
4129 if (TREE_CODE (exp
) == STMT_EXPR
4130 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
4133 /* Walk all other expressions. */
4137 /* Hook used by staticp to handle language-specific tree codes. */
4140 c_staticp (tree exp
)
4142 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4143 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
4149 /* Given a boolean expression ARG, return a tree representing an increment
4150 or decrement (as indicated by CODE) of ARG. The front end must check for
4151 invalid cases (e.g., decrement in C++). */
4153 boolean_increment (enum tree_code code
, tree arg
)
4156 tree true_res
= boolean_true_node
;
4158 arg
= stabilize_reference (arg
);
4161 case PREINCREMENT_EXPR
:
4162 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4164 case POSTINCREMENT_EXPR
:
4165 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4166 arg
= save_expr (arg
);
4167 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4168 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4170 case PREDECREMENT_EXPR
:
4171 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4173 case POSTDECREMENT_EXPR
:
4174 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4175 arg
= save_expr (arg
);
4176 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4177 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4182 TREE_SIDE_EFFECTS (val
) = 1;
4186 /* Built-in macros for stddef.h, that require macros defined in this
4189 c_stddef_cpp_builtins(void)
4191 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4192 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4193 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4194 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4198 c_init_attributes (void)
4200 /* Fill in the built_in_attributes array. */
4201 #define DEF_ATTR_NULL_TREE(ENUM) \
4202 built_in_attributes[(int) ENUM] = NULL_TREE;
4203 #define DEF_ATTR_INT(ENUM, VALUE) \
4204 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4205 #define DEF_ATTR_IDENT(ENUM, STRING) \
4206 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4207 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4208 built_in_attributes[(int) ENUM] \
4209 = tree_cons (built_in_attributes[(int) PURPOSE], \
4210 built_in_attributes[(int) VALUE], \
4211 built_in_attributes[(int) CHAIN]);
4212 #include "builtin-attrs.def"
4213 #undef DEF_ATTR_NULL_TREE
4215 #undef DEF_ATTR_IDENT
4216 #undef DEF_ATTR_TREE_LIST
4219 /* Attribute handlers common to C front ends. */
4221 /* Handle a "packed" attribute; arguments as in
4222 struct attribute_spec.handler. */
4225 handle_packed_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4226 int flags
, bool *no_add_attrs
)
4230 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4231 *node
= build_type_copy (*node
);
4232 TYPE_PACKED (*node
) = 1;
4233 if (TYPE_MAIN_VARIANT (*node
) == *node
)
4235 /* If it is the main variant, then pack the other variants
4236 too. This happens in,
4239 struct Foo const *ptr; // creates a variant w/o packed flag
4240 } __ attribute__((packed)); // packs it now.
4244 for (probe
= *node
; probe
; probe
= TYPE_NEXT_VARIANT (probe
))
4245 TYPE_PACKED (probe
) = 1;
4249 else if (TREE_CODE (*node
) == FIELD_DECL
)
4250 DECL_PACKED (*node
) = 1;
4251 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4252 used for DECL_REGISTER. It wouldn't mean anything anyway.
4253 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4254 that changes what the typedef is typing. */
4257 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4258 *no_add_attrs
= true;
4264 /* Handle a "nocommon" attribute; arguments as in
4265 struct attribute_spec.handler. */
4268 handle_nocommon_attribute (tree
*node
, tree name
,
4269 tree args ATTRIBUTE_UNUSED
,
4270 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4272 if (TREE_CODE (*node
) == VAR_DECL
)
4273 DECL_COMMON (*node
) = 0;
4276 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4277 *no_add_attrs
= true;
4283 /* Handle a "common" attribute; arguments as in
4284 struct attribute_spec.handler. */
4287 handle_common_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4288 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4290 if (TREE_CODE (*node
) == VAR_DECL
)
4291 DECL_COMMON (*node
) = 1;
4294 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4295 *no_add_attrs
= true;
4301 /* Handle a "noreturn" attribute; arguments as in
4302 struct attribute_spec.handler. */
4305 handle_noreturn_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4306 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4308 tree type
= TREE_TYPE (*node
);
4310 /* See FIXME comment in c_common_attribute_table. */
4311 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4312 TREE_THIS_VOLATILE (*node
) = 1;
4313 else if (TREE_CODE (type
) == POINTER_TYPE
4314 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4316 = build_pointer_type
4317 (build_type_variant (TREE_TYPE (type
),
4318 TREE_READONLY (TREE_TYPE (type
)), 1));
4321 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4322 *no_add_attrs
= true;
4328 /* Handle a "noinline" attribute; arguments as in
4329 struct attribute_spec.handler. */
4332 handle_noinline_attribute (tree
*node
, tree name
,
4333 tree args ATTRIBUTE_UNUSED
,
4334 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4336 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4337 DECL_UNINLINABLE (*node
) = 1;
4340 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4341 *no_add_attrs
= true;
4347 /* Handle a "always_inline" attribute; arguments as in
4348 struct attribute_spec.handler. */
4351 handle_always_inline_attribute (tree
*node
, tree name
,
4352 tree args ATTRIBUTE_UNUSED
,
4353 int flags ATTRIBUTE_UNUSED
,
4356 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4358 /* Do nothing else, just set the attribute. We'll get at
4359 it later with lookup_attribute. */
4363 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4364 *no_add_attrs
= true;
4370 /* Handle a "used" attribute; arguments as in
4371 struct attribute_spec.handler. */
4374 handle_used_attribute (tree
*pnode
, tree name
, tree args ATTRIBUTE_UNUSED
,
4375 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4379 if (TREE_CODE (node
) == FUNCTION_DECL
4380 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
4382 TREE_USED (node
) = 1;
4386 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4387 *no_add_attrs
= true;
4393 /* Handle a "unused" attribute; arguments as in
4394 struct attribute_spec.handler. */
4397 handle_unused_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4398 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4404 if (TREE_CODE (decl
) == PARM_DECL
4405 || TREE_CODE (decl
) == VAR_DECL
4406 || TREE_CODE (decl
) == FUNCTION_DECL
4407 || TREE_CODE (decl
) == LABEL_DECL
4408 || TREE_CODE (decl
) == TYPE_DECL
)
4409 TREE_USED (decl
) = 1;
4412 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4413 *no_add_attrs
= true;
4418 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4419 *node
= build_type_copy (*node
);
4420 TREE_USED (*node
) = 1;
4426 /* Handle a "const" attribute; arguments as in
4427 struct attribute_spec.handler. */
4430 handle_const_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4431 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4433 tree type
= TREE_TYPE (*node
);
4435 /* See FIXME comment on noreturn in c_common_attribute_table. */
4436 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4437 TREE_READONLY (*node
) = 1;
4438 else if (TREE_CODE (type
) == POINTER_TYPE
4439 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4441 = build_pointer_type
4442 (build_type_variant (TREE_TYPE (type
), 1,
4443 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
4446 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4447 *no_add_attrs
= true;
4453 /* Handle a "transparent_union" attribute; arguments as in
4454 struct attribute_spec.handler. */
4457 handle_transparent_union_attribute (tree
*node
, tree name
,
4458 tree args ATTRIBUTE_UNUSED
, int flags
,
4461 tree decl
= NULL_TREE
;
4468 type
= &TREE_TYPE (decl
);
4469 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
4471 else if (TYPE_P (*node
))
4472 type
= node
, is_type
= 1;
4475 && TREE_CODE (*type
) == UNION_TYPE
4477 || (TYPE_FIELDS (*type
) != 0
4478 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))))
4480 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4481 *type
= build_type_copy (*type
);
4482 TYPE_TRANSPARENT_UNION (*type
) = 1;
4484 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
4485 && TREE_CODE (*type
) == UNION_TYPE
4486 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))
4487 DECL_TRANSPARENT_UNION (decl
) = 1;
4490 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4491 *no_add_attrs
= true;
4497 /* Handle a "constructor" attribute; arguments as in
4498 struct attribute_spec.handler. */
4501 handle_constructor_attribute (tree
*node
, tree name
,
4502 tree args ATTRIBUTE_UNUSED
,
4503 int flags ATTRIBUTE_UNUSED
,
4507 tree type
= TREE_TYPE (decl
);
4509 if (TREE_CODE (decl
) == FUNCTION_DECL
4510 && TREE_CODE (type
) == FUNCTION_TYPE
4511 && decl_function_context (decl
) == 0)
4513 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
4514 TREE_USED (decl
) = 1;
4518 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4519 *no_add_attrs
= true;
4525 /* Handle a "destructor" attribute; arguments as in
4526 struct attribute_spec.handler. */
4529 handle_destructor_attribute (tree
*node
, tree name
,
4530 tree args ATTRIBUTE_UNUSED
,
4531 int flags ATTRIBUTE_UNUSED
,
4535 tree type
= TREE_TYPE (decl
);
4537 if (TREE_CODE (decl
) == FUNCTION_DECL
4538 && TREE_CODE (type
) == FUNCTION_TYPE
4539 && decl_function_context (decl
) == 0)
4541 DECL_STATIC_DESTRUCTOR (decl
) = 1;
4542 TREE_USED (decl
) = 1;
4546 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4547 *no_add_attrs
= true;
4553 /* Handle a "mode" attribute; arguments as in
4554 struct attribute_spec.handler. */
4557 handle_mode_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4558 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4562 *no_add_attrs
= true;
4564 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
4565 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4569 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
4570 int len
= strlen (p
);
4571 enum machine_mode mode
= VOIDmode
;
4575 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
4576 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
4578 char *newp
= alloca (len
- 1);
4580 strcpy (newp
, &p
[2]);
4581 newp
[len
- 4] = '\0';
4585 /* Change this type to have a type with the specified mode.
4586 First check for the special modes. */
4587 if (! strcmp (p
, "byte"))
4589 else if (!strcmp (p
, "word"))
4591 else if (! strcmp (p
, "pointer"))
4594 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
4595 if (!strcmp (p
, GET_MODE_NAME (j
)))
4596 mode
= (enum machine_mode
) j
;
4598 if (mode
== VOIDmode
)
4600 error ("unknown machine mode `%s'", p
);
4604 if (VECTOR_MODE_P (mode
))
4606 warning ("specifying vector types with __attribute__ ((mode)) "
4608 warning ("use __attribute__ ((vector_size)) instead");
4611 typefm
= lang_hooks
.types
.type_for_mode (mode
, TREE_UNSIGNED (type
));
4612 if (typefm
== NULL_TREE
)
4613 error ("no data type for mode `%s'", p
);
4615 else if ((TREE_CODE (type
) == POINTER_TYPE
4616 || TREE_CODE (type
) == REFERENCE_TYPE
)
4617 && !targetm
.valid_pointer_mode (mode
))
4618 error ("invalid pointer mode `%s'", p
);
4621 /* If this is a vector, make sure we either have hardware
4622 support, or we can emulate it. */
4623 if (VECTOR_MODE_P (mode
) && !vector_mode_valid_p (mode
))
4625 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
4629 if (TREE_CODE (type
) == POINTER_TYPE
)
4631 ptr_type
= build_pointer_type_for_mode (TREE_TYPE (type
),
4635 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
4637 ptr_type
= build_reference_type_for_mode (TREE_TYPE (type
),
4643 /* No need to layout the type here. The caller should do this. */
4650 /* Handle a "section" attribute; arguments as in
4651 struct attribute_spec.handler. */
4654 handle_section_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
, tree args
,
4655 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4659 if (targetm
.have_named_sections
)
4661 if ((TREE_CODE (decl
) == FUNCTION_DECL
4662 || TREE_CODE (decl
) == VAR_DECL
)
4663 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
4665 if (TREE_CODE (decl
) == VAR_DECL
4666 && current_function_decl
!= NULL_TREE
4667 && ! TREE_STATIC (decl
))
4669 error ("%Jsection attribute cannot be specified for "
4670 "local variables", decl
);
4671 *no_add_attrs
= true;
4674 /* The decl may have already been given a section attribute
4675 from a previous declaration. Ensure they match. */
4676 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
4677 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
4678 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
4680 error ("%Jsection of '%D' conflicts with previous declaration",
4682 *no_add_attrs
= true;
4685 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
4689 error ("%Jsection attribute not allowed for '%D'", *node
, *node
);
4690 *no_add_attrs
= true;
4695 error ("%Jsection attributes are not supported for this target", *node
);
4696 *no_add_attrs
= true;
4702 /* Handle a "aligned" attribute; arguments as in
4703 struct attribute_spec.handler. */
4706 handle_aligned_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
, tree args
,
4707 int flags
, bool *no_add_attrs
)
4709 tree decl
= NULL_TREE
;
4712 tree align_expr
= (args
? TREE_VALUE (args
)
4713 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
4719 type
= &TREE_TYPE (decl
);
4720 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
4722 else if (TYPE_P (*node
))
4723 type
= node
, is_type
= 1;
4725 /* Strip any NOPs of any kind. */
4726 while (TREE_CODE (align_expr
) == NOP_EXPR
4727 || TREE_CODE (align_expr
) == CONVERT_EXPR
4728 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
4729 align_expr
= TREE_OPERAND (align_expr
, 0);
4731 if (TREE_CODE (align_expr
) != INTEGER_CST
)
4733 error ("requested alignment is not a constant");
4734 *no_add_attrs
= true;
4736 else if ((i
= tree_log2 (align_expr
)) == -1)
4738 error ("requested alignment is not a power of 2");
4739 *no_add_attrs
= true;
4741 else if (i
> HOST_BITS_PER_INT
- 2)
4743 error ("requested alignment is too large");
4744 *no_add_attrs
= true;
4748 /* If we have a TYPE_DECL, then copy the type, so that we
4749 don't accidentally modify a builtin type. See pushdecl. */
4750 if (decl
&& TREE_TYPE (decl
) != error_mark_node
4751 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
4753 tree tt
= TREE_TYPE (decl
);
4754 *type
= build_type_copy (*type
);
4755 DECL_ORIGINAL_TYPE (decl
) = tt
;
4756 TYPE_NAME (*type
) = decl
;
4757 TREE_USED (*type
) = TREE_USED (decl
);
4758 TREE_TYPE (decl
) = *type
;
4760 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4761 *type
= build_type_copy (*type
);
4763 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
4764 TYPE_USER_ALIGN (*type
) = 1;
4766 else if (TREE_CODE (decl
) != VAR_DECL
4767 && TREE_CODE (decl
) != FIELD_DECL
)
4769 error ("%Jalignment may not be specified for '%D'", decl
, decl
);
4770 *no_add_attrs
= true;
4774 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
4775 DECL_USER_ALIGN (decl
) = 1;
4781 /* Handle a "weak" attribute; arguments as in
4782 struct attribute_spec.handler. */
4785 handle_weak_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
,
4786 tree args ATTRIBUTE_UNUSED
,
4787 int flags ATTRIBUTE_UNUSED
,
4788 bool *no_add_attrs ATTRIBUTE_UNUSED
)
4790 declare_weak (*node
);
4795 /* Handle an "alias" attribute; arguments as in
4796 struct attribute_spec.handler. */
4799 handle_alias_attribute (tree
*node
, tree name
, tree args
,
4800 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4804 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
4805 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
4807 error ("%J'%D' defined both normally and as an alias", decl
, decl
);
4808 *no_add_attrs
= true;
4811 /* Note that the very first time we process a nested declaration,
4812 decl_function_context will not be set. Indeed, *would* never
4813 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4814 we do below. After such frobbery, pushdecl would set the context.
4815 In any case, this is never what we want. */
4816 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
4820 id
= TREE_VALUE (args
);
4821 if (TREE_CODE (id
) != STRING_CST
)
4823 error ("alias arg not a string");
4824 *no_add_attrs
= true;
4827 id
= get_identifier (TREE_STRING_POINTER (id
));
4828 /* This counts as a use of the object pointed to. */
4831 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4832 DECL_INITIAL (decl
) = error_mark_node
;
4834 DECL_EXTERNAL (decl
) = 0;
4838 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4839 *no_add_attrs
= true;
4845 /* Handle an "visibility" attribute; arguments as in
4846 struct attribute_spec.handler. */
4849 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
4850 int flags ATTRIBUTE_UNUSED
,
4854 tree id
= TREE_VALUE (args
);
4856 *no_add_attrs
= true;
4858 if (decl_function_context (decl
) != 0 || ! TREE_PUBLIC (decl
))
4860 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4864 if (TREE_CODE (id
) != STRING_CST
)
4866 error ("visibility arg not a string");
4870 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
4871 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4872 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
4873 DECL_VISIBILITY (decl
) = VISIBILITY_INTERNAL
;
4874 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
4875 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
4876 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
4877 DECL_VISIBILITY (decl
) = VISIBILITY_PROTECTED
;
4879 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4884 /* Handle an "tls_model" attribute; arguments as in
4885 struct attribute_spec.handler. */
4888 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
4889 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4893 if (! DECL_THREAD_LOCAL (decl
))
4895 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4896 *no_add_attrs
= true;
4902 id
= TREE_VALUE (args
);
4903 if (TREE_CODE (id
) != STRING_CST
)
4905 error ("tls_model arg not a string");
4906 *no_add_attrs
= true;
4909 if (strcmp (TREE_STRING_POINTER (id
), "local-exec")
4910 && strcmp (TREE_STRING_POINTER (id
), "initial-exec")
4911 && strcmp (TREE_STRING_POINTER (id
), "local-dynamic")
4912 && strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
4914 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4915 *no_add_attrs
= true;
4923 /* Handle a "no_instrument_function" attribute; arguments as in
4924 struct attribute_spec.handler. */
4927 handle_no_instrument_function_attribute (tree
*node
, tree name
,
4928 tree args ATTRIBUTE_UNUSED
,
4929 int flags ATTRIBUTE_UNUSED
,
4934 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4936 error ("%J'%E' attribute applies only to functions", decl
, name
);
4937 *no_add_attrs
= true;
4939 else if (DECL_INITIAL (decl
))
4941 error ("%Jcan't set '%E' attribute after definition", decl
, name
);
4942 *no_add_attrs
= true;
4945 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
4950 /* Handle a "malloc" attribute; arguments as in
4951 struct attribute_spec.handler. */
4954 handle_malloc_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4955 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4957 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4958 DECL_IS_MALLOC (*node
) = 1;
4959 /* ??? TODO: Support types. */
4962 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4963 *no_add_attrs
= true;
4969 /* Handle a "no_limit_stack" attribute; arguments as in
4970 struct attribute_spec.handler. */
4973 handle_no_limit_stack_attribute (tree
*node
, tree name
,
4974 tree args ATTRIBUTE_UNUSED
,
4975 int flags ATTRIBUTE_UNUSED
,
4980 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4982 error ("%J'%E' attribute applies only to functions", decl
, name
);
4983 *no_add_attrs
= true;
4985 else if (DECL_INITIAL (decl
))
4987 error ("%Jcan't set '%E' attribute after definition", decl
, name
);
4988 *no_add_attrs
= true;
4991 DECL_NO_LIMIT_STACK (decl
) = 1;
4996 /* Handle a "pure" attribute; arguments as in
4997 struct attribute_spec.handler. */
5000 handle_pure_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
5001 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5003 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5004 DECL_IS_PURE (*node
) = 1;
5005 /* ??? TODO: Support types. */
5008 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5009 *no_add_attrs
= true;
5015 /* Handle a "deprecated" attribute; arguments as in
5016 struct attribute_spec.handler. */
5019 handle_deprecated_attribute (tree
*node
, tree name
,
5020 tree args ATTRIBUTE_UNUSED
, int flags
,
5023 tree type
= NULL_TREE
;
5025 const char *what
= NULL
;
5030 type
= TREE_TYPE (decl
);
5032 if (TREE_CODE (decl
) == TYPE_DECL
5033 || TREE_CODE (decl
) == PARM_DECL
5034 || TREE_CODE (decl
) == VAR_DECL
5035 || TREE_CODE (decl
) == FUNCTION_DECL
5036 || TREE_CODE (decl
) == FIELD_DECL
)
5037 TREE_DEPRECATED (decl
) = 1;
5041 else if (TYPE_P (*node
))
5043 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5044 *node
= build_type_copy (*node
);
5045 TREE_DEPRECATED (*node
) = 1;
5053 *no_add_attrs
= true;
5054 if (type
&& TYPE_NAME (type
))
5056 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
5057 what
= IDENTIFIER_POINTER (TYPE_NAME (*node
));
5058 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
5059 && DECL_NAME (TYPE_NAME (type
)))
5060 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
5063 warning ("`%s' attribute ignored for `%s'",
5064 IDENTIFIER_POINTER (name
), what
);
5066 warning ("`%s' attribute ignored",
5067 IDENTIFIER_POINTER (name
));
5073 /* Handle a "vector_size" attribute; arguments as in
5074 struct attribute_spec.handler. */
5077 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
5078 int flags ATTRIBUTE_UNUSED
,
5081 unsigned HOST_WIDE_INT vecsize
, nunits
;
5082 enum machine_mode mode
, orig_mode
, new_mode
;
5083 tree type
= *node
, new_type
, size
;
5085 *no_add_attrs
= true;
5087 /* Stripping NON_LVALUE_EXPR allows declarations such as
5088 typedef short v4si __attribute__((vector_size (4 * sizeof(short)))). */
5089 size
= TREE_VALUE (args
);
5090 if (TREE_CODE (size
) == NON_LVALUE_EXPR
)
5091 size
= TREE_OPERAND (size
, 0);
5093 if (! host_integerp (size
, 1))
5095 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5099 /* Get the vector size (in bytes). */
5100 vecsize
= tree_low_cst (size
, 1);
5102 /* We need to provide for vector pointers, vector arrays, and
5103 functions returning vectors. For example:
5105 __attribute__((vector_size(16))) short *foo;
5107 In this case, the mode is SI, but the type being modified is
5108 HI, so we need to look further. */
5110 while (POINTER_TYPE_P (type
)
5111 || TREE_CODE (type
) == FUNCTION_TYPE
5112 || TREE_CODE (type
) == METHOD_TYPE
5113 || TREE_CODE (type
) == ARRAY_TYPE
)
5114 type
= TREE_TYPE (type
);
5116 /* Get the mode of the type being modified. */
5117 orig_mode
= TYPE_MODE (type
);
5119 if (TREE_CODE (type
) == RECORD_TYPE
5120 || (GET_MODE_CLASS (orig_mode
) != MODE_FLOAT
5121 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
5122 || ! host_integerp (TYPE_SIZE_UNIT (type
), 1))
5124 error ("invalid vector type for attribute `%s'",
5125 IDENTIFIER_POINTER (name
));
5129 /* Calculate how many units fit in the vector. */
5130 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5132 /* Find a suitably sized vector. */
5133 new_mode
= VOIDmode
;
5134 for (mode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode
) == MODE_INT
5136 : MODE_VECTOR_FLOAT
);
5138 mode
= GET_MODE_WIDER_MODE (mode
))
5139 if (vecsize
== GET_MODE_SIZE (mode
)
5140 && nunits
== (unsigned HOST_WIDE_INT
) GET_MODE_NUNITS (mode
))
5146 if (new_mode
== VOIDmode
)
5148 error ("no vector mode with the size and type specified could be found");
5152 new_type
= build_vector_type_for_mode (type
, new_mode
);
5154 /* Build back pointers if needed. */
5155 *node
= reconstruct_complex_type (*node
, new_type
);
5160 /* Handle the "nonnull" attribute. */
5162 handle_nonnull_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
,
5163 tree args
, int flags ATTRIBUTE_UNUSED
,
5167 unsigned HOST_WIDE_INT attr_arg_num
;
5169 /* If no arguments are specified, all pointer arguments should be
5170 non-null. Verify a full prototype is given so that the arguments
5171 will have the correct types when we actually check them later. */
5174 if (! TYPE_ARG_TYPES (type
))
5176 error ("nonnull attribute without arguments on a non-prototype");
5177 *no_add_attrs
= true;
5182 /* Argument list specified. Verify that each argument number references
5183 a pointer argument. */
5184 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
5187 unsigned HOST_WIDE_INT arg_num
, ck_num
;
5189 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5191 error ("nonnull argument has invalid operand number (arg %lu)",
5192 (unsigned long) attr_arg_num
);
5193 *no_add_attrs
= true;
5197 argument
= TYPE_ARG_TYPES (type
);
5200 for (ck_num
= 1; ; ck_num
++)
5202 if (! argument
|| ck_num
== arg_num
)
5204 argument
= TREE_CHAIN (argument
);
5208 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
5210 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5211 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5212 *no_add_attrs
= true;
5216 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
5218 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5219 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5220 *no_add_attrs
= true;
5229 /* Check the argument list of a function call for null in argument slots
5230 that are marked as requiring a non-null pointer argument. */
5233 check_function_nonnull (tree attrs
, tree params
)
5235 tree a
, args
, param
;
5238 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
5240 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
5242 args
= TREE_VALUE (a
);
5244 /* Walk the argument list. If we encounter an argument number we
5245 should check for non-null, do it. If the attribute has no args,
5246 then every pointer argument is checked (in which case the check
5247 for pointer type is done in check_nonnull_arg). */
5248 for (param
= params
, param_num
= 1; ;
5249 param_num
++, param
= TREE_CHAIN (param
))
5253 if (! args
|| nonnull_check_p (args
, param_num
))
5254 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
5262 /* Helper for check_function_nonnull; given a list of operands which
5263 must be non-null in ARGS, determine if operand PARAM_NUM should be
5267 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
5269 unsigned HOST_WIDE_INT arg_num
;
5271 for (; args
; args
= TREE_CHAIN (args
))
5273 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5276 if (arg_num
== param_num
)
5282 /* Check that the function argument PARAM (which is operand number
5283 PARAM_NUM) is non-null. This is called by check_function_nonnull
5284 via check_function_arguments_recurse. */
5287 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED
, tree param
,
5288 unsigned HOST_WIDE_INT param_num
)
5290 /* Just skip checking the argument if it's not a pointer. This can
5291 happen if the "nonnull" attribute was given without an operand
5292 list (which means to check every pointer argument). */
5294 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
5297 if (integer_zerop (param
))
5298 warning ("null argument where non-null required (arg %lu)",
5299 (unsigned long) param_num
);
5302 /* Helper for nonnull attribute handling; fetch the operand number
5303 from the attribute argument list. */
5306 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
5308 /* Strip any conversions from the arg number and verify they
5310 while (TREE_CODE (arg_num_expr
) == NOP_EXPR
5311 || TREE_CODE (arg_num_expr
) == CONVERT_EXPR
5312 || TREE_CODE (arg_num_expr
) == NON_LVALUE_EXPR
)
5313 arg_num_expr
= TREE_OPERAND (arg_num_expr
, 0);
5315 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
5316 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
5319 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
5323 /* Handle a "nothrow" attribute; arguments as in
5324 struct attribute_spec.handler. */
5327 handle_nothrow_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
5328 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5330 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5331 TREE_NOTHROW (*node
) = 1;
5332 /* ??? TODO: Support types. */
5335 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5336 *no_add_attrs
= true;
5342 /* Handle a "cleanup" attribute; arguments as in
5343 struct attribute_spec.handler. */
5346 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
5347 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5350 tree cleanup_id
, cleanup_decl
;
5352 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5353 for global destructors in C++. This requires infrastructure that
5354 we don't have generically at the moment. It's also not a feature
5355 we'd be missing too much, since we do have attribute constructor. */
5356 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
5358 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5359 *no_add_attrs
= true;
5363 /* Verify that the argument is a function in scope. */
5364 /* ??? We could support pointers to functions here as well, if
5365 that was considered desirable. */
5366 cleanup_id
= TREE_VALUE (args
);
5367 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
5369 error ("cleanup arg not an identifier");
5370 *no_add_attrs
= true;
5373 cleanup_decl
= lookup_name (cleanup_id
);
5374 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
5376 error ("cleanup arg not a function");
5377 *no_add_attrs
= true;
5381 /* That the function has proper type is checked with the
5382 eventual call to build_function_call. */
5387 /* Handle a "warn_unused_result" attribute. No special handling. */
5390 handle_warn_unused_result_attribute (tree
*node
, tree name
,
5391 tree args ATTRIBUTE_UNUSED
,
5392 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5394 /* Ignore the attribute for functions not returning any value. */
5395 if (VOID_TYPE_P (TREE_TYPE (*node
)))
5397 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5398 *no_add_attrs
= true;
5404 /* Check for valid arguments being passed to a function. */
5406 check_function_arguments (tree attrs
, tree params
)
5408 /* Check for null being passed in a pointer argument that must be
5409 non-null. We also need to do this if format checking is enabled. */
5412 check_function_nonnull (attrs
, params
);
5414 /* Check for errors in format strings. */
5417 check_function_format (NULL
, attrs
, params
);
5420 /* Generic argument checking recursion routine. PARAM is the argument to
5421 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5422 once the argument is resolved. CTX is context for the callback. */
5424 check_function_arguments_recurse (void (*callback
)
5425 (void *, tree
, unsigned HOST_WIDE_INT
),
5426 void *ctx
, tree param
,
5427 unsigned HOST_WIDE_INT param_num
)
5429 if (TREE_CODE (param
) == NOP_EXPR
)
5431 /* Strip coercion. */
5432 check_function_arguments_recurse (callback
, ctx
,
5433 TREE_OPERAND (param
, 0), param_num
);
5437 if (TREE_CODE (param
) == CALL_EXPR
)
5439 tree type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (param
, 0)));
5441 bool found_format_arg
= false;
5443 /* See if this is a call to a known internationalization function
5444 that modifies a format arg. Such a function may have multiple
5445 format_arg attributes (for example, ngettext). */
5447 for (attrs
= TYPE_ATTRIBUTES (type
);
5449 attrs
= TREE_CHAIN (attrs
))
5450 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
5453 tree format_num_expr
;
5457 /* Extract the argument number, which was previously checked
5459 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
5460 while (TREE_CODE (format_num_expr
) == NOP_EXPR
5461 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
5462 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
5463 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
5465 if (TREE_CODE (format_num_expr
) != INTEGER_CST
5466 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
5469 format_num
= TREE_INT_CST_LOW (format_num_expr
);
5471 for (inner_args
= TREE_OPERAND (param
, 1), i
= 1;
5473 inner_args
= TREE_CHAIN (inner_args
), i
++)
5474 if (i
== format_num
)
5476 check_function_arguments_recurse (callback
, ctx
,
5477 TREE_VALUE (inner_args
),
5479 found_format_arg
= true;
5484 /* If we found a format_arg attribute and did a recursive check,
5485 we are done with checking this argument. Otherwise, we continue
5486 and this will be considered a non-literal. */
5487 if (found_format_arg
)
5491 if (TREE_CODE (param
) == COND_EXPR
)
5493 /* Check both halves of the conditional expression. */
5494 check_function_arguments_recurse (callback
, ctx
,
5495 TREE_OPERAND (param
, 1), param_num
);
5496 check_function_arguments_recurse (callback
, ctx
,
5497 TREE_OPERAND (param
, 2), param_num
);
5501 (*callback
) (ctx
, param
, param_num
);
5504 /* Function to help qsort sort FIELD_DECLs by name order. */
5507 field_decl_cmp (const void *x_p
, const void *y_p
)
5509 const tree
*const x
= x_p
;
5510 const tree
*const y
= y_p
;
5511 if (DECL_NAME (*x
) == DECL_NAME (*y
))
5512 /* A nontype is "greater" than a type. */
5513 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
5514 if (DECL_NAME (*x
) == NULL_TREE
)
5516 if (DECL_NAME (*y
) == NULL_TREE
)
5518 if (DECL_NAME (*x
) < DECL_NAME (*y
))
5524 gt_pointer_operator new_value
;
5528 /* This routine compares two fields like field_decl_cmp but using the
5529 pointer operator in resort_data. */
5532 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
5534 const tree
*const x
= x_p
;
5535 const tree
*const y
= y_p
;
5537 if (DECL_NAME (*x
) == DECL_NAME (*y
))
5538 /* A nontype is "greater" than a type. */
5539 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
5540 if (DECL_NAME (*x
) == NULL_TREE
)
5542 if (DECL_NAME (*y
) == NULL_TREE
)
5545 tree d1
= DECL_NAME (*x
);
5546 tree d2
= DECL_NAME (*y
);
5547 resort_data
.new_value (&d1
, resort_data
.cookie
);
5548 resort_data
.new_value (&d2
, resort_data
.cookie
);
5555 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5558 resort_sorted_fields (void *obj
,
5559 void *orig_obj ATTRIBUTE_UNUSED
,
5560 gt_pointer_operator new_value
,
5563 struct sorted_fields_type
*sf
= obj
;
5564 resort_data
.new_value
= new_value
;
5565 resort_data
.cookie
= cookie
;
5566 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
5567 resort_field_decl_cmp
);
5570 /* Used by estimate_num_insns. Estimate number of instructions seen
5571 by given statement. */
5573 c_estimate_num_insns_1 (tree
*tp
, int *walk_subtrees
, void *data
)
5578 if (TYPE_P (x
) || DECL_P (x
))
5583 /* Assume that constants and references counts nothing. These should
5584 be majorized by amount of operations among them we count later
5585 and are common target of CSE and similar optimizations. */
5586 if (TREE_CODE_CLASS (TREE_CODE (x
)) == 'c'
5587 || TREE_CODE_CLASS (TREE_CODE (x
)) == 'r')
5589 switch (TREE_CODE (x
))
5591 /* Recognize assignments of large structures and constructors of
5598 size
= int_size_in_bytes (TREE_TYPE (x
));
5600 if (size
< 0 || size
> MOVE_MAX_PIECES
* MOVE_RATIO
)
5603 *count
+= ((size
+ MOVE_MAX_PIECES
- 1) / MOVE_MAX_PIECES
);
5608 tree decl
= get_callee_fndecl (x
);
5610 if (decl
&& DECL_BUILT_IN (decl
))
5611 switch (DECL_FUNCTION_CODE (decl
))
5613 case BUILT_IN_CONSTANT_P
:
5616 case BUILT_IN_EXPECT
:
5624 /* Few special cases of expensive operations. This is useful
5625 to avoid inlining on functions having too many of these. */
5626 case TRUNC_DIV_EXPR
:
5628 case FLOOR_DIV_EXPR
:
5629 case ROUND_DIV_EXPR
:
5630 case TRUNC_MOD_EXPR
:
5632 case FLOOR_MOD_EXPR
:
5633 case ROUND_MOD_EXPR
:
5637 /* Various containers that will produce no code themselves. */
5644 case IDENTIFIER_NODE
:
5645 case PLACEHOLDER_EXPR
:
5646 case WITH_CLEANUP_EXPR
:
5647 case CLEANUP_POINT_EXPR
:
5649 case VIEW_CONVERT_EXPR
:
5655 case TRY_CATCH_EXPR
:
5656 case TRY_FINALLY_EXPR
:
5659 case LABELED_BLOCK_EXPR
:
5660 case EXIT_BLOCK_EXPR
:
5661 case EXPR_WITH_FILE_LOCATION
:
5678 /* Do not account static initializers. */
5679 if (TREE_STATIC (TREE_OPERAND (x
, 0)))
5688 /* Estimate number of instructions that will be created by expanding the body. */
5690 c_estimate_num_insns (tree decl
)
5693 walk_tree_without_duplicates (&DECL_SAVED_TREE (decl
), c_estimate_num_insns_1
, &num
);
5697 /* Used by c_decl_uninit to find where expressions like x = x + 1; */
5700 c_decl_uninit_1 (tree
*t
, int *walk_sub_trees
, void *x
)
5702 /* If x = EXP(&x)EXP, then do not warn about the use of x. */
5703 if (TREE_CODE (*t
) == ADDR_EXPR
&& TREE_OPERAND (*t
, 0) == x
)
5705 *walk_sub_trees
= 0;
5713 /* Find out if a variable is uninitialized based on DECL_INITIAL. */
5716 c_decl_uninit (tree t
)
5718 /* int x = x; is GCC extension to turn off this warning, only if warn_init_self is zero. */
5719 if (DECL_INITIAL (t
) == t
)
5720 return warn_init_self
? true : false;
5722 /* Walk the trees looking for the variable itself. */
5723 if (walk_tree_without_duplicates (&DECL_INITIAL (t
), c_decl_uninit_1
, t
))
5728 /* Issue the error given by MSGID, indicating that it occurred before
5729 TOKEN, which had the associated VALUE. */
5732 c_parse_error (const char *msgid
, enum cpp_ttype token
, tree value
)
5734 const char *string
= _(msgid
);
5736 if (token
== CPP_EOF
)
5737 error ("%s at end of input", string
);
5738 else if (token
== CPP_CHAR
|| token
== CPP_WCHAR
)
5740 unsigned int val
= TREE_INT_CST_LOW (value
);
5741 const char *const ell
= (token
== CPP_CHAR
) ? "" : "L";
5742 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
5743 error ("%s before %s'%c'", string
, ell
, val
);
5745 error ("%s before %s'\\x%x'", string
, ell
, val
);
5747 else if (token
== CPP_STRING
5748 || token
== CPP_WSTRING
)
5749 error ("%s before string constant", string
);
5750 else if (token
== CPP_NUMBER
)
5751 error ("%s before numeric constant", string
);
5752 else if (token
== CPP_NAME
)
5753 error ("%s before \"%s\"", string
, IDENTIFIER_POINTER (value
));
5754 else if (token
< N_TTYPES
)
5755 error ("%s before '%s' token", string
, cpp_type2name (token
));
5757 error ("%s", string
);
5760 #include "gt-c-common.h"