1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 #include "tree-iterator.h"
48 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
50 /* We let tm.h override the types used here, to handle trivial differences
51 such as the choice of unsigned int or long unsigned int for size_t.
52 When machines start needing nontrivial differences in the size type,
53 it would be best to do something here to figure out automatically
54 from other information what type to use. */
57 #define SIZE_TYPE "long unsigned int"
61 #define PID_TYPE "int"
65 #define WCHAR_TYPE "int"
68 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
69 #define MODIFIED_WCHAR_TYPE \
70 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
73 #define PTRDIFF_TYPE "long int"
77 #define WINT_TYPE "unsigned int"
81 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
89 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
91 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
92 ? "long unsigned int" \
93 : "long long unsigned int"))
96 /* The following symbols are subsumed in the c_global_trees array, and
97 listed here individually for documentation purposes.
99 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
101 tree short_integer_type_node;
102 tree long_integer_type_node;
103 tree long_long_integer_type_node;
105 tree short_unsigned_type_node;
106 tree long_unsigned_type_node;
107 tree long_long_unsigned_type_node;
109 tree truthvalue_type_node;
110 tree truthvalue_false_node;
111 tree truthvalue_true_node;
113 tree ptrdiff_type_node;
115 tree unsigned_char_type_node;
116 tree signed_char_type_node;
117 tree wchar_type_node;
118 tree signed_wchar_type_node;
119 tree unsigned_wchar_type_node;
121 tree float_type_node;
122 tree double_type_node;
123 tree long_double_type_node;
125 tree complex_integer_type_node;
126 tree complex_float_type_node;
127 tree complex_double_type_node;
128 tree complex_long_double_type_node;
130 tree intQI_type_node;
131 tree intHI_type_node;
132 tree intSI_type_node;
133 tree intDI_type_node;
134 tree intTI_type_node;
136 tree unsigned_intQI_type_node;
137 tree unsigned_intHI_type_node;
138 tree unsigned_intSI_type_node;
139 tree unsigned_intDI_type_node;
140 tree unsigned_intTI_type_node;
142 tree widest_integer_literal_type_node;
143 tree widest_unsigned_literal_type_node;
145 Nodes for types `void *' and `const void *'.
147 tree ptr_type_node, const_ptr_type_node;
149 Nodes for types `char *' and `const char *'.
151 tree string_type_node, const_string_type_node;
153 Type `char[SOMENUMBER]'.
154 Used when an array of char is needed and the size is irrelevant.
156 tree char_array_type_node;
158 Type `int[SOMENUMBER]' or something like it.
159 Used when an array of int needed and the size is irrelevant.
161 tree int_array_type_node;
163 Type `wchar_t[SOMENUMBER]' or something like it.
164 Used when a wide string literal is created.
166 tree wchar_array_type_node;
168 Type `int ()' -- used for implicit declaration of functions.
170 tree default_function_type;
172 A VOID_TYPE node, packaged in a TREE_LIST.
176 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
177 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
178 VAR_DECLS, but C++ does.)
180 tree function_name_decl_node;
181 tree pretty_function_name_decl_node;
182 tree c99_function_name_decl_node;
184 Stack of nested function name VAR_DECLs.
186 tree saved_function_name_decls;
190 tree c_global_trees
[CTI_MAX
];
192 /* TRUE if a code represents a statement. The front end init
193 langhook should take care of initialization of this array. */
195 bool statement_code_p
[MAX_TREE_CODES
];
197 /* Switches common to the C front ends. */
199 /* Nonzero if prepreprocessing only. */
201 int flag_preprocess_only
;
203 /* Nonzero means don't output line number information. */
205 char flag_no_line_commands
;
207 /* Nonzero causes -E output not to be done, but directives such as
208 #define that have side effects are still obeyed. */
212 /* Nonzero means dump macros in some fashion. */
214 char flag_dump_macros
;
216 /* Nonzero means pass #include lines through to the output. */
218 char flag_dump_includes
;
220 /* The file name to which we should write a precompiled header, or
221 NULL if no header will be written in this compile. */
223 const char *pch_file
;
225 /* Nonzero if an ISO standard was selected. It rejects macros in the
229 /* Nonzero if -undef was given. It suppresses target built-in macros
233 /* Nonzero means don't recognize the non-ANSI builtin functions. */
237 /* Nonzero means don't recognize the non-ANSI builtin functions.
240 int flag_no_nonansi_builtin
;
242 /* Nonzero means give `double' the same size as `float'. */
244 int flag_short_double
;
246 /* Nonzero means give `wchar_t' the same size as `short'. */
248 int flag_short_wchar
;
250 /* Nonzero means allow Microsoft extensions without warnings or errors. */
251 int flag_ms_extensions
;
253 /* Nonzero means don't recognize the keyword `asm'. */
257 /* Nonzero means give string constants the type `const char *', as mandated
260 int flag_const_strings
;
262 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
264 int flag_signed_bitfields
= 1;
265 int explicit_flag_signed_bitfields
;
267 /* Nonzero means warn about pointer casts that can drop a type qualifier
268 from the pointer target type. */
272 /* Warn about functions which might be candidates for format attributes. */
274 int warn_missing_format_attribute
;
276 /* Nonzero means warn about sizeof(function) or addition/subtraction
277 of function pointers. */
279 int warn_pointer_arith
;
281 /* Nonzero means warn for any global function def
282 without separate previous prototype decl. */
284 int warn_missing_prototypes
;
286 /* Warn if adding () is suggested. */
288 int warn_parentheses
;
290 /* Warn if initializer is not completely bracketed. */
292 int warn_missing_braces
;
294 /* Warn about comparison of signed and unsigned values.
295 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified
296 (in which case -Wextra gets to decide). */
298 int warn_sign_compare
= -1;
300 /* Nonzero means warn about usage of long long when `-pedantic'. */
302 int warn_long_long
= 1;
304 /* Nonzero means warn about deprecated conversion from string constant to
307 int warn_write_strings
;
309 /* Nonzero means warn about multiple (redundant) decls for the same single
310 variable or function. */
312 int warn_redundant_decls
;
314 /* Warn about testing equality of floating point numbers. */
316 int warn_float_equal
;
318 /* Warn about a subscript that has type char. */
320 int warn_char_subscripts
;
322 /* Warn if a type conversion is done that might have confusing results. */
326 /* Warn about #pragma directives that are not recognized. */
328 int warn_unknown_pragmas
; /* Tri state variable. */
330 /* Warn about format/argument anomalies in calls to formatted I/O functions
331 (*printf, *scanf, strftime, strfmon, etc.). */
335 /* Warn about Y2K problems with strftime formats. */
339 /* Warn about excess arguments to formats. */
341 int warn_format_extra_args
;
343 /* Warn about zero-length formats. */
345 int warn_format_zero_length
;
347 /* Warn about non-literal format arguments. */
349 int warn_format_nonliteral
;
351 /* Warn about possible security problems with calls to format functions. */
353 int warn_format_security
;
355 /* Zero means that faster, ...NonNil variants of objc_msgSend...
356 calls will be used in ObjC; passing nil receivers to such calls
357 will most likely result in crashes. */
358 int flag_nil_receivers
= 1;
360 /* Nonzero means that we will allow new ObjC exception syntax (@throw,
361 @try, etc.) in source code. */
362 int flag_objc_exceptions
= 0;
364 /* Nonzero means that we generate NeXT setjmp based exceptions. */
365 int flag_objc_sjlj_exceptions
= -1;
367 /* Nonzero means that code generation will be altered to support
368 "zero-link" execution. This currently affects ObjC only, but may
369 affect other languages in the future. */
370 int flag_zero_link
= 0;
372 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
373 unit. It will inform the ObjC runtime that class definition(s) herein
374 contained are to replace one(s) previously loaded. */
375 int flag_replace_objc_classes
= 0;
377 /* C/ObjC language option variables. */
380 /* Nonzero means message about use of implicit function declarations;
381 1 means warning; 2 means error. */
383 int mesg_implicit_function_declaration
= -1;
385 /* Nonzero means allow type mismatches in conditional expressions;
386 just make their values `void'. */
388 int flag_cond_mismatch
;
390 /* Nonzero means enable C89 Amendment 1 features. */
394 /* Nonzero means use the ISO C99 dialect of C. */
398 /* Nonzero means that we have builtin functions, and main is an int. */
402 /* Nonzero means warn when casting a function call to a type that does
403 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
404 when there is no previous declaration of sqrt or malloc. */
406 int warn_bad_function_cast
;
408 /* Warn about traditional constructs whose meanings changed in ANSI C. */
410 int warn_traditional
;
412 /* Nonzero means warn for a declaration found after a statement. */
414 int warn_declaration_after_statement
;
416 /* Nonzero means warn for non-prototype function decls
417 or non-prototyped defs without previous prototype. */
419 int warn_strict_prototypes
;
421 /* Nonzero means warn for any global function def
422 without separate previous decl. */
424 int warn_missing_declarations
;
426 /* Nonzero means warn about declarations of objects not at
427 file-scope level and about *all* declarations of functions (whether
428 or static) not at file-scope level. Note that we exclude
429 implicit function declarations. To get warnings about those, use
432 int warn_nested_externs
;
434 /* Warn if main is suspicious. */
438 /* Nonzero means warn about possible violations of sequence point rules. */
440 int warn_sequence_point
;
442 /* Nonzero means warn about uninitialized variable when it is initialized with itself.
443 For example: int i = i;, GCC will not warn about this when warn_init_self is nonzero. */
447 /* Nonzero means to warn about compile-time division by zero. */
448 int warn_div_by_zero
= 1;
450 /* Nonzero means warn about use of implicit int. */
452 int warn_implicit_int
;
454 /* Warn about NULL being passed to argument slots marked as requiring
459 /* Warn about old-style parameter declaration. */
461 int warn_old_style_definition
;
464 /* ObjC language option variables. */
467 /* Open and close the file for outputting class declarations, if
470 int flag_gen_declaration
;
472 /* Generate code for GNU or NeXT runtime environment. */
474 #ifdef NEXT_OBJC_RUNTIME
475 int flag_next_runtime
= 1;
477 int flag_next_runtime
= 0;
480 /* Tells the compiler that this is a special run. Do not perform any
481 compiling, instead we are to test some platform dependent features
482 and output a C header file with appropriate definitions. */
484 int print_struct_values
;
486 /* ???. Undocumented. */
488 const char *constant_string_class_name
;
490 /* Warn if multiple methods are seen for the same selector, but with
491 different argument types. Performs the check on the whole selector
492 table at the end of compilation. */
496 /* Warn if a @selector() is found, and no method with that selector
497 has been previously declared. The check is done on each
498 @selector() as soon as it is found - so it warns about forward
501 int warn_undeclared_selector
;
503 /* Warn if methods required by a protocol are not implemented in the
504 class adopting it. When turned off, methods inherited to that
505 class are also considered implemented. */
507 int warn_protocol
= 1;
510 /* C++ language option variables. */
513 /* Nonzero means don't recognize any extension keywords. */
515 int flag_no_gnu_keywords
;
517 /* Nonzero means do emit exported implementations of functions even if
518 they can be inlined. */
520 int flag_implement_inlines
= 1;
522 /* Nonzero means that implicit instantiations will be emitted if needed. */
524 int flag_implicit_templates
= 1;
526 /* Nonzero means that implicit instantiations of inline templates will be
527 emitted if needed, even if instantiations of non-inline templates
530 int flag_implicit_inline_templates
= 1;
532 /* Nonzero means generate separate instantiation control files and
533 juggle them at link time. */
535 int flag_use_repository
;
537 /* Nonzero if we want to issue diagnostics that the standard says are not
540 int flag_optional_diags
= 1;
542 /* Nonzero means we should attempt to elide constructors when possible. */
544 int flag_elide_constructors
= 1;
546 /* Nonzero means that member functions defined in class scope are
547 inline by default. */
549 int flag_default_inline
= 1;
551 /* Controls whether compiler generates 'type descriptor' that give
552 run-time type information. */
556 /* Nonzero if we want to conserve space in the .o files. We do this
557 by putting uninitialized data and runtime initialized data into
558 .common instead of .data at the expense of not flagging multiple
561 int flag_conserve_space
;
563 /* Nonzero if we want to obey access control semantics. */
565 int flag_access_control
= 1;
567 /* Nonzero if we want to check the return value of new and avoid calling
568 constructors if it is a null pointer. */
572 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
573 initialization variables.
574 0: Old rules, set by -fno-for-scope.
575 2: New ISO rules, set by -ffor-scope.
576 1: Try to implement new ISO rules, but with backup compatibility
577 (and warnings). This is the default, for now. */
579 int flag_new_for_scope
= 1;
581 /* Nonzero if we want to emit defined symbols with common-like linkage as
582 weak symbols where possible, in order to conform to C++ semantics.
583 Otherwise, emit them as local symbols. */
587 /* 0 means we want the preprocessor to not emit line directives for
588 the current working directory. 1 means we want it to do it. -1
589 means we should decide depending on whether debugging information
590 is being emitted or not. */
592 int flag_working_directory
= -1;
594 /* Nonzero to use __cxa_atexit, rather than atexit, to register
595 destructors for local statics and global objects. */
597 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
599 /* Nonzero means make the default pedwarns warnings instead of errors.
600 The value of this flag is ignored if -pedantic is specified. */
604 /* Nonzero means to implement standard semantics for exception
605 specifications, calling unexpected if an exception is thrown that
606 doesn't match the specification. Zero means to treat them as
607 assertions and optimize accordingly, but not check them. */
609 int flag_enforce_eh_specs
= 1;
611 /* Nonzero means warn about things that will change when compiling
612 with an ABI-compliant compiler. */
616 /* Nonzero means warn about invalid uses of offsetof. */
618 int warn_invalid_offsetof
= 1;
620 /* Nonzero means warn about implicit declarations. */
622 int warn_implicit
= 1;
624 /* Nonzero means warn when all ctors or dtors are private, and the class
627 int warn_ctor_dtor_privacy
= 0;
629 /* Nonzero means warn in function declared in derived class has the
630 same name as a virtual in the base class, but fails to match the
631 type signature of any virtual function in the base class. */
633 int warn_overloaded_virtual
;
635 /* Nonzero means warn when declaring a class that has a non virtual
636 destructor, when it really ought to have a virtual one. */
640 /* Nonzero means warn when the compiler will reorder code. */
644 /* Nonzero means warn when synthesis behavior differs from Cfront's. */
648 /* Nonzero means warn when we convert a pointer to member function
649 into a pointer to (void or function). */
651 int warn_pmf2ptr
= 1;
653 /* Nonzero means warn about violation of some Effective C++ style rules. */
657 /* Nonzero means warn where overload resolution chooses a promotion from
658 unsigned to signed over a conversion to an unsigned of the same size. */
662 /* Nonzero means warn when an old-style cast is used. */
664 int warn_old_style_cast
;
666 /* Nonzero means warn when non-templatized friend functions are
667 declared within a template */
669 int warn_nontemplate_friend
= 1;
671 /* Nonzero means complain about deprecated features. */
673 int warn_deprecated
= 1;
675 /* Maximum template instantiation depth. This limit is rather
676 arbitrary, but it exists to limit the time it takes to notice
677 infinite template instantiations. */
679 int max_tinst_depth
= 500;
683 /* The elements of `ridpointers' are identifier nodes for the reserved
684 type names and storage classes. It is indexed by a RID_... value. */
687 tree (*make_fname_decl
) (tree
, int);
689 /* If non-NULL, the address of a language-specific function that
690 returns 1 for language-specific statement codes. */
691 int (*lang_statement_code_p
) (enum tree_code
);
693 /* If non-NULL, the address of a language-specific function that takes
694 any action required right before expand_function_end is called. */
695 void (*lang_expand_function_end
) (void);
697 /* Nonzero means the expression being parsed will never be evaluated.
698 This is a count, since unevaluated expressions can nest. */
701 /* Information about how a function name is generated. */
704 tree
*const decl
; /* pointer to the VAR_DECL. */
705 const unsigned rid
; /* RID number for the identifier. */
706 const int pretty
; /* How pretty is it? */
709 /* The three ways of getting then name of the current function. */
711 const struct fname_var_t fname_vars
[] =
713 /* C99 compliant __func__, must be first. */
714 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
715 /* GCC __FUNCTION__ compliant. */
716 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
717 /* GCC __PRETTY_FUNCTION__ compliant. */
718 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
722 static int constant_fits_type_p (tree
, tree
);
724 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
725 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
726 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
727 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
728 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
729 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
731 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
732 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
733 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
734 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
736 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
737 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
738 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
739 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
740 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
741 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
742 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
743 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
745 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
747 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
749 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
750 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
752 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
753 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
755 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
757 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
758 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
759 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
760 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
763 static void check_function_nonnull (tree
, tree
);
764 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
765 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
766 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
767 static int resort_field_decl_cmp (const void *, const void *);
769 /* Table of machine-independent attributes common to all C-like languages. */
770 const struct attribute_spec c_common_attribute_table
[] =
772 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
773 { "packed", 0, 0, false, false, false,
774 handle_packed_attribute
},
775 { "nocommon", 0, 0, true, false, false,
776 handle_nocommon_attribute
},
777 { "common", 0, 0, true, false, false,
778 handle_common_attribute
},
779 /* FIXME: logically, noreturn attributes should be listed as
780 "false, true, true" and apply to function types. But implementing this
781 would require all the places in the compiler that use TREE_THIS_VOLATILE
782 on a decl to identify non-returning functions to be located and fixed
783 to check the function type instead. */
784 { "noreturn", 0, 0, true, false, false,
785 handle_noreturn_attribute
},
786 { "volatile", 0, 0, true, false, false,
787 handle_noreturn_attribute
},
788 { "noinline", 0, 0, true, false, false,
789 handle_noinline_attribute
},
790 { "always_inline", 0, 0, true, false, false,
791 handle_always_inline_attribute
},
792 { "used", 0, 0, true, false, false,
793 handle_used_attribute
},
794 { "unused", 0, 0, false, false, false,
795 handle_unused_attribute
},
796 /* The same comments as for noreturn attributes apply to const ones. */
797 { "const", 0, 0, true, false, false,
798 handle_const_attribute
},
799 { "transparent_union", 0, 0, false, false, false,
800 handle_transparent_union_attribute
},
801 { "constructor", 0, 0, true, false, false,
802 handle_constructor_attribute
},
803 { "destructor", 0, 0, true, false, false,
804 handle_destructor_attribute
},
805 { "mode", 1, 1, false, true, false,
806 handle_mode_attribute
},
807 { "section", 1, 1, true, false, false,
808 handle_section_attribute
},
809 { "aligned", 0, 1, false, false, false,
810 handle_aligned_attribute
},
811 { "weak", 0, 0, true, false, false,
812 handle_weak_attribute
},
813 { "alias", 1, 1, true, false, false,
814 handle_alias_attribute
},
815 { "no_instrument_function", 0, 0, true, false, false,
816 handle_no_instrument_function_attribute
},
817 { "malloc", 0, 0, true, false, false,
818 handle_malloc_attribute
},
819 { "no_stack_limit", 0, 0, true, false, false,
820 handle_no_limit_stack_attribute
},
821 { "pure", 0, 0, true, false, false,
822 handle_pure_attribute
},
823 { "deprecated", 0, 0, false, false, false,
824 handle_deprecated_attribute
},
825 { "vector_size", 1, 1, false, true, false,
826 handle_vector_size_attribute
},
827 { "visibility", 1, 1, true, false, false,
828 handle_visibility_attribute
},
829 { "tls_model", 1, 1, true, false, false,
830 handle_tls_model_attribute
},
831 { "nonnull", 0, -1, false, true, true,
832 handle_nonnull_attribute
},
833 { "nothrow", 0, 0, true, false, false,
834 handle_nothrow_attribute
},
835 { "may_alias", 0, 0, false, true, false, NULL
},
836 { "cleanup", 1, 1, true, false, false,
837 handle_cleanup_attribute
},
838 { "warn_unused_result", 0, 0, false, true, true,
839 handle_warn_unused_result_attribute
},
840 { NULL
, 0, 0, false, false, false, NULL
}
843 /* Give the specifications for the format attributes, used by C and all
846 const struct attribute_spec c_common_format_attribute_table
[] =
848 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
849 { "format", 3, 3, false, true, true,
850 handle_format_attribute
},
851 { "format_arg", 1, 1, false, true, true,
852 handle_format_arg_attribute
},
853 { NULL
, 0, 0, false, false, false, NULL
}
856 /* Push current bindings for the function name VAR_DECLS. */
859 start_fname_decls (void)
862 tree saved
= NULL_TREE
;
864 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
866 tree decl
= *fname_vars
[ix
].decl
;
870 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
871 *fname_vars
[ix
].decl
= NULL_TREE
;
874 if (saved
|| saved_function_name_decls
)
875 /* Normally they'll have been NULL, so only push if we've got a
876 stack, or they are non-NULL. */
877 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
878 saved_function_name_decls
);
881 /* Finish up the current bindings, adding them into the current function's
882 statement tree. This must be done _before_ finish_stmt_tree is called.
883 If there is no current function, we must be at file scope and no statements
884 are involved. Pop the previous bindings. */
887 finish_fname_decls (void)
890 tree stmts
= NULL_TREE
;
891 tree stack
= saved_function_name_decls
;
893 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
894 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
898 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
900 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
901 bodyp
= &BIND_EXPR_BODY (*bodyp
);
903 append_to_statement_list (*bodyp
, &stmts
);
907 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
908 *fname_vars
[ix
].decl
= NULL_TREE
;
912 /* We had saved values, restore them. */
915 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
917 tree decl
= TREE_PURPOSE (saved
);
918 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
920 *fname_vars
[ix
].decl
= decl
;
922 stack
= TREE_CHAIN (stack
);
924 saved_function_name_decls
= stack
;
927 /* Return the text name of the current function, suitably prettified
928 by PRETTY_P. Return string must be freed by caller. */
931 fname_as_string (int pretty_p
)
933 const char *name
= "top level";
943 if (current_function_decl
)
944 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
946 if (c_lex_string_translate
)
948 int len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
949 cpp_string cstr
= { 0, 0 }, strname
;
951 namep
= xmalloc (len
);
952 snprintf (namep
, len
, "\"%s\"", name
);
953 strname
.text
= (unsigned char *) namep
;
954 strname
.len
= len
- 1;
956 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, false))
957 return (char *) cstr
.text
;
960 namep
= xstrdup (name
);
965 /* Expand DECL if it declares an entity not handled by the
969 c_expand_decl (tree decl
)
971 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
973 /* Let the back-end know about this variable. */
974 if (!anon_aggr_type_p (TREE_TYPE (decl
)))
975 emit_local_var (decl
);
977 expand_anon_union_decl (decl
, NULL_TREE
,
978 DECL_ANON_UNION_ELEMS (decl
));
980 else if (TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
981 make_rtl_for_local_static (decl
);
989 /* Return the VAR_DECL for a const char array naming the current
990 function. If the VAR_DECL has not yet been created, create it
991 now. RID indicates how it should be formatted and IDENTIFIER_NODE
992 ID is its name (unfortunately C and C++ hold the RID values of
993 keywords in different places, so we can't derive RID from ID in
994 this language independent code. */
997 fname_decl (unsigned int rid
, tree id
)
1000 tree decl
= NULL_TREE
;
1002 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1003 if (fname_vars
[ix
].rid
== rid
)
1006 decl
= *fname_vars
[ix
].decl
;
1009 /* If a tree is built here, it would normally have the lineno of
1010 the current statement. Later this tree will be moved to the
1011 beginning of the function and this line number will be wrong.
1012 To avoid this problem set the lineno to 0 here; that prevents
1013 it from appearing in the RTL. */
1015 location_t saved_locus
= input_location
;
1018 stmts
= push_stmt_list ();
1019 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
1020 stmts
= pop_stmt_list (stmts
);
1021 if (!IS_EMPTY_STMT (stmts
))
1022 saved_function_name_decls
1023 = tree_cons (decl
, stmts
, saved_function_name_decls
);
1024 *fname_vars
[ix
].decl
= decl
;
1025 input_location
= saved_locus
;
1027 if (!ix
&& !current_function_decl
)
1028 pedwarn ("%J'%D' is not defined outside of function scope", decl
, decl
);
1033 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1036 fix_string_type (tree value
)
1038 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
1039 const int wide_flag
= TREE_TYPE (value
) == wchar_array_type_node
;
1040 const int nchars_max
= flag_isoc99
? 4095 : 509;
1041 int length
= TREE_STRING_LENGTH (value
);
1044 /* Compute the number of elements, for the array type. */
1045 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
1047 if (pedantic
&& nchars
- 1 > nchars_max
&& !c_dialect_cxx ())
1048 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1049 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
1051 /* Create the array type for the string constant.
1052 -Wwrite-strings says make the string constant an array of const char
1053 so that copying it to a non-const pointer will get a warning.
1054 For C++, this is the standard behavior. */
1055 if (flag_const_strings
)
1058 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
1061 = build_array_type (elements
,
1062 build_index_type (build_int_2 (nchars
- 1, 0)));
1066 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
1067 build_index_type (build_int_2 (nchars
- 1, 0)));
1069 TREE_CONSTANT (value
) = 1;
1070 TREE_INVARIANT (value
) = 1;
1071 TREE_READONLY (value
) = 1;
1072 TREE_STATIC (value
) = 1;
1076 /* Print a warning if a constant expression had overflow in folding.
1077 Invoke this function on every expression that the language
1078 requires to be a constant expression.
1079 Note the ANSI C standard says it is erroneous for a
1080 constant expression to overflow. */
1083 constant_expression_warning (tree value
)
1085 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1086 || TREE_CODE (value
) == VECTOR_CST
1087 || TREE_CODE (value
) == COMPLEX_CST
)
1088 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
1089 pedwarn ("overflow in constant expression");
1092 /* Print a warning if an expression had overflow in folding.
1093 Invoke this function on every expression that
1094 (1) appears in the source code, and
1095 (2) might be a constant expression that overflowed, and
1096 (3) is not already checked by convert_and_check;
1097 however, do not invoke this function on operands of explicit casts. */
1100 overflow_warning (tree value
)
1102 if ((TREE_CODE (value
) == INTEGER_CST
1103 || (TREE_CODE (value
) == COMPLEX_CST
1104 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
1105 && TREE_OVERFLOW (value
))
1107 TREE_OVERFLOW (value
) = 0;
1108 if (skip_evaluation
== 0)
1109 warning ("integer overflow in expression");
1111 else if ((TREE_CODE (value
) == REAL_CST
1112 || (TREE_CODE (value
) == COMPLEX_CST
1113 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
1114 && TREE_OVERFLOW (value
))
1116 TREE_OVERFLOW (value
) = 0;
1117 if (skip_evaluation
== 0)
1118 warning ("floating point overflow in expression");
1120 else if (TREE_CODE (value
) == VECTOR_CST
&& TREE_OVERFLOW (value
))
1122 TREE_OVERFLOW (value
) = 0;
1123 if (skip_evaluation
== 0)
1124 warning ("vector overflow in expression");
1128 /* Print a warning if a large constant is truncated to unsigned,
1129 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1130 Invoke this function on every expression that might be implicitly
1131 converted to an unsigned type. */
1134 unsigned_conversion_warning (tree result
, tree operand
)
1136 tree type
= TREE_TYPE (result
);
1138 if (TREE_CODE (operand
) == INTEGER_CST
1139 && TREE_CODE (type
) == INTEGER_TYPE
1140 && TYPE_UNSIGNED (type
)
1141 && skip_evaluation
== 0
1142 && !int_fits_type_p (operand
, type
))
1144 if (!int_fits_type_p (operand
, c_common_signed_type (type
)))
1145 /* This detects cases like converting -129 or 256 to unsigned char. */
1146 warning ("large integer implicitly truncated to unsigned type");
1147 else if (warn_conversion
)
1148 warning ("negative integer implicitly converted to unsigned type");
1152 /* Nonzero if constant C has a value that is permissible
1153 for type TYPE (an INTEGER_TYPE). */
1156 constant_fits_type_p (tree c
, tree type
)
1158 if (TREE_CODE (c
) == INTEGER_CST
)
1159 return int_fits_type_p (c
, type
);
1161 c
= convert (type
, c
);
1162 return !TREE_OVERFLOW (c
);
1165 /* Nonzero if vector types T1 and T2 can be converted to each other
1166 without an explicit cast. */
1168 vector_types_convertible_p (tree t1
, tree t2
)
1170 return targetm
.vector_opaque_p (t1
)
1171 || targetm
.vector_opaque_p (t2
)
1172 || TYPE_MODE (t1
) == TYPE_MODE (t2
);
1175 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1176 Invoke this function on every expression that is converted implicitly,
1177 i.e. because of language rules and not because of an explicit cast. */
1180 convert_and_check (tree type
, tree expr
)
1182 tree t
= convert (type
, expr
);
1183 if (TREE_CODE (t
) == INTEGER_CST
)
1185 if (TREE_OVERFLOW (t
))
1187 TREE_OVERFLOW (t
) = 0;
1189 /* Do not diagnose overflow in a constant expression merely
1190 because a conversion overflowed. */
1191 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
1193 /* No warning for converting 0x80000000 to int. */
1194 if (!(TYPE_UNSIGNED (type
) < TYPE_UNSIGNED (TREE_TYPE (expr
))
1195 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1196 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1197 /* If EXPR fits in the unsigned version of TYPE,
1198 don't warn unless pedantic. */
1200 || TYPE_UNSIGNED (type
)
1201 || ! constant_fits_type_p (expr
,
1202 c_common_unsigned_type (type
)))
1203 && skip_evaluation
== 0)
1204 warning ("overflow in implicit constant conversion");
1207 unsigned_conversion_warning (t
, expr
);
1212 /* A node in a list that describes references to variables (EXPR), which are
1213 either read accesses if WRITER is zero, or write accesses, in which case
1214 WRITER is the parent of EXPR. */
1221 /* Used to implement a cache the results of a call to verify_tree. We only
1222 use this for SAVE_EXPRs. */
1225 struct tlist_cache
*next
;
1226 struct tlist
*cache_before_sp
;
1227 struct tlist
*cache_after_sp
;
1231 /* Obstack to use when allocating tlist structures, and corresponding
1233 static struct obstack tlist_obstack
;
1234 static char *tlist_firstobj
= 0;
1236 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1238 static struct tlist
*warned_ids
;
1239 /* SAVE_EXPRs need special treatment. We process them only once and then
1240 cache the results. */
1241 static struct tlist_cache
*save_expr_cache
;
1243 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
1244 static void merge_tlist (struct tlist
**, struct tlist
*, int);
1245 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
1246 static int warning_candidate_p (tree
);
1247 static void warn_for_collisions (struct tlist
*);
1248 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
1249 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
1250 static void verify_sequence_points (tree
);
1252 /* Create a new struct tlist and fill in its fields. */
1253 static struct tlist
*
1254 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1257 l
= obstack_alloc (&tlist_obstack
, sizeof *l
);
1264 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1265 is nonnull, we ignore any node we find which has a writer equal to it. */
1268 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1272 struct tlist
*next
= add
->next
;
1275 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
1276 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1281 /* Merge the nodes of ADD into TO. This merging process is done so that for
1282 each variable that already exists in TO, no new node is added; however if
1283 there is a write access recorded in ADD, and an occurrence on TO is only
1284 a read access, then the occurrence in TO will be modified to record the
1288 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1290 struct tlist
**end
= to
;
1293 end
= &(*end
)->next
;
1299 struct tlist
*next
= add
->next
;
1301 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1302 if (tmp2
->expr
== add
->expr
)
1306 tmp2
->writer
= add
->writer
;
1310 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1311 end
= &(*end
)->next
;
1318 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1319 references in list LIST conflict with it, excluding reads if ONLY writers
1323 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1328 /* Avoid duplicate warnings. */
1329 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1330 if (tmp
->expr
== written
)
1335 if (list
->expr
== written
1336 && list
->writer
!= writer
1337 && (! only_writes
|| list
->writer
))
1339 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1340 warning ("operation on `%s' may be undefined",
1341 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
1347 /* Given a list LIST of references to variables, find whether any of these
1348 can cause conflicts due to missing sequence points. */
1351 warn_for_collisions (struct tlist
*list
)
1355 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1358 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1362 /* Return nonzero if X is a tree that can be verified by the sequence point
1365 warning_candidate_p (tree x
)
1367 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1370 /* Walk the tree X, and record accesses to variables. If X is written by the
1371 parent tree, WRITER is the parent.
1372 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1373 expression or its only operand forces a sequence point, then everything up
1374 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1376 Once we return, we will have emitted warnings if any subexpression before
1377 such a sequence point could be undefined. On a higher level, however, the
1378 sequence point may not be relevant, and we'll merge the two lists.
1380 Example: (b++, a) + b;
1381 The call that processes the COMPOUND_EXPR will store the increment of B
1382 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1383 processes the PLUS_EXPR will need to merge the two lists so that
1384 eventually, all accesses end up on the same list (and we'll warn about the
1385 unordered subexpressions b++ and b.
1387 A note on merging. If we modify the former example so that our expression
1390 care must be taken not simply to add all three expressions into the final
1391 PNO_SP list. The function merge_tlist takes care of that by merging the
1392 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1393 way, so that no more than one access to B is recorded. */
1396 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
1399 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1400 enum tree_code code
;
1403 /* X may be NULL if it is the operand of an empty statement expression
1409 code
= TREE_CODE (x
);
1410 class = TREE_CODE_CLASS (code
);
1412 if (warning_candidate_p (x
))
1414 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1424 case TRUTH_ANDIF_EXPR
:
1425 case TRUTH_ORIF_EXPR
:
1426 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1427 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1428 warn_for_collisions (tmp_nosp
);
1429 merge_tlist (pbefore_sp
, tmp_before
, 0);
1430 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1431 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1432 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1436 tmp_before
= tmp_list2
= 0;
1437 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1438 warn_for_collisions (tmp_list2
);
1439 merge_tlist (pbefore_sp
, tmp_before
, 0);
1440 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1442 tmp_list3
= tmp_nosp
= 0;
1443 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1444 warn_for_collisions (tmp_nosp
);
1445 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1447 tmp_list3
= tmp_list2
= 0;
1448 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1449 warn_for_collisions (tmp_list2
);
1450 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1451 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1452 two first, to avoid warning for (a ? b++ : b++). */
1453 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1454 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1457 case PREDECREMENT_EXPR
:
1458 case PREINCREMENT_EXPR
:
1459 case POSTDECREMENT_EXPR
:
1460 case POSTINCREMENT_EXPR
:
1461 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1465 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1466 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1467 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1468 /* Expressions inside the LHS are not ordered wrt. the sequence points
1469 in the RHS. Example:
1471 Despite the fact that the modification of "a" is in the before_sp
1472 list (tmp_before), it conflicts with the use of "a" in the LHS.
1473 We can handle this by adding the contents of tmp_list3
1474 to those of tmp_before, and redoing the collision warnings for that
1476 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1477 warn_for_collisions (tmp_before
);
1478 /* Exclude the LHS itself here; we first have to merge it into the
1479 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1480 didn't exclude the LHS, we'd get it twice, once as a read and once
1482 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1483 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1485 merge_tlist (pbefore_sp
, tmp_before
, 0);
1486 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1487 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1488 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1492 /* We need to warn about conflicts among arguments and conflicts between
1493 args and the function address. Side effects of the function address,
1494 however, are not ordered by the sequence point of the call. */
1495 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1496 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1497 if (TREE_OPERAND (x
, 1))
1498 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1499 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1500 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1501 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1502 warn_for_collisions (tmp_before
);
1503 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1507 /* Scan all the list, e.g. indices of multi dimensional array. */
1510 tmp_before
= tmp_nosp
= 0;
1511 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1512 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1513 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1520 struct tlist_cache
*t
;
1521 for (t
= save_expr_cache
; t
; t
= t
->next
)
1527 t
= obstack_alloc (&tlist_obstack
, sizeof *t
);
1528 t
->next
= save_expr_cache
;
1530 save_expr_cache
= t
;
1532 tmp_before
= tmp_nosp
= 0;
1533 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1534 warn_for_collisions (tmp_nosp
);
1539 struct tlist
*t
= tmp_nosp
;
1541 merge_tlist (&tmp_list3
, t
, 0);
1543 t
->cache_before_sp
= tmp_before
;
1544 t
->cache_after_sp
= tmp_list3
;
1546 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1547 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1556 if (first_rtl_op (code
) == 0)
1558 x
= TREE_OPERAND (x
, 0);
1573 int max
= first_rtl_op (TREE_CODE (x
));
1574 for (lp
= 0; lp
< max
; lp
++)
1576 tmp_before
= tmp_nosp
= 0;
1577 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1578 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1579 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1586 /* Try to warn for undefined behavior in EXPR due to missing sequence
1590 verify_sequence_points (tree expr
)
1592 struct tlist
*before_sp
= 0, *after_sp
= 0;
1595 save_expr_cache
= 0;
1596 if (tlist_firstobj
== 0)
1598 gcc_obstack_init (&tlist_obstack
);
1599 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1602 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1603 warn_for_collisions (after_sp
);
1604 obstack_free (&tlist_obstack
, tlist_firstobj
);
1608 c_expand_expr_stmt (tree expr
)
1610 /* Do default conversion if safe and possibly important,
1611 in case within ({...}). */
1612 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1613 && (flag_isoc99
|| lvalue_p (expr
)))
1614 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1615 expr
= default_conversion (expr
);
1617 if (warn_sequence_point
)
1618 verify_sequence_points (expr
);
1620 if (TREE_TYPE (expr
) != error_mark_node
1621 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1622 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1623 error ("expression statement has incomplete type");
1625 /* As tempting as it might be, we can't diagnose statement with no
1626 effect yet. We have to wait until after statement expressions
1627 have been parsed, and that process modifies the trees we are
1630 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1633 /* Validate the expression after `case' and apply default promotions. */
1636 check_case_value (tree value
)
1638 if (value
== NULL_TREE
)
1641 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1642 STRIP_TYPE_NOPS (value
);
1643 /* In C++, the following is allowed:
1646 switch (...) { case i: ... }
1648 So, we try to reduce the VALUE to a constant that way. */
1649 if (c_dialect_cxx ())
1651 value
= decl_constant_value (value
);
1652 STRIP_TYPE_NOPS (value
);
1653 value
= fold (value
);
1656 if (TREE_CODE (value
) != INTEGER_CST
1657 && value
!= error_mark_node
)
1659 error ("case label does not reduce to an integer constant");
1660 value
= error_mark_node
;
1663 /* Promote char or short to int. */
1664 value
= default_conversion (value
);
1666 constant_expression_warning (value
);
1671 /* Return an integer type with BITS bits of precision,
1672 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1675 c_common_type_for_size (unsigned int bits
, int unsignedp
)
1677 if (bits
== TYPE_PRECISION (integer_type_node
))
1678 return unsignedp
? unsigned_type_node
: integer_type_node
;
1680 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1681 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1683 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1684 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1686 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1687 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1689 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1690 return (unsignedp
? long_long_unsigned_type_node
1691 : long_long_integer_type_node
);
1693 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1694 return (unsignedp
? widest_unsigned_literal_type_node
1695 : widest_integer_literal_type_node
);
1697 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1698 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1700 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1701 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1703 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1704 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1706 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1707 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1712 /* Used for communication between c_common_type_for_mode and
1713 c_register_builtin_type. */
1714 static GTY(()) tree registered_builtin_types
;
1716 /* Return a data type that has machine mode MODE.
1717 If the mode is an integer,
1718 then UNSIGNEDP selects between signed and unsigned types. */
1721 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
1725 if (mode
== TYPE_MODE (integer_type_node
))
1726 return unsignedp
? unsigned_type_node
: integer_type_node
;
1728 if (mode
== TYPE_MODE (signed_char_type_node
))
1729 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1731 if (mode
== TYPE_MODE (short_integer_type_node
))
1732 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1734 if (mode
== TYPE_MODE (long_integer_type_node
))
1735 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1737 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1738 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1740 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1741 return unsignedp
? widest_unsigned_literal_type_node
1742 : widest_integer_literal_type_node
;
1745 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1748 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1751 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1754 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1756 #if HOST_BITS_PER_WIDE_INT >= 64
1757 if (mode
== TYPE_MODE (intTI_type_node
))
1758 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1761 if (mode
== TYPE_MODE (float_type_node
))
1762 return float_type_node
;
1764 if (mode
== TYPE_MODE (double_type_node
))
1765 return double_type_node
;
1767 if (mode
== TYPE_MODE (long_double_type_node
))
1768 return long_double_type_node
;
1770 if (mode
== TYPE_MODE (void_type_node
))
1771 return void_type_node
;
1773 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1774 return unsignedp
? make_unsigned_type (mode
) : make_signed_type (mode
);
1776 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1777 return unsignedp
? make_unsigned_type (mode
) : make_signed_type (mode
);
1779 if (VECTOR_MODE_P (mode
))
1781 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
1782 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
1783 if (inner_type
!= NULL_TREE
)
1784 return build_vector_type_for_mode (inner_type
, mode
);
1787 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1788 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
1789 return TREE_VALUE (t
);
1794 /* Return an unsigned type the same as TYPE in other respects. */
1796 c_common_unsigned_type (tree type
)
1798 tree type1
= TYPE_MAIN_VARIANT (type
);
1799 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1800 return unsigned_char_type_node
;
1801 if (type1
== integer_type_node
)
1802 return unsigned_type_node
;
1803 if (type1
== short_integer_type_node
)
1804 return short_unsigned_type_node
;
1805 if (type1
== long_integer_type_node
)
1806 return long_unsigned_type_node
;
1807 if (type1
== long_long_integer_type_node
)
1808 return long_long_unsigned_type_node
;
1809 if (type1
== widest_integer_literal_type_node
)
1810 return widest_unsigned_literal_type_node
;
1811 #if HOST_BITS_PER_WIDE_INT >= 64
1812 if (type1
== intTI_type_node
)
1813 return unsigned_intTI_type_node
;
1815 if (type1
== intDI_type_node
)
1816 return unsigned_intDI_type_node
;
1817 if (type1
== intSI_type_node
)
1818 return unsigned_intSI_type_node
;
1819 if (type1
== intHI_type_node
)
1820 return unsigned_intHI_type_node
;
1821 if (type1
== intQI_type_node
)
1822 return unsigned_intQI_type_node
;
1824 return c_common_signed_or_unsigned_type (1, type
);
1827 /* Return a signed type the same as TYPE in other respects. */
1830 c_common_signed_type (tree type
)
1832 tree type1
= TYPE_MAIN_VARIANT (type
);
1833 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1834 return signed_char_type_node
;
1835 if (type1
== unsigned_type_node
)
1836 return integer_type_node
;
1837 if (type1
== short_unsigned_type_node
)
1838 return short_integer_type_node
;
1839 if (type1
== long_unsigned_type_node
)
1840 return long_integer_type_node
;
1841 if (type1
== long_long_unsigned_type_node
)
1842 return long_long_integer_type_node
;
1843 if (type1
== widest_unsigned_literal_type_node
)
1844 return widest_integer_literal_type_node
;
1845 #if HOST_BITS_PER_WIDE_INT >= 64
1846 if (type1
== unsigned_intTI_type_node
)
1847 return intTI_type_node
;
1849 if (type1
== unsigned_intDI_type_node
)
1850 return intDI_type_node
;
1851 if (type1
== unsigned_intSI_type_node
)
1852 return intSI_type_node
;
1853 if (type1
== unsigned_intHI_type_node
)
1854 return intHI_type_node
;
1855 if (type1
== unsigned_intQI_type_node
)
1856 return intQI_type_node
;
1858 return c_common_signed_or_unsigned_type (0, type
);
1861 /* Return a type the same as TYPE except unsigned or
1862 signed according to UNSIGNEDP. */
1865 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
1867 if (! INTEGRAL_TYPE_P (type
)
1868 || TYPE_UNSIGNED (type
) == unsignedp
)
1871 /* Must check the mode of the types, not the precision. Enumeral types
1872 in C++ have precision set to match their range, but may use a wider
1873 mode to match an ABI. If we change modes, we may wind up with bad
1876 if (TYPE_MODE (type
) == TYPE_MODE (signed_char_type_node
))
1877 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1878 if (TYPE_MODE (type
) == TYPE_MODE (integer_type_node
))
1879 return unsignedp
? unsigned_type_node
: integer_type_node
;
1880 if (TYPE_MODE (type
) == TYPE_MODE (short_integer_type_node
))
1881 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1882 if (TYPE_MODE (type
) == TYPE_MODE (long_integer_type_node
))
1883 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1884 if (TYPE_MODE (type
) == TYPE_MODE (long_long_integer_type_node
))
1885 return (unsignedp
? long_long_unsigned_type_node
1886 : long_long_integer_type_node
);
1887 if (TYPE_MODE (type
) == TYPE_MODE (widest_integer_literal_type_node
))
1888 return (unsignedp
? widest_unsigned_literal_type_node
1889 : widest_integer_literal_type_node
);
1891 #if HOST_BITS_PER_WIDE_INT >= 64
1892 if (TYPE_MODE (type
) == TYPE_MODE (intTI_type_node
))
1893 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1895 if (TYPE_MODE (type
) == TYPE_MODE (intDI_type_node
))
1896 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1897 if (TYPE_MODE (type
) == TYPE_MODE (intSI_type_node
))
1898 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1899 if (TYPE_MODE (type
) == TYPE_MODE (intHI_type_node
))
1900 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1901 if (TYPE_MODE (type
) == TYPE_MODE (intQI_type_node
))
1902 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1907 /* The C version of the register_builtin_type langhook. */
1910 c_register_builtin_type (tree type
, const char* name
)
1914 decl
= build_decl (TYPE_DECL
, get_identifier (name
), type
);
1915 DECL_ARTIFICIAL (decl
) = 1;
1916 if (!TYPE_NAME (type
))
1917 TYPE_NAME (type
) = decl
;
1920 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
1924 /* Return the minimum number of bits needed to represent VALUE in a
1925 signed or unsigned type, UNSIGNEDP says which. */
1928 min_precision (tree value
, int unsignedp
)
1932 /* If the value is negative, compute its negative minus 1. The latter
1933 adjustment is because the absolute value of the largest negative value
1934 is one larger than the largest positive value. This is equivalent to
1935 a bit-wise negation, so use that operation instead. */
1937 if (tree_int_cst_sgn (value
) < 0)
1938 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
1940 /* Return the number of bits needed, taking into account the fact
1941 that we need one more bit for a signed than unsigned type. */
1943 if (integer_zerop (value
))
1946 log
= tree_floor_log2 (value
);
1948 return log
+ 1 + ! unsignedp
;
1951 /* Print an error message for invalid operands to arith operation
1952 CODE. NOP_EXPR is used as a special case (see
1953 c_common_truthvalue_conversion). */
1956 binary_op_error (enum tree_code code
)
1963 error ("invalid truth-value expression");
1967 opname
= "+"; break;
1969 opname
= "-"; break;
1971 opname
= "*"; break;
1973 opname
= "max"; break;
1975 opname
= "min"; break;
1977 opname
= "=="; break;
1979 opname
= "!="; break;
1981 opname
= "<="; break;
1983 opname
= ">="; break;
1985 opname
= "<"; break;
1987 opname
= ">"; break;
1989 opname
= "<<"; break;
1991 opname
= ">>"; break;
1992 case TRUNC_MOD_EXPR
:
1993 case FLOOR_MOD_EXPR
:
1994 opname
= "%"; break;
1995 case TRUNC_DIV_EXPR
:
1996 case FLOOR_DIV_EXPR
:
1997 opname
= "/"; break;
1999 opname
= "&"; break;
2001 opname
= "|"; break;
2002 case TRUTH_ANDIF_EXPR
:
2003 opname
= "&&"; break;
2004 case TRUTH_ORIF_EXPR
:
2005 opname
= "||"; break;
2007 opname
= "^"; break;
2010 opname
= "rotate"; break;
2012 opname
= "unknown"; break;
2014 error ("invalid operands to binary %s", opname
);
2017 /* Subroutine of build_binary_op, used for comparison operations.
2018 See if the operands have both been converted from subword integer types
2019 and, if so, perhaps change them both back to their original type.
2020 This function is also responsible for converting the two operands
2021 to the proper common type for comparison.
2023 The arguments of this function are all pointers to local variables
2024 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2025 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2027 If this function returns nonzero, it means that the comparison has
2028 a constant value. What this function returns is an expression for
2032 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
2033 enum tree_code
*rescode_ptr
)
2036 tree op0
= *op0_ptr
;
2037 tree op1
= *op1_ptr
;
2038 int unsignedp0
, unsignedp1
;
2040 tree primop0
, primop1
;
2041 enum tree_code code
= *rescode_ptr
;
2043 /* Throw away any conversions to wider types
2044 already present in the operands. */
2046 primop0
= get_narrower (op0
, &unsignedp0
);
2047 primop1
= get_narrower (op1
, &unsignedp1
);
2049 /* Handle the case that OP0 does not *contain* a conversion
2050 but it *requires* conversion to FINAL_TYPE. */
2052 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2053 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2054 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2055 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2057 /* If one of the operands must be floated, we cannot optimize. */
2058 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2059 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2061 /* If first arg is constant, swap the args (changing operation
2062 so value is preserved), for canonicalization. Don't do this if
2063 the second arg is 0. */
2065 if (TREE_CONSTANT (primop0
)
2066 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
2069 int temi
= unsignedp0
;
2077 unsignedp0
= unsignedp1
;
2100 *rescode_ptr
= code
;
2103 /* If comparing an integer against a constant more bits wide,
2104 maybe we can deduce a value of 1 or 0 independent of the data.
2105 Or else truncate the constant now
2106 rather than extend the variable at run time.
2108 This is only interesting if the constant is the wider arg.
2109 Also, it is not safe if the constant is unsigned and the
2110 variable arg is signed, since in this case the variable
2111 would be sign-extended and then regarded as unsigned.
2112 Our technique fails in this case because the lowest/highest
2113 possible unsigned results don't follow naturally from the
2114 lowest/highest possible values of the variable operand.
2115 For just EQ_EXPR and NE_EXPR there is another technique that
2116 could be used: see if the constant can be faithfully represented
2117 in the other operand's type, by truncating it and reextending it
2118 and see if that preserves the constant's value. */
2120 if (!real1
&& !real2
2121 && TREE_CODE (primop1
) == INTEGER_CST
2122 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2124 int min_gt
, max_gt
, min_lt
, max_lt
;
2125 tree maxval
, minval
;
2126 /* 1 if comparison is nominally unsigned. */
2127 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
2130 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2131 TREE_TYPE (primop0
));
2133 /* In C, if TYPE is an enumeration, then we need to get its
2134 min/max values from its underlying integral type, not the
2135 enumerated type itself. In C++, TYPE_MAX_VALUE and
2136 TYPE_MIN_VALUE have already been set correctly on the
2137 enumeration type. */
2138 if (!c_dialect_cxx() && TREE_CODE (type
) == ENUMERAL_TYPE
)
2139 type
= c_common_type_for_size (TYPE_PRECISION (type
), unsignedp0
);
2141 maxval
= TYPE_MAX_VALUE (type
);
2142 minval
= TYPE_MIN_VALUE (type
);
2144 if (unsignedp
&& !unsignedp0
)
2145 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2147 if (TREE_TYPE (primop1
) != *restype_ptr
)
2148 primop1
= convert (*restype_ptr
, primop1
);
2149 if (type
!= *restype_ptr
)
2151 minval
= convert (*restype_ptr
, minval
);
2152 maxval
= convert (*restype_ptr
, maxval
);
2155 if (unsignedp
&& unsignedp0
)
2157 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2158 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2159 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2160 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2164 min_gt
= INT_CST_LT (primop1
, minval
);
2165 max_gt
= INT_CST_LT (primop1
, maxval
);
2166 min_lt
= INT_CST_LT (minval
, primop1
);
2167 max_lt
= INT_CST_LT (maxval
, primop1
);
2171 /* This used to be a switch, but Genix compiler can't handle that. */
2172 if (code
== NE_EXPR
)
2174 if (max_lt
|| min_gt
)
2175 val
= truthvalue_true_node
;
2177 else if (code
== EQ_EXPR
)
2179 if (max_lt
|| min_gt
)
2180 val
= truthvalue_false_node
;
2182 else if (code
== LT_EXPR
)
2185 val
= truthvalue_true_node
;
2187 val
= truthvalue_false_node
;
2189 else if (code
== GT_EXPR
)
2192 val
= truthvalue_true_node
;
2194 val
= truthvalue_false_node
;
2196 else if (code
== LE_EXPR
)
2199 val
= truthvalue_true_node
;
2201 val
= truthvalue_false_node
;
2203 else if (code
== GE_EXPR
)
2206 val
= truthvalue_true_node
;
2208 val
= truthvalue_false_node
;
2211 /* If primop0 was sign-extended and unsigned comparison specd,
2212 we did a signed comparison above using the signed type bounds.
2213 But the comparison we output must be unsigned.
2215 Also, for inequalities, VAL is no good; but if the signed
2216 comparison had *any* fixed result, it follows that the
2217 unsigned comparison just tests the sign in reverse
2218 (positive values are LE, negative ones GE).
2219 So we can generate an unsigned comparison
2220 against an extreme value of the signed type. */
2222 if (unsignedp
&& !unsignedp0
)
2229 primop1
= TYPE_MIN_VALUE (type
);
2235 primop1
= TYPE_MAX_VALUE (type
);
2242 type
= c_common_unsigned_type (type
);
2245 if (TREE_CODE (primop0
) != INTEGER_CST
)
2247 if (val
== truthvalue_false_node
)
2248 warning ("comparison is always false due to limited range of data type");
2249 if (val
== truthvalue_true_node
)
2250 warning ("comparison is always true due to limited range of data type");
2255 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2256 if (TREE_SIDE_EFFECTS (primop0
))
2257 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2261 /* Value is not predetermined, but do the comparison
2262 in the type of the operand that is not constant.
2263 TYPE is already properly set. */
2265 else if (real1
&& real2
2266 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2267 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2268 type
= TREE_TYPE (primop0
);
2270 /* If args' natural types are both narrower than nominal type
2271 and both extend in the same manner, compare them
2272 in the type of the wider arg.
2273 Otherwise must actually extend both to the nominal
2274 common type lest different ways of extending
2276 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2278 else if (unsignedp0
== unsignedp1
&& real1
== real2
2279 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2280 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2282 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2283 type
= c_common_signed_or_unsigned_type (unsignedp0
2284 || TYPE_UNSIGNED (*restype_ptr
),
2286 /* Make sure shorter operand is extended the right way
2287 to match the longer operand. */
2289 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2290 TREE_TYPE (primop0
)),
2293 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2294 TREE_TYPE (primop1
)),
2299 /* Here we must do the comparison on the nominal type
2300 using the args exactly as we received them. */
2301 type
= *restype_ptr
;
2305 if (!real1
&& !real2
&& integer_zerop (primop1
)
2306 && TYPE_UNSIGNED (*restype_ptr
))
2312 /* All unsigned values are >= 0, so we warn if extra warnings
2313 are requested. However, if OP0 is a constant that is
2314 >= 0, the signedness of the comparison isn't an issue,
2315 so suppress the warning. */
2316 if (extra_warnings
&& !in_system_header
2317 && ! (TREE_CODE (primop0
) == INTEGER_CST
2318 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2320 warning ("comparison of unsigned expression >= 0 is always true");
2321 value
= truthvalue_true_node
;
2325 if (extra_warnings
&& !in_system_header
2326 && ! (TREE_CODE (primop0
) == INTEGER_CST
2327 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2329 warning ("comparison of unsigned expression < 0 is always false");
2330 value
= truthvalue_false_node
;
2339 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2340 if (TREE_SIDE_EFFECTS (primop0
))
2341 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2348 *op0_ptr
= convert (type
, primop0
);
2349 *op1_ptr
= convert (type
, primop1
);
2351 *restype_ptr
= truthvalue_type_node
;
2356 /* Return a tree for the sum or difference (RESULTCODE says which)
2357 of pointer PTROP and integer INTOP. */
2360 pointer_int_sum (enum tree_code resultcode
, tree ptrop
, tree intop
)
2364 /* The result is a pointer of the same type that is being added. */
2366 tree result_type
= TREE_TYPE (ptrop
);
2368 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2370 if (pedantic
|| warn_pointer_arith
)
2371 pedwarn ("pointer of type `void *' used in arithmetic");
2372 size_exp
= integer_one_node
;
2374 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2376 if (pedantic
|| warn_pointer_arith
)
2377 pedwarn ("pointer to a function used in arithmetic");
2378 size_exp
= integer_one_node
;
2380 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2382 if (pedantic
|| warn_pointer_arith
)
2383 pedwarn ("pointer to member function used in arithmetic");
2384 size_exp
= integer_one_node
;
2387 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2389 /* If what we are about to multiply by the size of the elements
2390 contains a constant term, apply distributive law
2391 and multiply that constant term separately.
2392 This helps produce common subexpressions. */
2394 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2395 && ! TREE_CONSTANT (intop
)
2396 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2397 && TREE_CONSTANT (size_exp
)
2398 /* If the constant comes from pointer subtraction,
2399 skip this optimization--it would cause an error. */
2400 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2401 /* If the constant is unsigned, and smaller than the pointer size,
2402 then we must skip this optimization. This is because it could cause
2403 an overflow error if the constant is negative but INTOP is not. */
2404 && (! TYPE_UNSIGNED (TREE_TYPE (intop
))
2405 || (TYPE_PRECISION (TREE_TYPE (intop
))
2406 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2408 enum tree_code subcode
= resultcode
;
2409 tree int_type
= TREE_TYPE (intop
);
2410 if (TREE_CODE (intop
) == MINUS_EXPR
)
2411 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2412 /* Convert both subexpression types to the type of intop,
2413 because weird cases involving pointer arithmetic
2414 can result in a sum or difference with different type args. */
2415 ptrop
= build_binary_op (subcode
, ptrop
,
2416 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2417 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2420 /* Convert the integer argument to a type the same size as sizetype
2421 so the multiply won't overflow spuriously. */
2423 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2424 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
2425 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2426 TYPE_UNSIGNED (sizetype
)), intop
);
2428 /* Replace the integer argument with a suitable product by the object size.
2429 Do this multiplication as signed, then convert to the appropriate
2430 pointer type (actually unsigned integral). */
2432 intop
= convert (result_type
,
2433 build_binary_op (MULT_EXPR
, intop
,
2434 convert (TREE_TYPE (intop
), size_exp
), 1));
2436 /* Create the sum or difference. */
2437 return fold (build (resultcode
, result_type
, ptrop
, intop
));
2440 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2441 or validate its data type for an `if' or `while' statement or ?..: exp.
2443 This preparation consists of taking the ordinary
2444 representation of an expression expr and producing a valid tree
2445 boolean expression describing whether expr is nonzero. We could
2446 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2447 but we optimize comparisons, &&, ||, and !.
2449 The resulting type should always be `truthvalue_type_node'. */
2452 c_common_truthvalue_conversion (tree expr
)
2454 if (TREE_CODE (expr
) == ERROR_MARK
)
2457 if (TREE_CODE (expr
) == FUNCTION_DECL
)
2458 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
2460 switch (TREE_CODE (expr
))
2462 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
2463 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2464 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
2465 case ORDERED_EXPR
: case UNORDERED_EXPR
:
2466 case TRUTH_ANDIF_EXPR
:
2467 case TRUTH_ORIF_EXPR
:
2468 case TRUTH_AND_EXPR
:
2470 case TRUTH_XOR_EXPR
:
2471 case TRUTH_NOT_EXPR
:
2472 TREE_TYPE (expr
) = truthvalue_type_node
;
2479 return integer_zerop (expr
) ? truthvalue_false_node
: truthvalue_true_node
;
2482 return real_zerop (expr
) ? truthvalue_false_node
: truthvalue_true_node
;
2486 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == FUNCTION_DECL
2487 && ! DECL_WEAK (TREE_OPERAND (expr
, 0)))
2489 /* Common Ada/Pascal programmer's mistake. We always warn
2490 about this since it is so bad. */
2491 warning ("the address of `%D', will always evaluate as `true'",
2492 TREE_OPERAND (expr
, 0));
2493 return truthvalue_true_node
;
2496 /* If we are taking the address of an external decl, it might be
2497 zero if it is weak, so we cannot optimize. */
2498 if (DECL_P (TREE_OPERAND (expr
, 0))
2499 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2502 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2503 return build (COMPOUND_EXPR
, truthvalue_type_node
,
2504 TREE_OPERAND (expr
, 0), truthvalue_true_node
);
2506 return truthvalue_true_node
;
2510 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2511 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2512 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2513 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2519 /* These don't change whether an object is nonzero or zero. */
2520 return lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0));
2524 /* These don't change whether an object is zero or nonzero, but
2525 we can't ignore them if their second arg has side-effects. */
2526 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2527 return build (COMPOUND_EXPR
, truthvalue_type_node
, TREE_OPERAND (expr
, 1),
2528 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2530 return lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0));
2533 /* Distribute the conversion into the arms of a COND_EXPR. */
2534 return fold (build (COND_EXPR
, truthvalue_type_node
, TREE_OPERAND (expr
, 0),
2535 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2536 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2539 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2540 since that affects how `default_conversion' will behave. */
2541 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2542 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2544 /* Fall through.... */
2546 /* If this is widening the argument, we can ignore it. */
2547 if (TYPE_PRECISION (TREE_TYPE (expr
))
2548 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2549 return lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0));
2553 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2554 aren't guaranteed to the be same for modes that can represent
2555 infinity, since if x and y are both +infinity, or both
2556 -infinity, then x - y is not a number.
2558 Note that this transformation is safe when x or y is NaN.
2559 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2561 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))))
2563 /* Fall through.... */
2565 /* This and MINUS_EXPR can be changed into a comparison of the
2567 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2568 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2569 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2570 TREE_OPERAND (expr
, 1), 1);
2571 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2572 fold (build1 (NOP_EXPR
,
2573 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2574 TREE_OPERAND (expr
, 1))), 1);
2577 if (integer_onep (TREE_OPERAND (expr
, 1))
2578 && TREE_TYPE (expr
) != truthvalue_type_node
)
2579 /* Using convert here would cause infinite recursion. */
2580 return build1 (NOP_EXPR
, truthvalue_type_node
, expr
);
2584 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2585 warning ("suggest parentheses around assignment used as truth value");
2592 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2594 tree t
= save_expr (expr
);
2595 return (build_binary_op
2596 ((TREE_SIDE_EFFECTS (expr
)
2597 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2598 lang_hooks
.truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2599 lang_hooks
.truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2603 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2606 static tree
builtin_function_2 (const char *, const char *, tree
, tree
,
2607 int, enum built_in_class
, int, int,
2610 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2611 down to the element type of an array. */
2614 c_build_qualified_type (tree type
, int type_quals
)
2616 if (type
== error_mark_node
)
2619 if (TREE_CODE (type
) == ARRAY_TYPE
)
2620 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2622 TYPE_DOMAIN (type
));
2624 /* A restrict-qualified pointer type must be a pointer to object or
2625 incomplete type. Note that the use of POINTER_TYPE_P also allows
2626 REFERENCE_TYPEs, which is appropriate for C++. */
2627 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2628 && (!POINTER_TYPE_P (type
)
2629 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2631 error ("invalid use of `restrict'");
2632 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2635 return build_qualified_type (type
, type_quals
);
2638 /* Apply the TYPE_QUALS to the new DECL. */
2641 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
2643 tree type
= TREE_TYPE (decl
);
2645 if (type
== error_mark_node
)
2648 if (((type_quals
& TYPE_QUAL_CONST
)
2649 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
2650 /* An object declared 'const' is only readonly after it is
2651 initialized. We don't have any way of expressing this currently,
2652 so we need to be conservative and unset TREE_READONLY for types
2653 with constructors. Otherwise aliasing code will ignore stores in
2654 an inline constructor. */
2655 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
2656 TREE_READONLY (decl
) = 1;
2657 if (type_quals
& TYPE_QUAL_VOLATILE
)
2659 TREE_SIDE_EFFECTS (decl
) = 1;
2660 TREE_THIS_VOLATILE (decl
) = 1;
2662 if (type_quals
& TYPE_QUAL_RESTRICT
)
2664 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
2665 /* Allow 'restrict' on arrays of pointers.
2666 FIXME currently we just ignore it. */
2667 type
= TREE_TYPE (type
);
2669 || !POINTER_TYPE_P (type
)
2670 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
2671 error ("invalid use of `restrict'");
2672 else if (flag_strict_aliasing
&& type
== TREE_TYPE (decl
))
2673 /* Indicate we need to make a unique alias set for this pointer.
2674 We can't do it here because it might be pointing to an
2676 DECL_POINTER_ALIAS_SET (decl
) = -2;
2680 /* Hash function for the problem of multiple type definitions in
2681 different files. This must hash all types that will compare
2682 equal via comptypes to the same value. In practice it hashes
2683 on some of the simple stuff and leaves the details to comptypes. */
2686 c_type_hash (const void *p
)
2692 switch (TREE_CODE (t
))
2694 /* For pointers, hash on pointee type plus some swizzling. */
2696 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
2697 /* Hash on number of elements and total size. */
2700 t2
= TYPE_VALUES (t
);
2704 t2
= TYPE_FIELDS (t
);
2706 case QUAL_UNION_TYPE
:
2708 t2
= TYPE_FIELDS (t
);
2712 t2
= TYPE_FIELDS (t
);
2717 for (; t2
; t2
= TREE_CHAIN (t2
))
2719 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
2720 return ((size
<< 24) | (i
<< shift
));
2723 /* Return the typed-based alias set for T, which may be an expression
2724 or a type. Return -1 if we don't do anything special. */
2727 c_common_get_alias_set (tree t
)
2731 static htab_t type_hash_table
;
2733 /* Permit type-punning when accessing a union, provided the access
2734 is directly through the union. For example, this code does not
2735 permit taking the address of a union member and then storing
2736 through it. Even the type-punning allowed here is a GCC
2737 extension, albeit a common and useful one; the C standard says
2738 that such accesses have implementation-defined behavior. */
2740 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2741 u
= TREE_OPERAND (u
, 0))
2742 if (TREE_CODE (u
) == COMPONENT_REF
2743 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2746 /* That's all the expressions we handle specially. */
2750 /* The C standard guarantees that any object may be accessed via an
2751 lvalue that has character type. */
2752 if (t
== char_type_node
2753 || t
== signed_char_type_node
2754 || t
== unsigned_char_type_node
)
2757 /* If it has the may_alias attribute, it can alias anything. */
2758 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
2761 /* The C standard specifically allows aliasing between signed and
2762 unsigned variants of the same type. We treat the signed
2763 variant as canonical. */
2764 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2766 tree t1
= c_common_signed_type (t
);
2768 /* t1 == t can happen for boolean nodes which are always unsigned. */
2770 return get_alias_set (t1
);
2772 else if (POINTER_TYPE_P (t
))
2776 /* Unfortunately, there is no canonical form of a pointer type.
2777 In particular, if we have `typedef int I', then `int *', and
2778 `I *' are different types. So, we have to pick a canonical
2779 representative. We do this below.
2781 Technically, this approach is actually more conservative that
2782 it needs to be. In particular, `const int *' and `int *'
2783 should be in different alias sets, according to the C and C++
2784 standard, since their types are not the same, and so,
2785 technically, an `int **' and `const int **' cannot point at
2788 But, the standard is wrong. In particular, this code is
2793 const int* const* cipp = ipp;
2795 And, it doesn't make sense for that to be legal unless you
2796 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2797 the pointed-to types. This issue has been reported to the
2799 t1
= build_type_no_quals (t
);
2801 return get_alias_set (t1
);
2804 /* Handle the case of multiple type nodes referring to "the same" type,
2805 which occurs with IMA. These share an alias set. FIXME: Currently only
2806 C90 is handled. (In C99 type compatibility is not transitive, which
2807 complicates things mightily. The alias set splay trees can theoretically
2808 represent this, but insertion is tricky when you consider all the
2809 different orders things might arrive in.) */
2811 if (c_language
!= clk_c
|| flag_isoc99
)
2814 /* Save time if there's only one input file. */
2815 if (!current_file_decl
|| TREE_CHAIN (current_file_decl
) == NULL_TREE
)
2818 /* Pointers need special handling if they point to any type that
2819 needs special handling (below). */
2820 if (TREE_CODE (t
) == POINTER_TYPE
)
2823 /* Find bottom type under any nested POINTERs. */
2824 for (t2
= TREE_TYPE (t
);
2825 TREE_CODE (t2
) == POINTER_TYPE
;
2826 t2
= TREE_TYPE (t2
))
2828 if (TREE_CODE (t2
) != RECORD_TYPE
2829 && TREE_CODE (t2
) != ENUMERAL_TYPE
2830 && TREE_CODE (t2
) != QUAL_UNION_TYPE
2831 && TREE_CODE (t2
) != UNION_TYPE
)
2833 if (TYPE_SIZE (t2
) == 0)
2836 /* These are the only cases that need special handling. */
2837 if (TREE_CODE (t
) != RECORD_TYPE
2838 && TREE_CODE (t
) != ENUMERAL_TYPE
2839 && TREE_CODE (t
) != QUAL_UNION_TYPE
2840 && TREE_CODE (t
) != UNION_TYPE
2841 && TREE_CODE (t
) != POINTER_TYPE
)
2844 if (TYPE_SIZE (t
) == 0)
2847 /* Look up t in hash table. Only one of the compatible types within each
2848 alias set is recorded in the table. */
2849 if (!type_hash_table
)
2850 type_hash_table
= htab_create (1021, c_type_hash
,
2851 (htab_eq
) lang_hooks
.types_compatible_p
,
2853 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
2855 return TYPE_ALIAS_SET ((tree
)*slot
);
2857 /* Our caller will assign and record (in t) a new alias set; all we need
2858 to do is remember t in the hash table. */
2864 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2865 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2866 flag controls whether we should diagnose possibly ill-formed
2867 constructs or not. */
2869 c_sizeof_or_alignof_type (tree type
, enum tree_code op
, int complain
)
2871 const char *op_name
;
2873 enum tree_code type_code
= TREE_CODE (type
);
2875 my_friendly_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
, 20020720);
2876 op_name
= op
== SIZEOF_EXPR
? "sizeof" : "__alignof__";
2878 if (type_code
== FUNCTION_TYPE
)
2880 if (op
== SIZEOF_EXPR
)
2882 if (complain
&& (pedantic
|| warn_pointer_arith
))
2883 pedwarn ("invalid application of `sizeof' to a function type");
2884 value
= size_one_node
;
2887 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2889 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
2891 if (type_code
== VOID_TYPE
2892 && complain
&& (pedantic
|| warn_pointer_arith
))
2893 pedwarn ("invalid application of `%s' to a void type", op_name
);
2894 value
= size_one_node
;
2896 else if (!COMPLETE_TYPE_P (type
))
2899 error ("invalid application of `%s' to incomplete type `%T' ",
2901 value
= size_zero_node
;
2905 if (op
== SIZEOF_EXPR
)
2906 /* Convert in case a char is more than one unit. */
2907 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
2908 size_int (TYPE_PRECISION (char_type_node
)
2911 value
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
2914 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2915 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2916 never happen. However, this node should really have type
2917 `size_t', which is just a typedef for an ordinary integer type. */
2918 value
= fold (build1 (NOP_EXPR
, size_type_node
, value
));
2919 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)), 20001021);
2924 /* Implement the __alignof keyword: Return the minimum required
2925 alignment of EXPR, measured in bytes. For VAR_DECL's and
2926 FIELD_DECL's return DECL_ALIGN (which can be set from an
2927 "aligned" __attribute__ specification). */
2930 c_alignof_expr (tree expr
)
2934 if (TREE_CODE (expr
) == VAR_DECL
)
2935 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
2937 else if (TREE_CODE (expr
) == COMPONENT_REF
2938 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
2940 error ("`__alignof' applied to a bit-field");
2943 else if (TREE_CODE (expr
) == COMPONENT_REF
2944 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
2945 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
2947 else if (TREE_CODE (expr
) == INDIRECT_REF
)
2949 tree t
= TREE_OPERAND (expr
, 0);
2951 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2953 while (TREE_CODE (t
) == NOP_EXPR
2954 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
2958 t
= TREE_OPERAND (t
, 0);
2959 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2960 if (thisalign
> bestalign
)
2961 best
= t
, bestalign
= thisalign
;
2963 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
2966 return c_alignof (TREE_TYPE (expr
));
2968 return fold (build1 (NOP_EXPR
, size_type_node
, t
));
2971 /* Handle C and C++ default attributes. */
2973 enum built_in_attribute
2975 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2976 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2977 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2978 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2979 #include "builtin-attrs.def"
2980 #undef DEF_ATTR_NULL_TREE
2982 #undef DEF_ATTR_IDENT
2983 #undef DEF_ATTR_TREE_LIST
2987 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
2989 static void c_init_attributes (void);
2991 /* Build tree nodes and builtin functions common to both C and C++ language
2995 c_common_nodes_and_builtins (void)
2999 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3000 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3001 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3002 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3003 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3004 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3005 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3006 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3007 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3008 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3009 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3010 #include "builtin-types.def"
3011 #undef DEF_PRIMITIVE_TYPE
3012 #undef DEF_FUNCTION_TYPE_0
3013 #undef DEF_FUNCTION_TYPE_1
3014 #undef DEF_FUNCTION_TYPE_2
3015 #undef DEF_FUNCTION_TYPE_3
3016 #undef DEF_FUNCTION_TYPE_4
3017 #undef DEF_FUNCTION_TYPE_VAR_0
3018 #undef DEF_FUNCTION_TYPE_VAR_1
3019 #undef DEF_FUNCTION_TYPE_VAR_2
3020 #undef DEF_FUNCTION_TYPE_VAR_3
3021 #undef DEF_POINTER_TYPE
3025 typedef enum builtin_type builtin_type
;
3027 tree builtin_types
[(int) BT_LAST
];
3028 int wchar_type_size
;
3029 tree array_domain_type
;
3030 tree va_list_ref_type_node
;
3031 tree va_list_arg_type_node
;
3033 /* Define `int' and `char' first so that dbx will output them first. */
3034 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3035 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3037 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3038 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3039 but not C. Are the conditionals here needed? */
3040 if (c_dialect_cxx ())
3041 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3042 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3043 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3044 record_builtin_type (RID_MAX
, "long unsigned int",
3045 long_unsigned_type_node
);
3046 if (c_dialect_cxx ())
3047 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3048 record_builtin_type (RID_MAX
, "long long int",
3049 long_long_integer_type_node
);
3050 record_builtin_type (RID_MAX
, "long long unsigned int",
3051 long_long_unsigned_type_node
);
3052 if (c_dialect_cxx ())
3053 record_builtin_type (RID_MAX
, "long long unsigned",
3054 long_long_unsigned_type_node
);
3055 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3056 record_builtin_type (RID_MAX
, "short unsigned int",
3057 short_unsigned_type_node
);
3058 if (c_dialect_cxx ())
3059 record_builtin_type (RID_MAX
, "unsigned short",
3060 short_unsigned_type_node
);
3062 /* Define both `signed char' and `unsigned char'. */
3063 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3064 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3066 /* These are types that c_common_type_for_size and
3067 c_common_type_for_mode use. */
3068 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
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 #if HOST_BITS_PER_WIDE_INT >= 64
3077 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3078 get_identifier ("__int128_t"),
3081 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3082 unsigned_intQI_type_node
));
3083 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3084 unsigned_intHI_type_node
));
3085 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3086 unsigned_intSI_type_node
));
3087 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3088 unsigned_intDI_type_node
));
3089 #if HOST_BITS_PER_WIDE_INT >= 64
3090 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3091 get_identifier ("__uint128_t"),
3092 unsigned_intTI_type_node
));
3095 /* Create the widest literal types. */
3096 widest_integer_literal_type_node
3097 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3098 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3099 widest_integer_literal_type_node
));
3101 widest_unsigned_literal_type_node
3102 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3103 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3104 widest_unsigned_literal_type_node
));
3106 /* `unsigned long' is the standard type for sizeof.
3107 Note that stddef.h uses `unsigned long',
3108 and this must agree, even if long and int are the same size. */
3110 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3111 signed_size_type_node
= c_common_signed_type (size_type_node
);
3112 set_sizetype (size_type_node
);
3115 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
3117 build_common_tree_nodes_2 (flag_short_double
);
3119 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3120 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3121 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3123 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3124 get_identifier ("complex int"),
3125 complex_integer_type_node
));
3126 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3127 get_identifier ("complex float"),
3128 complex_float_type_node
));
3129 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3130 get_identifier ("complex double"),
3131 complex_double_type_node
));
3132 lang_hooks
.decls
.pushdecl
3133 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3134 complex_long_double_type_node
));
3136 if (c_dialect_cxx ())
3137 /* For C++, make fileptr_type_node a distinct void * type until
3138 FILE type is defined. */
3139 fileptr_type_node
= build_type_copy (ptr_type_node
);
3141 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3143 void_zero_node
= build_int_2 (0, 0);
3144 TREE_TYPE (void_zero_node
) = void_type_node
;
3146 void_list_node
= build_void_list_node ();
3148 /* Make a type to be the domain of a few array types
3149 whose domains don't really matter.
3150 200 is small enough that it always fits in size_t
3151 and large enough that it can hold most function names for the
3152 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3153 array_domain_type
= build_index_type (size_int (200));
3155 /* Make a type for arrays of characters.
3156 With luck nothing will ever really depend on the length of this
3158 char_array_type_node
3159 = build_array_type (char_type_node
, array_domain_type
);
3161 /* Likewise for arrays of ints. */
3163 = build_array_type (integer_type_node
, array_domain_type
);
3165 string_type_node
= build_pointer_type (char_type_node
);
3166 const_string_type_node
3167 = build_pointer_type (build_qualified_type
3168 (char_type_node
, TYPE_QUAL_CONST
));
3170 /* This is special for C++ so functions can be overloaded. */
3171 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3172 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3173 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3174 if (c_dialect_cxx ())
3176 if (TYPE_UNSIGNED (wchar_type_node
))
3177 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3179 wchar_type_node
= make_signed_type (wchar_type_size
);
3180 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3184 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3185 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3188 /* This is for wide string constants. */
3189 wchar_array_type_node
3190 = build_array_type (wchar_type_node
, array_domain_type
);
3193 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3196 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3198 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3200 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3202 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3203 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3205 lang_hooks
.decls
.pushdecl
3206 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3207 va_list_type_node
));
3209 lang_hooks
.decls
.pushdecl
3210 (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
3211 ptrdiff_type_node
));
3213 lang_hooks
.decls
.pushdecl
3214 (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
3217 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3219 va_list_arg_type_node
= va_list_ref_type_node
=
3220 build_pointer_type (TREE_TYPE (va_list_type_node
));
3224 va_list_arg_type_node
= va_list_type_node
;
3225 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3228 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3229 builtin_types[(int) ENUM] = VALUE;
3230 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3231 builtin_types[(int) ENUM] \
3232 = build_function_type (builtin_types[(int) RETURN], \
3234 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3235 builtin_types[(int) ENUM] \
3236 = build_function_type (builtin_types[(int) RETURN], \
3237 tree_cons (NULL_TREE, \
3238 builtin_types[(int) ARG1], \
3240 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3241 builtin_types[(int) ENUM] \
3242 = build_function_type \
3243 (builtin_types[(int) RETURN], \
3244 tree_cons (NULL_TREE, \
3245 builtin_types[(int) ARG1], \
3246 tree_cons (NULL_TREE, \
3247 builtin_types[(int) ARG2], \
3249 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3250 builtin_types[(int) ENUM] \
3251 = build_function_type \
3252 (builtin_types[(int) RETURN], \
3253 tree_cons (NULL_TREE, \
3254 builtin_types[(int) ARG1], \
3255 tree_cons (NULL_TREE, \
3256 builtin_types[(int) ARG2], \
3257 tree_cons (NULL_TREE, \
3258 builtin_types[(int) ARG3], \
3260 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3261 builtin_types[(int) ENUM] \
3262 = build_function_type \
3263 (builtin_types[(int) RETURN], \
3264 tree_cons (NULL_TREE, \
3265 builtin_types[(int) ARG1], \
3266 tree_cons (NULL_TREE, \
3267 builtin_types[(int) ARG2], \
3270 builtin_types[(int) ARG3], \
3271 tree_cons (NULL_TREE, \
3272 builtin_types[(int) ARG4], \
3273 void_list_node)))));
3274 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3275 builtin_types[(int) ENUM] \
3276 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3277 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3278 builtin_types[(int) ENUM] \
3279 = build_function_type (builtin_types[(int) RETURN], \
3280 tree_cons (NULL_TREE, \
3281 builtin_types[(int) ARG1], \
3284 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3285 builtin_types[(int) ENUM] \
3286 = build_function_type \
3287 (builtin_types[(int) RETURN], \
3288 tree_cons (NULL_TREE, \
3289 builtin_types[(int) ARG1], \
3290 tree_cons (NULL_TREE, \
3291 builtin_types[(int) ARG2], \
3294 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3295 builtin_types[(int) ENUM] \
3296 = build_function_type \
3297 (builtin_types[(int) RETURN], \
3298 tree_cons (NULL_TREE, \
3299 builtin_types[(int) ARG1], \
3300 tree_cons (NULL_TREE, \
3301 builtin_types[(int) ARG2], \
3302 tree_cons (NULL_TREE, \
3303 builtin_types[(int) ARG3], \
3306 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3307 builtin_types[(int) ENUM] \
3308 = build_pointer_type (builtin_types[(int) TYPE]);
3309 #include "builtin-types.def"
3310 #undef DEF_PRIMITIVE_TYPE
3311 #undef DEF_FUNCTION_TYPE_1
3312 #undef DEF_FUNCTION_TYPE_2
3313 #undef DEF_FUNCTION_TYPE_3
3314 #undef DEF_FUNCTION_TYPE_4
3315 #undef DEF_FUNCTION_TYPE_VAR_0
3316 #undef DEF_FUNCTION_TYPE_VAR_1
3317 #undef DEF_FUNCTION_TYPE_VAR_2
3318 #undef DEF_FUNCTION_TYPE_VAR_3
3319 #undef DEF_POINTER_TYPE
3321 c_init_attributes ();
3323 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3324 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3329 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3333 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3336 ? (NAME + strlen ("__builtin_")) \
3338 built_in_attributes[(int) ATTRS]); \
3340 decl = builtin_function_2 (NAME, \
3341 NAME + strlen ("__builtin_"), \
3342 builtin_types[TYPE], \
3343 builtin_types[LIBTYPE], \
3348 built_in_attributes[(int) ATTRS]); \
3350 built_in_decls[(int) ENUM] = decl; \
3352 implicit_built_in_decls[(int) ENUM] = decl; \
3354 #include "builtins.def"
3357 targetm
.init_builtins ();
3359 main_identifier_node
= get_identifier ("main");
3363 build_va_arg (tree expr
, tree type
)
3365 return build1 (VA_ARG_EXPR
, type
, expr
);
3369 /* Linked list of disabled built-in functions. */
3371 typedef struct disabled_builtin
3374 struct disabled_builtin
*next
;
3376 static disabled_builtin
*disabled_builtins
= NULL
;
3378 static bool builtin_function_disabled_p (const char *);
3380 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3381 begins with "__builtin_", give an error. */
3384 disable_builtin_function (const char *name
)
3386 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3387 error ("cannot disable built-in function `%s'", name
);
3390 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
3392 new->next
= disabled_builtins
;
3393 disabled_builtins
= new;
3398 /* Return true if the built-in function NAME has been disabled, false
3402 builtin_function_disabled_p (const char *name
)
3404 disabled_builtin
*p
;
3405 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3407 if (strcmp (name
, p
->name
) == 0)
3414 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3415 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3416 of these may be NULL (though both being NULL is useless).
3417 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3418 TYPE is the type of the function with the ordinary name. These
3419 may differ if the ordinary name is declared with a looser type to avoid
3420 conflicts with headers. FUNCTION_CODE and CLASS are as for
3421 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3422 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3423 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3424 ATTRS is the tree list representing the builtin's function attributes.
3425 Returns the declaration of BUILTIN_NAME, if any, otherwise
3426 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3427 or if NONANSI_P and flag_no_nonansi_builtin. */
3430 builtin_function_2 (const char *builtin_name
, const char *name
,
3431 tree builtin_type
, tree type
, int function_code
,
3432 enum built_in_class
class, int library_name_p
,
3433 int nonansi_p
, tree attrs
)
3435 tree bdecl
= NULL_TREE
;
3436 tree decl
= NULL_TREE
;
3438 if (builtin_name
!= 0)
3439 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
3440 class, library_name_p
? name
: NULL
, attrs
);
3442 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
3443 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3444 decl
= builtin_function (name
, type
, function_code
, class, NULL
, attrs
);
3446 return (bdecl
!= 0 ? bdecl
: decl
);
3449 /* Nonzero if the type T promotes to int. This is (nearly) the
3450 integral promotions defined in ISO C99 6.3.1.1/2. */
3453 c_promoting_integer_type_p (tree t
)
3455 switch (TREE_CODE (t
))
3458 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3459 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3460 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3461 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3462 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3463 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3466 /* ??? Technically all enumerations not larger than an int
3467 promote to an int. But this is used along code paths
3468 that only want to notice a size change. */
3469 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3479 /* Return 1 if PARMS specifies a fixed number of parameters
3480 and none of their types is affected by default promotions. */
3483 self_promoting_args_p (tree parms
)
3486 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3488 tree type
= TREE_VALUE (t
);
3490 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3496 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3499 if (c_promoting_integer_type_p (type
))
3505 /* Recursively examines the array elements of TYPE, until a non-array
3506 element type is found. */
3509 strip_array_types (tree type
)
3511 while (TREE_CODE (type
) == ARRAY_TYPE
)
3512 type
= TREE_TYPE (type
);
3517 /* Recursively remove any '*' or '&' operator from TYPE. */
3519 strip_pointer_operator (tree t
)
3521 while (POINTER_TYPE_P (t
))
3526 static tree
expand_unordered_cmp (tree
, tree
, enum tree_code
, enum tree_code
);
3528 /* Expand a call to an unordered comparison function such as
3529 __builtin_isgreater(). FUNCTION is the function's declaration and
3530 PARAMS a list of the values passed. For __builtin_isunordered(),
3531 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3532 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3533 that give the opposite of the desired result. UNORDERED_CODE is
3534 used for modes that can hold NaNs and ORDERED_CODE is used for the
3538 expand_unordered_cmp (tree function
, tree params
,
3539 enum tree_code unordered_code
,
3540 enum tree_code ordered_code
)
3542 tree arg0
, arg1
, type
;
3543 enum tree_code code0
, code1
;
3545 /* Check that we have exactly two arguments. */
3546 if (params
== 0 || TREE_CHAIN (params
) == 0)
3548 error ("too few arguments to function `%s'",
3549 IDENTIFIER_POINTER (DECL_NAME (function
)));
3550 return error_mark_node
;
3552 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3554 error ("too many arguments to function `%s'",
3555 IDENTIFIER_POINTER (DECL_NAME (function
)));
3556 return error_mark_node
;
3559 arg0
= TREE_VALUE (params
);
3560 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3562 code0
= TREE_CODE (TREE_TYPE (arg0
));
3563 code1
= TREE_CODE (TREE_TYPE (arg1
));
3565 /* Make sure that the arguments have a common type of REAL. */
3567 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3568 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3569 type
= common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
));
3571 if (type
== 0 || TREE_CODE (type
) != REAL_TYPE
)
3573 error ("non-floating-point argument to function `%s'",
3574 IDENTIFIER_POINTER (DECL_NAME (function
)));
3575 return error_mark_node
;
3578 if (unordered_code
== UNORDERED_EXPR
)
3580 if (MODE_HAS_NANS (TYPE_MODE (type
)))
3581 return build_binary_op (unordered_code
,
3582 convert (type
, arg0
),
3583 convert (type
, arg1
),
3586 return integer_zero_node
;
3589 return build_unary_op (TRUTH_NOT_EXPR
,
3590 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type
))
3593 convert (type
, arg0
),
3594 convert (type
, arg1
),
3600 /* Recognize certain built-in functions so we can make tree-codes
3601 other than CALL_EXPR. We do this when it enables fold-const.c
3602 to do something useful. */
3603 /* ??? By rights this should go in builtins.c, but only C and C++
3604 implement build_{binary,unary}_op. Not exactly sure what bits
3605 of functionality are actually needed from those functions, or
3606 where the similar functionality exists in the other front ends. */
3609 expand_tree_builtin (tree function
, tree params
, tree coerced_params
)
3611 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
3614 switch (DECL_FUNCTION_CODE (function
))
3618 case BUILT_IN_LLABS
:
3619 case BUILT_IN_IMAXABS
:
3621 case BUILT_IN_FABSL
:
3622 case BUILT_IN_FABSF
:
3623 if (coerced_params
== 0)
3624 return integer_zero_node
;
3625 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3628 case BUILT_IN_CONJF
:
3629 case BUILT_IN_CONJL
:
3630 if (coerced_params
== 0)
3631 return integer_zero_node
;
3632 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3634 case BUILT_IN_CREAL
:
3635 case BUILT_IN_CREALF
:
3636 case BUILT_IN_CREALL
:
3637 if (coerced_params
== 0)
3638 return integer_zero_node
;
3639 return non_lvalue (build_unary_op (REALPART_EXPR
,
3640 TREE_VALUE (coerced_params
), 0));
3642 case BUILT_IN_CIMAG
:
3643 case BUILT_IN_CIMAGF
:
3644 case BUILT_IN_CIMAGL
:
3645 if (coerced_params
== 0)
3646 return integer_zero_node
;
3647 return non_lvalue (build_unary_op (IMAGPART_EXPR
,
3648 TREE_VALUE (coerced_params
), 0));
3650 case BUILT_IN_ISGREATER
:
3651 return expand_unordered_cmp (function
, params
, UNLE_EXPR
, LE_EXPR
);
3653 case BUILT_IN_ISGREATEREQUAL
:
3654 return expand_unordered_cmp (function
, params
, UNLT_EXPR
, LT_EXPR
);
3656 case BUILT_IN_ISLESS
:
3657 return expand_unordered_cmp (function
, params
, UNGE_EXPR
, GE_EXPR
);
3659 case BUILT_IN_ISLESSEQUAL
:
3660 return expand_unordered_cmp (function
, params
, UNGT_EXPR
, GT_EXPR
);
3662 case BUILT_IN_ISLESSGREATER
:
3663 return expand_unordered_cmp (function
, params
, UNEQ_EXPR
, EQ_EXPR
);
3665 case BUILT_IN_ISUNORDERED
:
3666 return expand_unordered_cmp (function
, params
, UNORDERED_EXPR
, NOP_EXPR
);
3675 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3676 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3677 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3678 value, the traversal is aborted, and the value returned by FUNC is
3679 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3680 the node being visited are not walked.
3682 We don't need a without_duplicates variant of this one because the
3683 statement tree is a tree, not a graph. */
3686 walk_stmt_tree (tree
*tp
, walk_tree_fn func
, void *data
)
3688 enum tree_code code
;
3693 #define WALK_SUBTREE(NODE) \
3696 result = walk_stmt_tree (&(NODE), func, data); \
3702 /* Skip empty subtrees. */
3706 /* Skip subtrees below non-statement nodes. */
3707 if (!STATEMENT_CODE_P (TREE_CODE (*tp
)))
3710 /* Call the function. */
3712 result
= (*func
) (tp
, &walk_subtrees
, data
);
3714 /* If we found something, return it. */
3718 /* FUNC may have modified the tree, recheck that we're looking at a
3720 code
= TREE_CODE (*tp
);
3721 if (!STATEMENT_CODE_P (code
))
3724 /* Visit the subtrees unless FUNC decided that there was nothing
3725 interesting below this point in the tree. */
3728 /* Walk over all the sub-trees of this operand. Statement nodes
3729 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3730 len
= TREE_CODE_LENGTH (code
);
3732 /* Go through the subtrees. We need to do this in forward order so
3733 that the scope of a FOR_EXPR is handled properly. */
3734 for (i
= 0; i
< len
; ++i
)
3735 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3738 /* Finally visit the chain. This can be tail-recursion optimized if
3739 we write it this way. */
3740 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3745 /* Used to compare case labels. K1 and K2 are actually tree nodes
3746 representing case labels, or NULL_TREE for a `default' label.
3747 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3748 K2, and 0 if K1 and K2 are equal. */
3751 case_compare (splay_tree_key k1
, splay_tree_key k2
)
3753 /* Consider a NULL key (such as arises with a `default' label) to be
3754 smaller than anything else. */
3760 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3763 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3764 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3765 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3766 case label was declared using the usual C/C++ syntax, rather than
3767 the GNU case range extension. CASES is a tree containing all the
3768 case ranges processed so far; COND is the condition for the
3769 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3770 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3773 c_add_case_label (splay_tree cases
, tree cond
, tree low_value
,
3779 splay_tree_node node
;
3781 /* Create the LABEL_DECL itself. */
3782 label
= create_artificial_label ();
3784 /* If there was an error processing the switch condition, bail now
3785 before we get more confused. */
3786 if (!cond
|| cond
== error_mark_node
)
3789 if ((low_value
&& TREE_TYPE (low_value
)
3790 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3791 || (high_value
&& TREE_TYPE (high_value
)
3792 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3793 error ("pointers are not permitted as case values");
3795 /* Case ranges are a GNU extension. */
3796 if (high_value
&& pedantic
)
3797 pedwarn ("range expressions in switch statements are non-standard");
3799 type
= TREE_TYPE (cond
);
3802 low_value
= check_case_value (low_value
);
3803 low_value
= convert_and_check (type
, low_value
);
3807 high_value
= check_case_value (high_value
);
3808 high_value
= convert_and_check (type
, high_value
);
3811 /* If an error has occurred, bail out now. */
3812 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
3815 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3816 really a case range, even though it was written that way. Remove
3817 the HIGH_VALUE to simplify later processing. */
3818 if (tree_int_cst_equal (low_value
, high_value
))
3819 high_value
= NULL_TREE
;
3820 if (low_value
&& high_value
3821 && !tree_int_cst_lt (low_value
, high_value
))
3822 warning ("empty range specified");
3824 /* Look up the LOW_VALUE in the table of case labels we already
3826 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3827 /* If there was not an exact match, check for overlapping ranges.
3828 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3829 that's a `default' label and the only overlap is an exact match. */
3830 if (!node
&& (low_value
|| high_value
))
3832 splay_tree_node low_bound
;
3833 splay_tree_node high_bound
;
3835 /* Even though there wasn't an exact match, there might be an
3836 overlap between this case range and another case range.
3837 Since we've (inductively) not allowed any overlapping case
3838 ranges, we simply need to find the greatest low case label
3839 that is smaller that LOW_VALUE, and the smallest low case
3840 label that is greater than LOW_VALUE. If there is an overlap
3841 it will occur in one of these two ranges. */
3842 low_bound
= splay_tree_predecessor (cases
,
3843 (splay_tree_key
) low_value
);
3844 high_bound
= splay_tree_successor (cases
,
3845 (splay_tree_key
) low_value
);
3847 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3848 the LOW_VALUE, so there is no need to check unless the
3849 LOW_BOUND is in fact itself a case range. */
3851 && CASE_HIGH ((tree
) low_bound
->value
)
3852 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3855 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3856 range is bigger than the low end of the current range, so we
3857 are only interested if the current range is a real range, and
3858 not an ordinary case label. */
3861 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3866 /* If there was an overlap, issue an error. */
3869 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
3873 error ("duplicate (or overlapping) case value");
3874 error ("%Jthis is the first entry overlapping that value", duplicate
);
3878 error ("duplicate case value") ;
3879 error ("%Jpreviously used here", duplicate
);
3883 error ("multiple default labels in one switch");
3884 error ("%Jthis is the first default label", duplicate
);
3889 /* Add a CASE_LABEL to the statement-tree. */
3890 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3891 /* Register this case label in the splay tree. */
3892 splay_tree_insert (cases
,
3893 (splay_tree_key
) low_value
,
3894 (splay_tree_value
) case_label
);
3899 /* Add a label so that the back-end doesn't think that the beginning of
3900 the switch is unreachable. Note that we do not add a case label, as
3901 that just leads to duplicates and thence to aborts later on. */
3904 tree t
= create_artificial_label ();
3905 add_stmt (build_stmt (LABEL_EXPR
, t
));
3907 return error_mark_node
;
3910 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3911 Used to verify that case values match up with enumerator values. */
3914 match_case_to_enum_1 (tree key
, tree type
, tree label
)
3916 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
3918 /* ??? Not working too hard to print the double-word value.
3919 Should perhaps be done with %lwd in the diagnostic routines? */
3920 if (TREE_INT_CST_HIGH (key
) == 0)
3921 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
3922 TREE_INT_CST_LOW (key
));
3923 else if (!TYPE_UNSIGNED (type
)
3924 && TREE_INT_CST_HIGH (key
) == -1
3925 && TREE_INT_CST_LOW (key
) != 0)
3926 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
3927 -TREE_INT_CST_LOW (key
));
3929 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3930 TREE_INT_CST_HIGH (key
), TREE_INT_CST_LOW (key
));
3932 if (TYPE_NAME (type
) == 0)
3933 warning ("%Jcase value `%s' not in enumerated type",
3934 CASE_LABEL (label
), buf
);
3936 warning ("%Jcase value `%s' not in enumerated type `%T'",
3937 CASE_LABEL (label
), buf
, type
);
3941 match_case_to_enum (splay_tree_node node
, void *data
)
3943 tree label
= (tree
) node
->value
;
3946 /* Skip default case. */
3947 if (!CASE_LOW (label
))
3950 /* If TREE_ADDRESSABLE is not set, that means CASE_LOW did not appear
3951 when we did our enum->case scan. Reset our scratch bit after. */
3952 if (!TREE_ADDRESSABLE (label
))
3953 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
3955 TREE_ADDRESSABLE (label
) = 0;
3957 /* If CASE_HIGH is non-null, we have a range. Here we must search.
3958 Note that the old code in stmt.c did not check for the values in
3959 the range either, just the endpoints. */
3960 if (CASE_HIGH (label
))
3962 tree chain
, key
= CASE_HIGH (label
);
3964 for (chain
= TYPE_VALUES (type
);
3965 chain
&& !tree_int_cst_equal (key
, TREE_VALUE (chain
));
3966 chain
= TREE_CHAIN (chain
))
3969 match_case_to_enum_1 (key
, type
, label
);
3975 /* Handle -Wswitch*. Called from the front end after parsing the switch
3977 /* ??? Should probably be somewhere generic, since other languages besides
3978 C and C++ would want this. We'd want to agree on the datastructure,
3979 however, which is a problem. Alternately, we operate on gimplified
3980 switch_exprs, which I don't especially like. At the moment, however,
3981 C/C++ are the only tree-ssa languages that support enumerations at all,
3982 so the point is moot. */
3985 c_do_switch_warnings (splay_tree cases
, tree switch_stmt
)
3987 splay_tree_node default_node
;
3988 location_t
*switch_locus
;
3991 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
3994 switch_locus
= EXPR_LOCUS (switch_stmt
);
3996 switch_locus
= &input_location
;
3997 type
= SWITCH_TYPE (switch_stmt
);
3999 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
4000 if (warn_switch_default
&& !default_node
)
4001 warning ("%Hswitch missing default case", switch_locus
);
4003 /* If the switch expression was an enumerated type, check that
4004 exactly all enumeration literals are covered by the cases.
4005 The check is made when -Wswitch was specified and there is no
4006 default case, or when -Wswitch-enum was specified. */
4007 if (((warn_switch
&& !default_node
) || warn_switch_enum
)
4008 && type
&& TREE_CODE (type
) == ENUMERAL_TYPE
4009 && TREE_CODE (SWITCH_COND (switch_stmt
)) != INTEGER_CST
)
4013 /* The time complexity here is O(N*lg(N)) worst case, but for the
4014 common case of monotonically increasing enumerators, it is
4015 O(N), since the nature of the splay tree will keep the next
4016 element adjacent to the root at all times. */
4018 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
4020 splay_tree_node node
4021 = splay_tree_lookup (cases
, (splay_tree_key
) TREE_VALUE (chain
));
4025 /* Mark the CASE_LOW part of the case entry as seen, so
4026 that we save time later. Choose TREE_ADDRESSABLE
4027 randomly as a bit that won't have been set to-date. */
4028 tree label
= (tree
) node
->value
;
4029 TREE_ADDRESSABLE (label
) = 1;
4033 /* Warn if there are enumerators that don't correspond to
4034 case expressions. */
4035 warning ("%Henumeration value `%E' not handled in switch",
4036 switch_locus
, TREE_PURPOSE (chain
));
4040 /* Warn if there are case expressions that don't correspond to
4041 enumerators. This can occur since C and C++ don't enforce
4042 type-checking of assignments to enumeration variables.
4044 The time complexity here is O(N**2) worst case, since we've
4045 not sorted the enumeration values. However, in the absence
4046 of case ranges this is O(N), since all single cases that
4047 corresponded to enumerations have been marked above. */
4049 splay_tree_foreach (cases
, match_case_to_enum
, type
);
4053 /* Finish an expression taking the address of LABEL (an
4054 IDENTIFIER_NODE). Returns an expression for the address. */
4057 finish_label_address_expr (tree label
)
4062 pedwarn ("taking the address of a label is non-standard");
4064 if (label
== error_mark_node
)
4065 return error_mark_node
;
4067 label
= lookup_label (label
);
4068 if (label
== NULL_TREE
)
4069 result
= null_pointer_node
;
4072 TREE_USED (label
) = 1;
4073 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4074 /* The current function in not necessarily uninlinable.
4075 Computed gotos are incompatible with inlining, but the value
4076 here could be used only in a diagnostic, for example. */
4082 /* Hook used by expand_expr to expand language-specific tree codes. */
4083 /* The only things that should go here are bits needed to expand
4084 constant initializers. Everything else should be handled by the
4085 gimplification routines. */
4088 c_expand_expr (tree exp
, rtx target
, enum machine_mode tmode
,
4089 int modifier
/* Actually enum_modifier. */,
4092 switch (TREE_CODE (exp
))
4094 case COMPOUND_LITERAL_EXPR
:
4096 /* Initialize the anonymous variable declared in the compound
4097 literal, then return the variable. */
4098 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4099 emit_local_var (decl
);
4100 return expand_expr_real (decl
, target
, tmode
, modifier
, alt_rtl
);
4108 /* Hook used by safe_from_p to handle language-specific tree codes. */
4111 c_safe_from_p (rtx target
, tree exp
)
4113 /* We can see statements here when processing the body of a
4114 statement-expression. For a declaration statement declaring a
4115 variable, look at the variable's initializer. */
4116 if (TREE_CODE (exp
) == DECL_STMT
)
4118 tree decl
= DECL_STMT_DECL (exp
);
4120 if (TREE_CODE (decl
) == VAR_DECL
4121 && DECL_INITIAL (decl
)
4122 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
4126 /* Assume everything else is safe. */
4130 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4133 c_common_unsafe_for_reeval (tree exp
)
4135 /* Statement expressions may not be reevaluated, likewise compound
4137 if (TREE_CODE (exp
) == STMT_EXPR
4138 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
4141 /* Walk all other expressions. */
4145 /* Hook used by staticp to handle language-specific tree codes. */
4148 c_staticp (tree exp
)
4150 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4151 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
4157 /* Given a boolean expression ARG, return a tree representing an increment
4158 or decrement (as indicated by CODE) of ARG. The front end must check for
4159 invalid cases (e.g., decrement in C++). */
4161 boolean_increment (enum tree_code code
, tree arg
)
4164 tree true_res
= boolean_true_node
;
4166 arg
= stabilize_reference (arg
);
4169 case PREINCREMENT_EXPR
:
4170 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4172 case POSTINCREMENT_EXPR
:
4173 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4174 arg
= save_expr (arg
);
4175 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4176 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4178 case PREDECREMENT_EXPR
:
4179 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4181 case POSTDECREMENT_EXPR
:
4182 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4183 arg
= save_expr (arg
);
4184 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4185 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4190 TREE_SIDE_EFFECTS (val
) = 1;
4194 /* Built-in macros for stddef.h, that require macros defined in this
4197 c_stddef_cpp_builtins(void)
4199 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4200 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4201 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4202 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4206 c_init_attributes (void)
4208 /* Fill in the built_in_attributes array. */
4209 #define DEF_ATTR_NULL_TREE(ENUM) \
4210 built_in_attributes[(int) ENUM] = NULL_TREE;
4211 #define DEF_ATTR_INT(ENUM, VALUE) \
4212 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4213 #define DEF_ATTR_IDENT(ENUM, STRING) \
4214 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4215 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4216 built_in_attributes[(int) ENUM] \
4217 = tree_cons (built_in_attributes[(int) PURPOSE], \
4218 built_in_attributes[(int) VALUE], \
4219 built_in_attributes[(int) CHAIN]);
4220 #include "builtin-attrs.def"
4221 #undef DEF_ATTR_NULL_TREE
4223 #undef DEF_ATTR_IDENT
4224 #undef DEF_ATTR_TREE_LIST
4227 /* Attribute handlers common to C front ends. */
4229 /* Handle a "packed" attribute; arguments as in
4230 struct attribute_spec.handler. */
4233 handle_packed_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4234 int flags
, bool *no_add_attrs
)
4238 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4239 *node
= build_type_copy (*node
);
4240 TYPE_PACKED (*node
) = 1;
4241 if (TYPE_MAIN_VARIANT (*node
) == *node
)
4243 /* If it is the main variant, then pack the other variants
4244 too. This happens in,
4247 struct Foo const *ptr; // creates a variant w/o packed flag
4248 } __ attribute__((packed)); // packs it now.
4252 for (probe
= *node
; probe
; probe
= TYPE_NEXT_VARIANT (probe
))
4253 TYPE_PACKED (probe
) = 1;
4257 else if (TREE_CODE (*node
) == FIELD_DECL
)
4258 DECL_PACKED (*node
) = 1;
4259 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4260 used for DECL_REGISTER. It wouldn't mean anything anyway.
4261 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4262 that changes what the typedef is typing. */
4265 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4266 *no_add_attrs
= true;
4272 /* Handle a "nocommon" attribute; arguments as in
4273 struct attribute_spec.handler. */
4276 handle_nocommon_attribute (tree
*node
, tree name
,
4277 tree args ATTRIBUTE_UNUSED
,
4278 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4280 if (TREE_CODE (*node
) == VAR_DECL
)
4281 DECL_COMMON (*node
) = 0;
4284 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4285 *no_add_attrs
= true;
4291 /* Handle a "common" attribute; arguments as in
4292 struct attribute_spec.handler. */
4295 handle_common_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4296 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4298 if (TREE_CODE (*node
) == VAR_DECL
)
4299 DECL_COMMON (*node
) = 1;
4302 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4303 *no_add_attrs
= true;
4309 /* Handle a "noreturn" attribute; arguments as in
4310 struct attribute_spec.handler. */
4313 handle_noreturn_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4314 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4316 tree type
= TREE_TYPE (*node
);
4318 /* See FIXME comment in c_common_attribute_table. */
4319 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4320 TREE_THIS_VOLATILE (*node
) = 1;
4321 else if (TREE_CODE (type
) == POINTER_TYPE
4322 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4324 = build_pointer_type
4325 (build_type_variant (TREE_TYPE (type
),
4326 TYPE_READONLY (TREE_TYPE (type
)), 1));
4329 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4330 *no_add_attrs
= true;
4336 /* Handle a "noinline" attribute; arguments as in
4337 struct attribute_spec.handler. */
4340 handle_noinline_attribute (tree
*node
, tree name
,
4341 tree args ATTRIBUTE_UNUSED
,
4342 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4344 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4345 DECL_UNINLINABLE (*node
) = 1;
4348 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4349 *no_add_attrs
= true;
4355 /* Handle a "always_inline" attribute; arguments as in
4356 struct attribute_spec.handler. */
4359 handle_always_inline_attribute (tree
*node
, tree name
,
4360 tree args ATTRIBUTE_UNUSED
,
4361 int flags ATTRIBUTE_UNUSED
,
4364 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4366 /* Do nothing else, just set the attribute. We'll get at
4367 it later with lookup_attribute. */
4371 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4372 *no_add_attrs
= true;
4378 /* Handle a "used" attribute; arguments as in
4379 struct attribute_spec.handler. */
4382 handle_used_attribute (tree
*pnode
, tree name
, tree args ATTRIBUTE_UNUSED
,
4383 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4387 if (TREE_CODE (node
) == FUNCTION_DECL
4388 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
4390 TREE_USED (node
) = 1;
4394 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4395 *no_add_attrs
= true;
4401 /* Handle a "unused" attribute; arguments as in
4402 struct attribute_spec.handler. */
4405 handle_unused_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4406 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4412 if (TREE_CODE (decl
) == PARM_DECL
4413 || TREE_CODE (decl
) == VAR_DECL
4414 || TREE_CODE (decl
) == FUNCTION_DECL
4415 || TREE_CODE (decl
) == LABEL_DECL
4416 || TREE_CODE (decl
) == TYPE_DECL
)
4417 TREE_USED (decl
) = 1;
4420 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4421 *no_add_attrs
= true;
4426 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4427 *node
= build_type_copy (*node
);
4428 TREE_USED (*node
) = 1;
4434 /* Handle a "const" attribute; arguments as in
4435 struct attribute_spec.handler. */
4438 handle_const_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4439 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4441 tree type
= TREE_TYPE (*node
);
4443 /* See FIXME comment on noreturn in c_common_attribute_table. */
4444 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4445 TREE_READONLY (*node
) = 1;
4446 else if (TREE_CODE (type
) == POINTER_TYPE
4447 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4449 = build_pointer_type
4450 (build_type_variant (TREE_TYPE (type
), 1,
4451 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
4454 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4455 *no_add_attrs
= true;
4461 /* Handle a "transparent_union" attribute; arguments as in
4462 struct attribute_spec.handler. */
4465 handle_transparent_union_attribute (tree
*node
, tree name
,
4466 tree args ATTRIBUTE_UNUSED
, int flags
,
4469 tree decl
= NULL_TREE
;
4476 type
= &TREE_TYPE (decl
);
4477 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
4479 else if (TYPE_P (*node
))
4480 type
= node
, is_type
= 1;
4483 && TREE_CODE (*type
) == UNION_TYPE
4485 || (TYPE_FIELDS (*type
) != 0
4486 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))))
4488 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4489 *type
= build_type_copy (*type
);
4490 TYPE_TRANSPARENT_UNION (*type
) = 1;
4492 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
4493 && TREE_CODE (*type
) == UNION_TYPE
4494 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))
4495 DECL_TRANSPARENT_UNION (decl
) = 1;
4498 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4499 *no_add_attrs
= true;
4505 /* Handle a "constructor" attribute; arguments as in
4506 struct attribute_spec.handler. */
4509 handle_constructor_attribute (tree
*node
, tree name
,
4510 tree args ATTRIBUTE_UNUSED
,
4511 int flags ATTRIBUTE_UNUSED
,
4515 tree type
= TREE_TYPE (decl
);
4517 if (TREE_CODE (decl
) == FUNCTION_DECL
4518 && TREE_CODE (type
) == FUNCTION_TYPE
4519 && decl_function_context (decl
) == 0)
4521 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
4522 TREE_USED (decl
) = 1;
4526 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4527 *no_add_attrs
= true;
4533 /* Handle a "destructor" attribute; arguments as in
4534 struct attribute_spec.handler. */
4537 handle_destructor_attribute (tree
*node
, tree name
,
4538 tree args ATTRIBUTE_UNUSED
,
4539 int flags ATTRIBUTE_UNUSED
,
4543 tree type
= TREE_TYPE (decl
);
4545 if (TREE_CODE (decl
) == FUNCTION_DECL
4546 && TREE_CODE (type
) == FUNCTION_TYPE
4547 && decl_function_context (decl
) == 0)
4549 DECL_STATIC_DESTRUCTOR (decl
) = 1;
4550 TREE_USED (decl
) = 1;
4554 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4555 *no_add_attrs
= true;
4561 /* Handle a "mode" attribute; arguments as in
4562 struct attribute_spec.handler. */
4565 handle_mode_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4566 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4570 *no_add_attrs
= true;
4572 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
4573 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4577 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
4578 int len
= strlen (p
);
4579 enum machine_mode mode
= VOIDmode
;
4583 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
4584 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
4586 char *newp
= alloca (len
- 1);
4588 strcpy (newp
, &p
[2]);
4589 newp
[len
- 4] = '\0';
4593 /* Change this type to have a type with the specified mode.
4594 First check for the special modes. */
4595 if (! strcmp (p
, "byte"))
4597 else if (!strcmp (p
, "word"))
4599 else if (! strcmp (p
, "pointer"))
4602 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
4603 if (!strcmp (p
, GET_MODE_NAME (j
)))
4604 mode
= (enum machine_mode
) j
;
4606 if (mode
== VOIDmode
)
4608 error ("unknown machine mode `%s'", p
);
4612 if (VECTOR_MODE_P (mode
))
4614 warning ("specifying vector types with __attribute__ ((mode)) "
4616 warning ("use __attribute__ ((vector_size)) instead");
4619 typefm
= lang_hooks
.types
.type_for_mode (mode
, TYPE_UNSIGNED (type
));
4620 if (typefm
== NULL_TREE
)
4621 error ("no data type for mode `%s'", p
);
4623 else if ((TREE_CODE (type
) == POINTER_TYPE
4624 || TREE_CODE (type
) == REFERENCE_TYPE
)
4625 && !targetm
.valid_pointer_mode (mode
))
4626 error ("invalid pointer mode `%s'", p
);
4629 /* If this is a vector, make sure we either have hardware
4630 support, or we can emulate it. */
4631 if (VECTOR_MODE_P (mode
) && !vector_mode_valid_p (mode
))
4633 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
4637 if (TREE_CODE (type
) == POINTER_TYPE
)
4639 ptr_type
= build_pointer_type_for_mode (TREE_TYPE (type
),
4643 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
4645 ptr_type
= build_reference_type_for_mode (TREE_TYPE (type
),
4651 /* No need to layout the type here. The caller should do this. */
4658 /* Handle a "section" attribute; arguments as in
4659 struct attribute_spec.handler. */
4662 handle_section_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
, tree args
,
4663 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4667 if (targetm
.have_named_sections
)
4669 if ((TREE_CODE (decl
) == FUNCTION_DECL
4670 || TREE_CODE (decl
) == VAR_DECL
)
4671 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
4673 if (TREE_CODE (decl
) == VAR_DECL
4674 && current_function_decl
!= NULL_TREE
4675 && ! TREE_STATIC (decl
))
4677 error ("%Jsection attribute cannot be specified for "
4678 "local variables", decl
);
4679 *no_add_attrs
= true;
4682 /* The decl may have already been given a section attribute
4683 from a previous declaration. Ensure they match. */
4684 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
4685 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
4686 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
4688 error ("%Jsection of '%D' conflicts with previous declaration",
4690 *no_add_attrs
= true;
4693 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
4697 error ("%Jsection attribute not allowed for '%D'", *node
, *node
);
4698 *no_add_attrs
= true;
4703 error ("%Jsection attributes are not supported for this target", *node
);
4704 *no_add_attrs
= true;
4710 /* Handle a "aligned" attribute; arguments as in
4711 struct attribute_spec.handler. */
4714 handle_aligned_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
, tree args
,
4715 int flags
, bool *no_add_attrs
)
4717 tree decl
= NULL_TREE
;
4720 tree align_expr
= (args
? TREE_VALUE (args
)
4721 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
4727 type
= &TREE_TYPE (decl
);
4728 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
4730 else if (TYPE_P (*node
))
4731 type
= node
, is_type
= 1;
4733 /* Strip any NOPs of any kind. */
4734 while (TREE_CODE (align_expr
) == NOP_EXPR
4735 || TREE_CODE (align_expr
) == CONVERT_EXPR
4736 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
4737 align_expr
= TREE_OPERAND (align_expr
, 0);
4739 if (TREE_CODE (align_expr
) != INTEGER_CST
)
4741 error ("requested alignment is not a constant");
4742 *no_add_attrs
= true;
4744 else if ((i
= tree_log2 (align_expr
)) == -1)
4746 error ("requested alignment is not a power of 2");
4747 *no_add_attrs
= true;
4749 else if (i
> HOST_BITS_PER_INT
- 2)
4751 error ("requested alignment is too large");
4752 *no_add_attrs
= true;
4756 /* If we have a TYPE_DECL, then copy the type, so that we
4757 don't accidentally modify a builtin type. See pushdecl. */
4758 if (decl
&& TREE_TYPE (decl
) != error_mark_node
4759 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
4761 tree tt
= TREE_TYPE (decl
);
4762 *type
= build_type_copy (*type
);
4763 DECL_ORIGINAL_TYPE (decl
) = tt
;
4764 TYPE_NAME (*type
) = decl
;
4765 TREE_USED (*type
) = TREE_USED (decl
);
4766 TREE_TYPE (decl
) = *type
;
4768 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4769 *type
= build_type_copy (*type
);
4771 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
4772 TYPE_USER_ALIGN (*type
) = 1;
4774 else if (TREE_CODE (decl
) != VAR_DECL
4775 && TREE_CODE (decl
) != FIELD_DECL
)
4777 error ("%Jalignment may not be specified for '%D'", decl
, decl
);
4778 *no_add_attrs
= true;
4782 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
4783 DECL_USER_ALIGN (decl
) = 1;
4789 /* Handle a "weak" attribute; arguments as in
4790 struct attribute_spec.handler. */
4793 handle_weak_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
,
4794 tree args ATTRIBUTE_UNUSED
,
4795 int flags ATTRIBUTE_UNUSED
,
4796 bool *no_add_attrs ATTRIBUTE_UNUSED
)
4798 declare_weak (*node
);
4803 /* Handle an "alias" attribute; arguments as in
4804 struct attribute_spec.handler. */
4807 handle_alias_attribute (tree
*node
, tree name
, tree args
,
4808 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4812 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
4813 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
4815 error ("%J'%D' defined both normally and as an alias", decl
, decl
);
4816 *no_add_attrs
= true;
4819 /* Note that the very first time we process a nested declaration,
4820 decl_function_context will not be set. Indeed, *would* never
4821 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4822 we do below. After such frobbery, pushdecl would set the context.
4823 In any case, this is never what we want. */
4824 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
4828 id
= TREE_VALUE (args
);
4829 if (TREE_CODE (id
) != STRING_CST
)
4831 error ("alias arg not a string");
4832 *no_add_attrs
= true;
4835 id
= get_identifier (TREE_STRING_POINTER (id
));
4836 /* This counts as a use of the object pointed to. */
4839 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4840 DECL_INITIAL (decl
) = error_mark_node
;
4843 DECL_EXTERNAL (decl
) = 0;
4844 TREE_STATIC (decl
) = 1;
4849 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4850 *no_add_attrs
= true;
4856 /* Handle an "visibility" attribute; arguments as in
4857 struct attribute_spec.handler. */
4860 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
4861 int flags ATTRIBUTE_UNUSED
,
4865 tree id
= TREE_VALUE (args
);
4867 *no_add_attrs
= true;
4869 if (decl_function_context (decl
) != 0 || ! TREE_PUBLIC (decl
))
4871 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4875 if (TREE_CODE (id
) != STRING_CST
)
4877 error ("visibility arg not a string");
4881 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
4882 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4883 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
4884 DECL_VISIBILITY (decl
) = VISIBILITY_INTERNAL
;
4885 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
4886 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
4887 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
4888 DECL_VISIBILITY (decl
) = VISIBILITY_PROTECTED
;
4890 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4895 /* Handle an "tls_model" attribute; arguments as in
4896 struct attribute_spec.handler. */
4899 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
4900 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4904 if (! DECL_THREAD_LOCAL (decl
))
4906 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4907 *no_add_attrs
= true;
4913 id
= TREE_VALUE (args
);
4914 if (TREE_CODE (id
) != STRING_CST
)
4916 error ("tls_model arg not a string");
4917 *no_add_attrs
= true;
4920 if (strcmp (TREE_STRING_POINTER (id
), "local-exec")
4921 && strcmp (TREE_STRING_POINTER (id
), "initial-exec")
4922 && strcmp (TREE_STRING_POINTER (id
), "local-dynamic")
4923 && strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
4925 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4926 *no_add_attrs
= true;
4934 /* Handle a "no_instrument_function" attribute; arguments as in
4935 struct attribute_spec.handler. */
4938 handle_no_instrument_function_attribute (tree
*node
, tree name
,
4939 tree args ATTRIBUTE_UNUSED
,
4940 int flags ATTRIBUTE_UNUSED
,
4945 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4947 error ("%J'%E' attribute applies only to functions", decl
, name
);
4948 *no_add_attrs
= true;
4950 else if (DECL_INITIAL (decl
))
4952 error ("%Jcan't set '%E' attribute after definition", decl
, name
);
4953 *no_add_attrs
= true;
4956 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
4961 /* Handle a "malloc" attribute; arguments as in
4962 struct attribute_spec.handler. */
4965 handle_malloc_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4966 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4968 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4969 DECL_IS_MALLOC (*node
) = 1;
4970 /* ??? TODO: Support types. */
4973 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4974 *no_add_attrs
= true;
4980 /* Handle a "no_limit_stack" attribute; arguments as in
4981 struct attribute_spec.handler. */
4984 handle_no_limit_stack_attribute (tree
*node
, tree name
,
4985 tree args ATTRIBUTE_UNUSED
,
4986 int flags ATTRIBUTE_UNUSED
,
4991 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4993 error ("%J'%E' attribute applies only to functions", decl
, name
);
4994 *no_add_attrs
= true;
4996 else if (DECL_INITIAL (decl
))
4998 error ("%Jcan't set '%E' attribute after definition", decl
, name
);
4999 *no_add_attrs
= true;
5002 DECL_NO_LIMIT_STACK (decl
) = 1;
5007 /* Handle a "pure" attribute; arguments as in
5008 struct attribute_spec.handler. */
5011 handle_pure_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
5012 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5014 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5015 DECL_IS_PURE (*node
) = 1;
5016 /* ??? TODO: Support types. */
5019 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5020 *no_add_attrs
= true;
5026 /* Handle a "deprecated" attribute; arguments as in
5027 struct attribute_spec.handler. */
5030 handle_deprecated_attribute (tree
*node
, tree name
,
5031 tree args ATTRIBUTE_UNUSED
, int flags
,
5034 tree type
= NULL_TREE
;
5036 const char *what
= NULL
;
5041 type
= TREE_TYPE (decl
);
5043 if (TREE_CODE (decl
) == TYPE_DECL
5044 || TREE_CODE (decl
) == PARM_DECL
5045 || TREE_CODE (decl
) == VAR_DECL
5046 || TREE_CODE (decl
) == FUNCTION_DECL
5047 || TREE_CODE (decl
) == FIELD_DECL
)
5048 TREE_DEPRECATED (decl
) = 1;
5052 else if (TYPE_P (*node
))
5054 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5055 *node
= build_type_copy (*node
);
5056 TREE_DEPRECATED (*node
) = 1;
5064 *no_add_attrs
= true;
5065 if (type
&& TYPE_NAME (type
))
5067 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
5068 what
= IDENTIFIER_POINTER (TYPE_NAME (*node
));
5069 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
5070 && DECL_NAME (TYPE_NAME (type
)))
5071 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
5074 warning ("`%s' attribute ignored for `%s'",
5075 IDENTIFIER_POINTER (name
), what
);
5077 warning ("`%s' attribute ignored",
5078 IDENTIFIER_POINTER (name
));
5084 /* Handle a "vector_size" attribute; arguments as in
5085 struct attribute_spec.handler. */
5088 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
5089 int flags ATTRIBUTE_UNUSED
,
5092 unsigned HOST_WIDE_INT vecsize
, nunits
;
5093 enum machine_mode mode
, orig_mode
, new_mode
;
5094 tree type
= *node
, new_type
, size
;
5096 *no_add_attrs
= true;
5098 /* Stripping NON_LVALUE_EXPR allows declarations such as
5099 typedef short v4si __attribute__((vector_size (4 * sizeof(short)))). */
5100 size
= TREE_VALUE (args
);
5101 if (TREE_CODE (size
) == NON_LVALUE_EXPR
)
5102 size
= TREE_OPERAND (size
, 0);
5104 if (! host_integerp (size
, 1))
5106 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5110 /* Get the vector size (in bytes). */
5111 vecsize
= tree_low_cst (size
, 1);
5113 /* We need to provide for vector pointers, vector arrays, and
5114 functions returning vectors. For example:
5116 __attribute__((vector_size(16))) short *foo;
5118 In this case, the mode is SI, but the type being modified is
5119 HI, so we need to look further. */
5121 while (POINTER_TYPE_P (type
)
5122 || TREE_CODE (type
) == FUNCTION_TYPE
5123 || TREE_CODE (type
) == METHOD_TYPE
5124 || TREE_CODE (type
) == ARRAY_TYPE
)
5125 type
= TREE_TYPE (type
);
5127 /* Get the mode of the type being modified. */
5128 orig_mode
= TYPE_MODE (type
);
5130 if (TREE_CODE (type
) == RECORD_TYPE
5131 || (GET_MODE_CLASS (orig_mode
) != MODE_FLOAT
5132 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
5133 || ! host_integerp (TYPE_SIZE_UNIT (type
), 1))
5135 error ("invalid vector type for attribute `%s'",
5136 IDENTIFIER_POINTER (name
));
5140 /* Calculate how many units fit in the vector. */
5141 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5143 /* Find a suitably sized vector. */
5144 new_mode
= VOIDmode
;
5145 for (mode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode
) == MODE_INT
5147 : MODE_VECTOR_FLOAT
);
5149 mode
= GET_MODE_WIDER_MODE (mode
))
5150 if (vecsize
== GET_MODE_SIZE (mode
)
5151 && nunits
== (unsigned HOST_WIDE_INT
) GET_MODE_NUNITS (mode
))
5157 if (new_mode
== VOIDmode
)
5159 error ("no vector mode with the size and type specified could be found");
5163 new_type
= build_vector_type_for_mode (type
, new_mode
);
5165 /* Build back pointers if needed. */
5166 *node
= reconstruct_complex_type (*node
, new_type
);
5171 /* Handle the "nonnull" attribute. */
5173 handle_nonnull_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
,
5174 tree args
, int flags ATTRIBUTE_UNUSED
,
5178 unsigned HOST_WIDE_INT attr_arg_num
;
5180 /* If no arguments are specified, all pointer arguments should be
5181 non-null. Verify a full prototype is given so that the arguments
5182 will have the correct types when we actually check them later. */
5185 if (! TYPE_ARG_TYPES (type
))
5187 error ("nonnull attribute without arguments on a non-prototype");
5188 *no_add_attrs
= true;
5193 /* Argument list specified. Verify that each argument number references
5194 a pointer argument. */
5195 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
5198 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
5200 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5202 error ("nonnull argument has invalid operand number (arg %lu)",
5203 (unsigned long) attr_arg_num
);
5204 *no_add_attrs
= true;
5208 argument
= TYPE_ARG_TYPES (type
);
5211 for (ck_num
= 1; ; ck_num
++)
5213 if (! argument
|| ck_num
== arg_num
)
5215 argument
= TREE_CHAIN (argument
);
5219 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
5221 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5222 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5223 *no_add_attrs
= true;
5227 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
5229 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5230 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5231 *no_add_attrs
= true;
5240 /* Check the argument list of a function call for null in argument slots
5241 that are marked as requiring a non-null pointer argument. */
5244 check_function_nonnull (tree attrs
, tree params
)
5246 tree a
, args
, param
;
5249 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
5251 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
5253 args
= TREE_VALUE (a
);
5255 /* Walk the argument list. If we encounter an argument number we
5256 should check for non-null, do it. If the attribute has no args,
5257 then every pointer argument is checked (in which case the check
5258 for pointer type is done in check_nonnull_arg). */
5259 for (param
= params
, param_num
= 1; ;
5260 param_num
++, param
= TREE_CHAIN (param
))
5264 if (! args
|| nonnull_check_p (args
, param_num
))
5265 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
5273 /* Helper for check_function_nonnull; given a list of operands which
5274 must be non-null in ARGS, determine if operand PARAM_NUM should be
5278 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
5280 unsigned HOST_WIDE_INT arg_num
= 0;
5282 for (; args
; args
= TREE_CHAIN (args
))
5284 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5287 if (arg_num
== param_num
)
5293 /* Check that the function argument PARAM (which is operand number
5294 PARAM_NUM) is non-null. This is called by check_function_nonnull
5295 via check_function_arguments_recurse. */
5298 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED
, tree param
,
5299 unsigned HOST_WIDE_INT param_num
)
5301 /* Just skip checking the argument if it's not a pointer. This can
5302 happen if the "nonnull" attribute was given without an operand
5303 list (which means to check every pointer argument). */
5305 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
5308 if (integer_zerop (param
))
5309 warning ("null argument where non-null required (arg %lu)",
5310 (unsigned long) param_num
);
5313 /* Helper for nonnull attribute handling; fetch the operand number
5314 from the attribute argument list. */
5317 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
5319 /* Strip any conversions from the arg number and verify they
5321 while (TREE_CODE (arg_num_expr
) == NOP_EXPR
5322 || TREE_CODE (arg_num_expr
) == CONVERT_EXPR
5323 || TREE_CODE (arg_num_expr
) == NON_LVALUE_EXPR
)
5324 arg_num_expr
= TREE_OPERAND (arg_num_expr
, 0);
5326 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
5327 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
5330 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
5334 /* Handle a "nothrow" attribute; arguments as in
5335 struct attribute_spec.handler. */
5338 handle_nothrow_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
5339 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5341 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5342 TREE_NOTHROW (*node
) = 1;
5343 /* ??? TODO: Support types. */
5346 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5347 *no_add_attrs
= true;
5353 /* Handle a "cleanup" attribute; arguments as in
5354 struct attribute_spec.handler. */
5357 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
5358 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5361 tree cleanup_id
, cleanup_decl
;
5363 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5364 for global destructors in C++. This requires infrastructure that
5365 we don't have generically at the moment. It's also not a feature
5366 we'd be missing too much, since we do have attribute constructor. */
5367 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
5369 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5370 *no_add_attrs
= true;
5374 /* Verify that the argument is a function in scope. */
5375 /* ??? We could support pointers to functions here as well, if
5376 that was considered desirable. */
5377 cleanup_id
= TREE_VALUE (args
);
5378 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
5380 error ("cleanup arg not an identifier");
5381 *no_add_attrs
= true;
5384 cleanup_decl
= lookup_name (cleanup_id
);
5385 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
5387 error ("cleanup arg not a function");
5388 *no_add_attrs
= true;
5392 /* That the function has proper type is checked with the
5393 eventual call to build_function_call. */
5398 /* Handle a "warn_unused_result" attribute. No special handling. */
5401 handle_warn_unused_result_attribute (tree
*node
, tree name
,
5402 tree args ATTRIBUTE_UNUSED
,
5403 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5405 /* Ignore the attribute for functions not returning any value. */
5406 if (VOID_TYPE_P (TREE_TYPE (*node
)))
5408 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5409 *no_add_attrs
= true;
5415 /* Check for valid arguments being passed to a function. */
5417 check_function_arguments (tree attrs
, tree params
)
5419 /* Check for null being passed in a pointer argument that must be
5420 non-null. We also need to do this if format checking is enabled. */
5423 check_function_nonnull (attrs
, params
);
5425 /* Check for errors in format strings. */
5428 check_function_format (NULL
, attrs
, params
);
5431 /* Generic argument checking recursion routine. PARAM is the argument to
5432 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5433 once the argument is resolved. CTX is context for the callback. */
5435 check_function_arguments_recurse (void (*callback
)
5436 (void *, tree
, unsigned HOST_WIDE_INT
),
5437 void *ctx
, tree param
,
5438 unsigned HOST_WIDE_INT param_num
)
5440 if (TREE_CODE (param
) == NOP_EXPR
)
5442 /* Strip coercion. */
5443 check_function_arguments_recurse (callback
, ctx
,
5444 TREE_OPERAND (param
, 0), param_num
);
5448 if (TREE_CODE (param
) == CALL_EXPR
)
5450 tree type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (param
, 0)));
5452 bool found_format_arg
= false;
5454 /* See if this is a call to a known internationalization function
5455 that modifies a format arg. Such a function may have multiple
5456 format_arg attributes (for example, ngettext). */
5458 for (attrs
= TYPE_ATTRIBUTES (type
);
5460 attrs
= TREE_CHAIN (attrs
))
5461 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
5464 tree format_num_expr
;
5468 /* Extract the argument number, which was previously checked
5470 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
5471 while (TREE_CODE (format_num_expr
) == NOP_EXPR
5472 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
5473 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
5474 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
5476 if (TREE_CODE (format_num_expr
) != INTEGER_CST
5477 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
5480 format_num
= TREE_INT_CST_LOW (format_num_expr
);
5482 for (inner_args
= TREE_OPERAND (param
, 1), i
= 1;
5484 inner_args
= TREE_CHAIN (inner_args
), i
++)
5485 if (i
== format_num
)
5487 check_function_arguments_recurse (callback
, ctx
,
5488 TREE_VALUE (inner_args
),
5490 found_format_arg
= true;
5495 /* If we found a format_arg attribute and did a recursive check,
5496 we are done with checking this argument. Otherwise, we continue
5497 and this will be considered a non-literal. */
5498 if (found_format_arg
)
5502 if (TREE_CODE (param
) == COND_EXPR
)
5504 /* Check both halves of the conditional expression. */
5505 check_function_arguments_recurse (callback
, ctx
,
5506 TREE_OPERAND (param
, 1), param_num
);
5507 check_function_arguments_recurse (callback
, ctx
,
5508 TREE_OPERAND (param
, 2), param_num
);
5512 (*callback
) (ctx
, param
, param_num
);
5515 /* C implementation of lang_hooks.tree_inlining.walk_subtrees. Tracks the
5516 locus from EXPR_LOCUS and handles DECL_STMT specially. */
5519 c_walk_subtrees (tree
*tp
, int *walk_subtrees_p ATTRIBUTE_UNUSED
,
5520 walk_tree_fn func
, void *data
, void *htab
)
5522 enum tree_code code
= TREE_CODE (*tp
);
5523 location_t save_locus
;
5526 #define WALK_SUBTREE(NODE) \
5529 result = walk_tree (&(NODE), func, data, htab); \
5530 if (result) goto out; \
5534 if (code
!= DECL_STMT
)
5537 /* Set input_location here so we get the right instantiation context
5538 if we call instantiate_decl from inlinable_function_p. */
5539 save_locus
= input_location
;
5540 if (EXPR_LOCUS (*tp
))
5541 input_location
= *EXPR_LOCUS (*tp
);
5543 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
5544 into declarations that are just mentioned, rather than
5545 declared; they don't really belong to this part of the tree.
5546 And, we can see cycles: the initializer for a declaration can
5547 refer to the declaration itself. */
5548 WALK_SUBTREE (DECL_INITIAL (DECL_STMT_DECL (*tp
)));
5549 WALK_SUBTREE (DECL_SIZE (DECL_STMT_DECL (*tp
)));
5550 WALK_SUBTREE (DECL_SIZE_UNIT (DECL_STMT_DECL (*tp
)));
5551 WALK_SUBTREE (TREE_CHAIN (*tp
));
5552 *walk_subtrees_p
= 0;
5554 /* We didn't find what we were looking for. */
5556 input_location
= save_locus
;
5562 /* Function to help qsort sort FIELD_DECLs by name order. */
5565 field_decl_cmp (const void *x_p
, const void *y_p
)
5567 const tree
*const x
= x_p
;
5568 const tree
*const y
= y_p
;
5569 if (DECL_NAME (*x
) == DECL_NAME (*y
))
5570 /* A nontype is "greater" than a type. */
5571 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
5572 if (DECL_NAME (*x
) == NULL_TREE
)
5574 if (DECL_NAME (*y
) == NULL_TREE
)
5576 if (DECL_NAME (*x
) < DECL_NAME (*y
))
5582 gt_pointer_operator new_value
;
5586 /* This routine compares two fields like field_decl_cmp but using the
5587 pointer operator in resort_data. */
5590 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
5592 const tree
*const x
= x_p
;
5593 const tree
*const y
= y_p
;
5595 if (DECL_NAME (*x
) == DECL_NAME (*y
))
5596 /* A nontype is "greater" than a type. */
5597 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
5598 if (DECL_NAME (*x
) == NULL_TREE
)
5600 if (DECL_NAME (*y
) == NULL_TREE
)
5603 tree d1
= DECL_NAME (*x
);
5604 tree d2
= DECL_NAME (*y
);
5605 resort_data
.new_value (&d1
, resort_data
.cookie
);
5606 resort_data
.new_value (&d2
, resort_data
.cookie
);
5613 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5616 resort_sorted_fields (void *obj
,
5617 void *orig_obj ATTRIBUTE_UNUSED
,
5618 gt_pointer_operator new_value
,
5621 struct sorted_fields_type
*sf
= obj
;
5622 resort_data
.new_value
= new_value
;
5623 resort_data
.cookie
= cookie
;
5624 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
5625 resort_field_decl_cmp
);
5628 /* Issue the error given by MSGID, indicating that it occurred before
5629 TOKEN, which had the associated VALUE. */
5632 c_parse_error (const char *msgid
, enum cpp_ttype token
, tree value
)
5634 const char *string
= _(msgid
);
5636 if (token
== CPP_EOF
)
5637 error ("%s at end of input", string
);
5638 else if (token
== CPP_CHAR
|| token
== CPP_WCHAR
)
5640 unsigned int val
= TREE_INT_CST_LOW (value
);
5641 const char *const ell
= (token
== CPP_CHAR
) ? "" : "L";
5642 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
5643 error ("%s before %s'%c'", string
, ell
, val
);
5645 error ("%s before %s'\\x%x'", string
, ell
, val
);
5647 else if (token
== CPP_STRING
5648 || token
== CPP_WSTRING
)
5649 error ("%s before string constant", string
);
5650 else if (token
== CPP_NUMBER
)
5651 error ("%s before numeric constant", string
);
5652 else if (token
== CPP_NAME
)
5653 error ("%s before \"%s\"", string
, IDENTIFIER_POINTER (value
));
5654 else if (token
< N_TTYPES
)
5655 error ("%s before '%s' token", string
, cpp_type2name (token
));
5657 error ("%s", string
);
5660 /* Walk a gimplified function and warn for functions whose return value is
5661 ignored and attribute((warn_unused_result)) is set. This is done before
5662 inlining, so we don't have to worry about that. */
5665 c_warn_unused_result (tree
*top_p
)
5668 tree_stmt_iterator i
;
5671 switch (TREE_CODE (t
))
5673 case STATEMENT_LIST
:
5674 for (i
= tsi_start (*top_p
); !tsi_end_p (i
); tsi_next (&i
))
5675 c_warn_unused_result (tsi_stmt_ptr (i
));
5679 c_warn_unused_result (&COND_EXPR_THEN (t
));
5680 c_warn_unused_result (&COND_EXPR_ELSE (t
));
5683 c_warn_unused_result (&BIND_EXPR_BODY (t
));
5685 case TRY_FINALLY_EXPR
:
5686 case TRY_CATCH_EXPR
:
5687 c_warn_unused_result (&TREE_OPERAND (t
, 0));
5688 c_warn_unused_result (&TREE_OPERAND (t
, 1));
5691 c_warn_unused_result (&CATCH_BODY (t
));
5693 case EH_FILTER_EXPR
:
5694 c_warn_unused_result (&EH_FILTER_FAILURE (t
));
5698 /* This is a naked call, as opposed to a CALL_EXPR nested inside
5699 a MODIFY_EXPR. All calls whose value is ignored should be
5700 represented like this. Look for the attribute. */
5701 fdecl
= get_callee_fndecl (t
);
5703 ftype
= TREE_TYPE (fdecl
);
5706 ftype
= TREE_TYPE (TREE_OPERAND (t
, 0));
5707 /* Look past pointer-to-function to the function type itself. */
5708 ftype
= TREE_TYPE (ftype
);
5711 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
5714 warning ("%Hignoring return value of `%D', "
5715 "declared with attribute warn_unused_result",
5716 EXPR_LOCUS (t
), fdecl
);
5718 warning ("%Hignoring return value of function "
5719 "declared with attribute warn_unused_result",
5725 /* Not a container, not a call, or a call whose value is used. */
5730 #include "gt-c-common.h"