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
);
1251 /* Create a new struct tlist and fill in its fields. */
1252 static struct tlist
*
1253 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1256 l
= obstack_alloc (&tlist_obstack
, sizeof *l
);
1263 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1264 is nonnull, we ignore any node we find which has a writer equal to it. */
1267 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1271 struct tlist
*next
= add
->next
;
1274 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
1275 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1280 /* Merge the nodes of ADD into TO. This merging process is done so that for
1281 each variable that already exists in TO, no new node is added; however if
1282 there is a write access recorded in ADD, and an occurrence on TO is only
1283 a read access, then the occurrence in TO will be modified to record the
1287 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1289 struct tlist
**end
= to
;
1292 end
= &(*end
)->next
;
1298 struct tlist
*next
= add
->next
;
1300 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1301 if (tmp2
->expr
== add
->expr
)
1305 tmp2
->writer
= add
->writer
;
1309 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1310 end
= &(*end
)->next
;
1317 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1318 references in list LIST conflict with it, excluding reads if ONLY writers
1322 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1327 /* Avoid duplicate warnings. */
1328 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1329 if (tmp
->expr
== written
)
1334 if (list
->expr
== written
1335 && list
->writer
!= writer
1336 && (! only_writes
|| list
->writer
))
1338 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1339 warning ("operation on `%s' may be undefined",
1340 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
1346 /* Given a list LIST of references to variables, find whether any of these
1347 can cause conflicts due to missing sequence points. */
1350 warn_for_collisions (struct tlist
*list
)
1354 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1357 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1361 /* Return nonzero if X is a tree that can be verified by the sequence point
1364 warning_candidate_p (tree x
)
1366 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1369 /* Walk the tree X, and record accesses to variables. If X is written by the
1370 parent tree, WRITER is the parent.
1371 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1372 expression or its only operand forces a sequence point, then everything up
1373 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1375 Once we return, we will have emitted warnings if any subexpression before
1376 such a sequence point could be undefined. On a higher level, however, the
1377 sequence point may not be relevant, and we'll merge the two lists.
1379 Example: (b++, a) + b;
1380 The call that processes the COMPOUND_EXPR will store the increment of B
1381 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1382 processes the PLUS_EXPR will need to merge the two lists so that
1383 eventually, all accesses end up on the same list (and we'll warn about the
1384 unordered subexpressions b++ and b.
1386 A note on merging. If we modify the former example so that our expression
1389 care must be taken not simply to add all three expressions into the final
1390 PNO_SP list. The function merge_tlist takes care of that by merging the
1391 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1392 way, so that no more than one access to B is recorded. */
1395 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
1398 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1399 enum tree_code code
;
1402 /* X may be NULL if it is the operand of an empty statement expression
1408 code
= TREE_CODE (x
);
1409 class = TREE_CODE_CLASS (code
);
1411 if (warning_candidate_p (x
))
1413 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1423 case TRUTH_ANDIF_EXPR
:
1424 case TRUTH_ORIF_EXPR
:
1425 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1426 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1427 warn_for_collisions (tmp_nosp
);
1428 merge_tlist (pbefore_sp
, tmp_before
, 0);
1429 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1430 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1431 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1435 tmp_before
= tmp_list2
= 0;
1436 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1437 warn_for_collisions (tmp_list2
);
1438 merge_tlist (pbefore_sp
, tmp_before
, 0);
1439 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1441 tmp_list3
= tmp_nosp
= 0;
1442 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1443 warn_for_collisions (tmp_nosp
);
1444 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1446 tmp_list3
= tmp_list2
= 0;
1447 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1448 warn_for_collisions (tmp_list2
);
1449 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1450 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1451 two first, to avoid warning for (a ? b++ : b++). */
1452 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1453 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1456 case PREDECREMENT_EXPR
:
1457 case PREINCREMENT_EXPR
:
1458 case POSTDECREMENT_EXPR
:
1459 case POSTINCREMENT_EXPR
:
1460 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1464 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1465 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1466 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1467 /* Expressions inside the LHS are not ordered wrt. the sequence points
1468 in the RHS. Example:
1470 Despite the fact that the modification of "a" is in the before_sp
1471 list (tmp_before), it conflicts with the use of "a" in the LHS.
1472 We can handle this by adding the contents of tmp_list3
1473 to those of tmp_before, and redoing the collision warnings for that
1475 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1476 warn_for_collisions (tmp_before
);
1477 /* Exclude the LHS itself here; we first have to merge it into the
1478 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1479 didn't exclude the LHS, we'd get it twice, once as a read and once
1481 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1482 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1484 merge_tlist (pbefore_sp
, tmp_before
, 0);
1485 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1486 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1487 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1491 /* We need to warn about conflicts among arguments and conflicts between
1492 args and the function address. Side effects of the function address,
1493 however, are not ordered by the sequence point of the call. */
1494 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1495 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1496 if (TREE_OPERAND (x
, 1))
1497 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1498 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1499 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1500 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1501 warn_for_collisions (tmp_before
);
1502 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1506 /* Scan all the list, e.g. indices of multi dimensional array. */
1509 tmp_before
= tmp_nosp
= 0;
1510 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1511 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1512 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1519 struct tlist_cache
*t
;
1520 for (t
= save_expr_cache
; t
; t
= t
->next
)
1526 t
= obstack_alloc (&tlist_obstack
, sizeof *t
);
1527 t
->next
= save_expr_cache
;
1529 save_expr_cache
= t
;
1531 tmp_before
= tmp_nosp
= 0;
1532 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1533 warn_for_collisions (tmp_nosp
);
1538 struct tlist
*t
= tmp_nosp
;
1540 merge_tlist (&tmp_list3
, t
, 0);
1542 t
->cache_before_sp
= tmp_before
;
1543 t
->cache_after_sp
= tmp_list3
;
1545 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1546 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1555 if (first_rtl_op (code
) == 0)
1557 x
= TREE_OPERAND (x
, 0);
1572 int max
= first_rtl_op (TREE_CODE (x
));
1573 for (lp
= 0; lp
< max
; lp
++)
1575 tmp_before
= tmp_nosp
= 0;
1576 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1577 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1578 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1585 /* Try to warn for undefined behavior in EXPR due to missing sequence
1589 verify_sequence_points (tree expr
)
1591 struct tlist
*before_sp
= 0, *after_sp
= 0;
1594 save_expr_cache
= 0;
1595 if (tlist_firstobj
== 0)
1597 gcc_obstack_init (&tlist_obstack
);
1598 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1601 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1602 warn_for_collisions (after_sp
);
1603 obstack_free (&tlist_obstack
, tlist_firstobj
);
1606 /* Validate the expression after `case' and apply default promotions. */
1609 check_case_value (tree value
)
1611 if (value
== NULL_TREE
)
1614 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1615 STRIP_TYPE_NOPS (value
);
1616 /* In C++, the following is allowed:
1619 switch (...) { case i: ... }
1621 So, we try to reduce the VALUE to a constant that way. */
1622 if (c_dialect_cxx ())
1624 value
= decl_constant_value (value
);
1625 STRIP_TYPE_NOPS (value
);
1626 value
= fold (value
);
1629 if (TREE_CODE (value
) != INTEGER_CST
1630 && value
!= error_mark_node
)
1632 error ("case label does not reduce to an integer constant");
1633 value
= error_mark_node
;
1636 /* Promote char or short to int. */
1637 value
= default_conversion (value
);
1639 constant_expression_warning (value
);
1644 /* Return an integer type with BITS bits of precision,
1645 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1648 c_common_type_for_size (unsigned int bits
, int unsignedp
)
1650 if (bits
== TYPE_PRECISION (integer_type_node
))
1651 return unsignedp
? unsigned_type_node
: integer_type_node
;
1653 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1654 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1656 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1657 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1659 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1660 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1662 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1663 return (unsignedp
? long_long_unsigned_type_node
1664 : long_long_integer_type_node
);
1666 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1667 return (unsignedp
? widest_unsigned_literal_type_node
1668 : widest_integer_literal_type_node
);
1670 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1671 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1673 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1674 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1676 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1677 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1679 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1680 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1685 /* Used for communication between c_common_type_for_mode and
1686 c_register_builtin_type. */
1687 static GTY(()) tree registered_builtin_types
;
1689 /* Return a data type that has machine mode MODE.
1690 If the mode is an integer,
1691 then UNSIGNEDP selects between signed and unsigned types. */
1694 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
1698 if (mode
== TYPE_MODE (integer_type_node
))
1699 return unsignedp
? unsigned_type_node
: integer_type_node
;
1701 if (mode
== TYPE_MODE (signed_char_type_node
))
1702 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1704 if (mode
== TYPE_MODE (short_integer_type_node
))
1705 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1707 if (mode
== TYPE_MODE (long_integer_type_node
))
1708 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1710 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1711 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1713 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1714 return unsignedp
? widest_unsigned_literal_type_node
1715 : widest_integer_literal_type_node
;
1718 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1721 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1724 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1727 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1729 #if HOST_BITS_PER_WIDE_INT >= 64
1730 if (mode
== TYPE_MODE (intTI_type_node
))
1731 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1734 if (mode
== TYPE_MODE (float_type_node
))
1735 return float_type_node
;
1737 if (mode
== TYPE_MODE (double_type_node
))
1738 return double_type_node
;
1740 if (mode
== TYPE_MODE (long_double_type_node
))
1741 return long_double_type_node
;
1743 if (mode
== TYPE_MODE (void_type_node
))
1744 return void_type_node
;
1746 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1747 return unsignedp
? make_unsigned_type (mode
) : make_signed_type (mode
);
1749 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1750 return unsignedp
? make_unsigned_type (mode
) : make_signed_type (mode
);
1752 if (VECTOR_MODE_P (mode
))
1754 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
1755 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
1756 if (inner_type
!= NULL_TREE
)
1757 return build_vector_type_for_mode (inner_type
, mode
);
1760 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1761 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
1762 return TREE_VALUE (t
);
1767 /* Return an unsigned type the same as TYPE in other respects. */
1769 c_common_unsigned_type (tree type
)
1771 tree type1
= TYPE_MAIN_VARIANT (type
);
1772 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1773 return unsigned_char_type_node
;
1774 if (type1
== integer_type_node
)
1775 return unsigned_type_node
;
1776 if (type1
== short_integer_type_node
)
1777 return short_unsigned_type_node
;
1778 if (type1
== long_integer_type_node
)
1779 return long_unsigned_type_node
;
1780 if (type1
== long_long_integer_type_node
)
1781 return long_long_unsigned_type_node
;
1782 if (type1
== widest_integer_literal_type_node
)
1783 return widest_unsigned_literal_type_node
;
1784 #if HOST_BITS_PER_WIDE_INT >= 64
1785 if (type1
== intTI_type_node
)
1786 return unsigned_intTI_type_node
;
1788 if (type1
== intDI_type_node
)
1789 return unsigned_intDI_type_node
;
1790 if (type1
== intSI_type_node
)
1791 return unsigned_intSI_type_node
;
1792 if (type1
== intHI_type_node
)
1793 return unsigned_intHI_type_node
;
1794 if (type1
== intQI_type_node
)
1795 return unsigned_intQI_type_node
;
1797 return c_common_signed_or_unsigned_type (1, type
);
1800 /* Return a signed type the same as TYPE in other respects. */
1803 c_common_signed_type (tree type
)
1805 tree type1
= TYPE_MAIN_VARIANT (type
);
1806 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1807 return signed_char_type_node
;
1808 if (type1
== unsigned_type_node
)
1809 return integer_type_node
;
1810 if (type1
== short_unsigned_type_node
)
1811 return short_integer_type_node
;
1812 if (type1
== long_unsigned_type_node
)
1813 return long_integer_type_node
;
1814 if (type1
== long_long_unsigned_type_node
)
1815 return long_long_integer_type_node
;
1816 if (type1
== widest_unsigned_literal_type_node
)
1817 return widest_integer_literal_type_node
;
1818 #if HOST_BITS_PER_WIDE_INT >= 64
1819 if (type1
== unsigned_intTI_type_node
)
1820 return intTI_type_node
;
1822 if (type1
== unsigned_intDI_type_node
)
1823 return intDI_type_node
;
1824 if (type1
== unsigned_intSI_type_node
)
1825 return intSI_type_node
;
1826 if (type1
== unsigned_intHI_type_node
)
1827 return intHI_type_node
;
1828 if (type1
== unsigned_intQI_type_node
)
1829 return intQI_type_node
;
1831 return c_common_signed_or_unsigned_type (0, type
);
1834 /* Return a type the same as TYPE except unsigned or
1835 signed according to UNSIGNEDP. */
1838 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
1840 if (! INTEGRAL_TYPE_P (type
)
1841 || TYPE_UNSIGNED (type
) == unsignedp
)
1844 /* Must check the mode of the types, not the precision. Enumeral types
1845 in C++ have precision set to match their range, but may use a wider
1846 mode to match an ABI. If we change modes, we may wind up with bad
1849 if (TYPE_MODE (type
) == TYPE_MODE (signed_char_type_node
))
1850 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1851 if (TYPE_MODE (type
) == TYPE_MODE (integer_type_node
))
1852 return unsignedp
? unsigned_type_node
: integer_type_node
;
1853 if (TYPE_MODE (type
) == TYPE_MODE (short_integer_type_node
))
1854 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1855 if (TYPE_MODE (type
) == TYPE_MODE (long_integer_type_node
))
1856 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1857 if (TYPE_MODE (type
) == TYPE_MODE (long_long_integer_type_node
))
1858 return (unsignedp
? long_long_unsigned_type_node
1859 : long_long_integer_type_node
);
1860 if (TYPE_MODE (type
) == TYPE_MODE (widest_integer_literal_type_node
))
1861 return (unsignedp
? widest_unsigned_literal_type_node
1862 : widest_integer_literal_type_node
);
1864 #if HOST_BITS_PER_WIDE_INT >= 64
1865 if (TYPE_MODE (type
) == TYPE_MODE (intTI_type_node
))
1866 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1868 if (TYPE_MODE (type
) == TYPE_MODE (intDI_type_node
))
1869 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1870 if (TYPE_MODE (type
) == TYPE_MODE (intSI_type_node
))
1871 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1872 if (TYPE_MODE (type
) == TYPE_MODE (intHI_type_node
))
1873 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1874 if (TYPE_MODE (type
) == TYPE_MODE (intQI_type_node
))
1875 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1880 /* The C version of the register_builtin_type langhook. */
1883 c_register_builtin_type (tree type
, const char* name
)
1887 decl
= build_decl (TYPE_DECL
, get_identifier (name
), type
);
1888 DECL_ARTIFICIAL (decl
) = 1;
1889 if (!TYPE_NAME (type
))
1890 TYPE_NAME (type
) = decl
;
1893 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
1897 /* Return the minimum number of bits needed to represent VALUE in a
1898 signed or unsigned type, UNSIGNEDP says which. */
1901 min_precision (tree value
, int unsignedp
)
1905 /* If the value is negative, compute its negative minus 1. The latter
1906 adjustment is because the absolute value of the largest negative value
1907 is one larger than the largest positive value. This is equivalent to
1908 a bit-wise negation, so use that operation instead. */
1910 if (tree_int_cst_sgn (value
) < 0)
1911 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
1913 /* Return the number of bits needed, taking into account the fact
1914 that we need one more bit for a signed than unsigned type. */
1916 if (integer_zerop (value
))
1919 log
= tree_floor_log2 (value
);
1921 return log
+ 1 + ! unsignedp
;
1924 /* Print an error message for invalid operands to arith operation
1925 CODE. NOP_EXPR is used as a special case (see
1926 c_common_truthvalue_conversion). */
1929 binary_op_error (enum tree_code code
)
1936 error ("invalid truth-value expression");
1940 opname
= "+"; break;
1942 opname
= "-"; break;
1944 opname
= "*"; break;
1946 opname
= "max"; break;
1948 opname
= "min"; break;
1950 opname
= "=="; break;
1952 opname
= "!="; break;
1954 opname
= "<="; break;
1956 opname
= ">="; break;
1958 opname
= "<"; break;
1960 opname
= ">"; break;
1962 opname
= "<<"; break;
1964 opname
= ">>"; break;
1965 case TRUNC_MOD_EXPR
:
1966 case FLOOR_MOD_EXPR
:
1967 opname
= "%"; break;
1968 case TRUNC_DIV_EXPR
:
1969 case FLOOR_DIV_EXPR
:
1970 opname
= "/"; break;
1972 opname
= "&"; break;
1974 opname
= "|"; break;
1975 case TRUTH_ANDIF_EXPR
:
1976 opname
= "&&"; break;
1977 case TRUTH_ORIF_EXPR
:
1978 opname
= "||"; break;
1980 opname
= "^"; break;
1983 opname
= "rotate"; break;
1985 opname
= "unknown"; break;
1987 error ("invalid operands to binary %s", opname
);
1990 /* Subroutine of build_binary_op, used for comparison operations.
1991 See if the operands have both been converted from subword integer types
1992 and, if so, perhaps change them both back to their original type.
1993 This function is also responsible for converting the two operands
1994 to the proper common type for comparison.
1996 The arguments of this function are all pointers to local variables
1997 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1998 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2000 If this function returns nonzero, it means that the comparison has
2001 a constant value. What this function returns is an expression for
2005 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
2006 enum tree_code
*rescode_ptr
)
2009 tree op0
= *op0_ptr
;
2010 tree op1
= *op1_ptr
;
2011 int unsignedp0
, unsignedp1
;
2013 tree primop0
, primop1
;
2014 enum tree_code code
= *rescode_ptr
;
2016 /* Throw away any conversions to wider types
2017 already present in the operands. */
2019 primop0
= get_narrower (op0
, &unsignedp0
);
2020 primop1
= get_narrower (op1
, &unsignedp1
);
2022 /* Handle the case that OP0 does not *contain* a conversion
2023 but it *requires* conversion to FINAL_TYPE. */
2025 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2026 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2027 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2028 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2030 /* If one of the operands must be floated, we cannot optimize. */
2031 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2032 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2034 /* If first arg is constant, swap the args (changing operation
2035 so value is preserved), for canonicalization. Don't do this if
2036 the second arg is 0. */
2038 if (TREE_CONSTANT (primop0
)
2039 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
2042 int temi
= unsignedp0
;
2050 unsignedp0
= unsignedp1
;
2073 *rescode_ptr
= code
;
2076 /* If comparing an integer against a constant more bits wide,
2077 maybe we can deduce a value of 1 or 0 independent of the data.
2078 Or else truncate the constant now
2079 rather than extend the variable at run time.
2081 This is only interesting if the constant is the wider arg.
2082 Also, it is not safe if the constant is unsigned and the
2083 variable arg is signed, since in this case the variable
2084 would be sign-extended and then regarded as unsigned.
2085 Our technique fails in this case because the lowest/highest
2086 possible unsigned results don't follow naturally from the
2087 lowest/highest possible values of the variable operand.
2088 For just EQ_EXPR and NE_EXPR there is another technique that
2089 could be used: see if the constant can be faithfully represented
2090 in the other operand's type, by truncating it and reextending it
2091 and see if that preserves the constant's value. */
2093 if (!real1
&& !real2
2094 && TREE_CODE (primop1
) == INTEGER_CST
2095 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2097 int min_gt
, max_gt
, min_lt
, max_lt
;
2098 tree maxval
, minval
;
2099 /* 1 if comparison is nominally unsigned. */
2100 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
2103 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2104 TREE_TYPE (primop0
));
2106 /* In C, if TYPE is an enumeration, then we need to get its
2107 min/max values from its underlying integral type, not the
2108 enumerated type itself. In C++, TYPE_MAX_VALUE and
2109 TYPE_MIN_VALUE have already been set correctly on the
2110 enumeration type. */
2111 if (!c_dialect_cxx() && TREE_CODE (type
) == ENUMERAL_TYPE
)
2112 type
= c_common_type_for_size (TYPE_PRECISION (type
), unsignedp0
);
2114 maxval
= TYPE_MAX_VALUE (type
);
2115 minval
= TYPE_MIN_VALUE (type
);
2117 if (unsignedp
&& !unsignedp0
)
2118 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2120 if (TREE_TYPE (primop1
) != *restype_ptr
)
2121 primop1
= convert (*restype_ptr
, primop1
);
2122 if (type
!= *restype_ptr
)
2124 minval
= convert (*restype_ptr
, minval
);
2125 maxval
= convert (*restype_ptr
, maxval
);
2128 if (unsignedp
&& unsignedp0
)
2130 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2131 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2132 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2133 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2137 min_gt
= INT_CST_LT (primop1
, minval
);
2138 max_gt
= INT_CST_LT (primop1
, maxval
);
2139 min_lt
= INT_CST_LT (minval
, primop1
);
2140 max_lt
= INT_CST_LT (maxval
, primop1
);
2144 /* This used to be a switch, but Genix compiler can't handle that. */
2145 if (code
== NE_EXPR
)
2147 if (max_lt
|| min_gt
)
2148 val
= truthvalue_true_node
;
2150 else if (code
== EQ_EXPR
)
2152 if (max_lt
|| min_gt
)
2153 val
= truthvalue_false_node
;
2155 else if (code
== LT_EXPR
)
2158 val
= truthvalue_true_node
;
2160 val
= truthvalue_false_node
;
2162 else if (code
== GT_EXPR
)
2165 val
= truthvalue_true_node
;
2167 val
= truthvalue_false_node
;
2169 else if (code
== LE_EXPR
)
2172 val
= truthvalue_true_node
;
2174 val
= truthvalue_false_node
;
2176 else if (code
== GE_EXPR
)
2179 val
= truthvalue_true_node
;
2181 val
= truthvalue_false_node
;
2184 /* If primop0 was sign-extended and unsigned comparison specd,
2185 we did a signed comparison above using the signed type bounds.
2186 But the comparison we output must be unsigned.
2188 Also, for inequalities, VAL is no good; but if the signed
2189 comparison had *any* fixed result, it follows that the
2190 unsigned comparison just tests the sign in reverse
2191 (positive values are LE, negative ones GE).
2192 So we can generate an unsigned comparison
2193 against an extreme value of the signed type. */
2195 if (unsignedp
&& !unsignedp0
)
2202 primop1
= TYPE_MIN_VALUE (type
);
2208 primop1
= TYPE_MAX_VALUE (type
);
2215 type
= c_common_unsigned_type (type
);
2218 if (TREE_CODE (primop0
) != INTEGER_CST
)
2220 if (val
== truthvalue_false_node
)
2221 warning ("comparison is always false due to limited range of data type");
2222 if (val
== truthvalue_true_node
)
2223 warning ("comparison is always true due to limited range of data type");
2228 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2229 if (TREE_SIDE_EFFECTS (primop0
))
2230 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2234 /* Value is not predetermined, but do the comparison
2235 in the type of the operand that is not constant.
2236 TYPE is already properly set. */
2238 else if (real1
&& real2
2239 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2240 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2241 type
= TREE_TYPE (primop0
);
2243 /* If args' natural types are both narrower than nominal type
2244 and both extend in the same manner, compare them
2245 in the type of the wider arg.
2246 Otherwise must actually extend both to the nominal
2247 common type lest different ways of extending
2249 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2251 else if (unsignedp0
== unsignedp1
&& real1
== real2
2252 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2253 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2255 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2256 type
= c_common_signed_or_unsigned_type (unsignedp0
2257 || TYPE_UNSIGNED (*restype_ptr
),
2259 /* Make sure shorter operand is extended the right way
2260 to match the longer operand. */
2262 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2263 TREE_TYPE (primop0
)),
2266 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2267 TREE_TYPE (primop1
)),
2272 /* Here we must do the comparison on the nominal type
2273 using the args exactly as we received them. */
2274 type
= *restype_ptr
;
2278 if (!real1
&& !real2
&& integer_zerop (primop1
)
2279 && TYPE_UNSIGNED (*restype_ptr
))
2285 /* All unsigned values are >= 0, so we warn if extra warnings
2286 are requested. However, if OP0 is a constant that is
2287 >= 0, the signedness of the comparison isn't an issue,
2288 so suppress the warning. */
2289 if (extra_warnings
&& !in_system_header
2290 && ! (TREE_CODE (primop0
) == INTEGER_CST
2291 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2293 warning ("comparison of unsigned expression >= 0 is always true");
2294 value
= truthvalue_true_node
;
2298 if (extra_warnings
&& !in_system_header
2299 && ! (TREE_CODE (primop0
) == INTEGER_CST
2300 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2302 warning ("comparison of unsigned expression < 0 is always false");
2303 value
= truthvalue_false_node
;
2312 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2313 if (TREE_SIDE_EFFECTS (primop0
))
2314 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2321 *op0_ptr
= convert (type
, primop0
);
2322 *op1_ptr
= convert (type
, primop1
);
2324 *restype_ptr
= truthvalue_type_node
;
2329 /* Return a tree for the sum or difference (RESULTCODE says which)
2330 of pointer PTROP and integer INTOP. */
2333 pointer_int_sum (enum tree_code resultcode
, tree ptrop
, tree intop
)
2337 /* The result is a pointer of the same type that is being added. */
2339 tree result_type
= TREE_TYPE (ptrop
);
2341 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2343 if (pedantic
|| warn_pointer_arith
)
2344 pedwarn ("pointer of type `void *' used in arithmetic");
2345 size_exp
= integer_one_node
;
2347 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2349 if (pedantic
|| warn_pointer_arith
)
2350 pedwarn ("pointer to a function used in arithmetic");
2351 size_exp
= integer_one_node
;
2353 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2355 if (pedantic
|| warn_pointer_arith
)
2356 pedwarn ("pointer to member function used in arithmetic");
2357 size_exp
= integer_one_node
;
2360 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2362 /* If what we are about to multiply by the size of the elements
2363 contains a constant term, apply distributive law
2364 and multiply that constant term separately.
2365 This helps produce common subexpressions. */
2367 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2368 && ! TREE_CONSTANT (intop
)
2369 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2370 && TREE_CONSTANT (size_exp
)
2371 /* If the constant comes from pointer subtraction,
2372 skip this optimization--it would cause an error. */
2373 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2374 /* If the constant is unsigned, and smaller than the pointer size,
2375 then we must skip this optimization. This is because it could cause
2376 an overflow error if the constant is negative but INTOP is not. */
2377 && (! TYPE_UNSIGNED (TREE_TYPE (intop
))
2378 || (TYPE_PRECISION (TREE_TYPE (intop
))
2379 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2381 enum tree_code subcode
= resultcode
;
2382 tree int_type
= TREE_TYPE (intop
);
2383 if (TREE_CODE (intop
) == MINUS_EXPR
)
2384 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2385 /* Convert both subexpression types to the type of intop,
2386 because weird cases involving pointer arithmetic
2387 can result in a sum or difference with different type args. */
2388 ptrop
= build_binary_op (subcode
, ptrop
,
2389 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2390 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2393 /* Convert the integer argument to a type the same size as sizetype
2394 so the multiply won't overflow spuriously. */
2396 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2397 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
2398 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2399 TYPE_UNSIGNED (sizetype
)), intop
);
2401 /* Replace the integer argument with a suitable product by the object size.
2402 Do this multiplication as signed, then convert to the appropriate
2403 pointer type (actually unsigned integral). */
2405 intop
= convert (result_type
,
2406 build_binary_op (MULT_EXPR
, intop
,
2407 convert (TREE_TYPE (intop
), size_exp
), 1));
2409 /* Create the sum or difference. */
2410 return fold (build (resultcode
, result_type
, ptrop
, intop
));
2413 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2414 or validate its data type for an `if' or `while' statement or ?..: exp.
2416 This preparation consists of taking the ordinary
2417 representation of an expression expr and producing a valid tree
2418 boolean expression describing whether expr is nonzero. We could
2419 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2420 but we optimize comparisons, &&, ||, and !.
2422 The resulting type should always be `truthvalue_type_node'. */
2425 c_common_truthvalue_conversion (tree expr
)
2427 if (TREE_CODE (expr
) == ERROR_MARK
)
2430 if (TREE_CODE (expr
) == FUNCTION_DECL
)
2431 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
2433 switch (TREE_CODE (expr
))
2435 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
2436 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2437 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
2438 case ORDERED_EXPR
: case UNORDERED_EXPR
:
2439 case TRUTH_ANDIF_EXPR
:
2440 case TRUTH_ORIF_EXPR
:
2441 case TRUTH_AND_EXPR
:
2443 case TRUTH_XOR_EXPR
:
2444 case TRUTH_NOT_EXPR
:
2445 TREE_TYPE (expr
) = truthvalue_type_node
;
2452 return integer_zerop (expr
) ? truthvalue_false_node
: truthvalue_true_node
;
2455 return real_zerop (expr
) ? truthvalue_false_node
: truthvalue_true_node
;
2459 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == FUNCTION_DECL
2460 && ! DECL_WEAK (TREE_OPERAND (expr
, 0)))
2462 /* Common Ada/Pascal programmer's mistake. We always warn
2463 about this since it is so bad. */
2464 warning ("the address of `%D', will always evaluate as `true'",
2465 TREE_OPERAND (expr
, 0));
2466 return truthvalue_true_node
;
2469 /* If we are taking the address of an external decl, it might be
2470 zero if it is weak, so we cannot optimize. */
2471 if (DECL_P (TREE_OPERAND (expr
, 0))
2472 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2475 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2476 return build (COMPOUND_EXPR
, truthvalue_type_node
,
2477 TREE_OPERAND (expr
, 0), truthvalue_true_node
);
2479 return truthvalue_true_node
;
2483 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2484 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2485 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2486 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2492 /* These don't change whether an object is nonzero or zero. */
2493 return lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0));
2497 /* These don't change whether an object is zero or nonzero, but
2498 we can't ignore them if their second arg has side-effects. */
2499 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2500 return build (COMPOUND_EXPR
, truthvalue_type_node
, TREE_OPERAND (expr
, 1),
2501 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2503 return lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0));
2506 /* Distribute the conversion into the arms of a COND_EXPR. */
2507 return fold (build (COND_EXPR
, truthvalue_type_node
, TREE_OPERAND (expr
, 0),
2508 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2509 lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2512 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2513 since that affects how `default_conversion' will behave. */
2514 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2515 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2517 /* Fall through.... */
2519 /* If this is widening the argument, we can ignore it. */
2520 if (TYPE_PRECISION (TREE_TYPE (expr
))
2521 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2522 return lang_hooks
.truthvalue_conversion (TREE_OPERAND (expr
, 0));
2526 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2527 aren't guaranteed to the be same for modes that can represent
2528 infinity, since if x and y are both +infinity, or both
2529 -infinity, then x - y is not a number.
2531 Note that this transformation is safe when x or y is NaN.
2532 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2534 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))))
2536 /* Fall through.... */
2538 /* This and MINUS_EXPR can be changed into a comparison of the
2540 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2541 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2542 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2543 TREE_OPERAND (expr
, 1), 1);
2544 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2545 fold (build1 (NOP_EXPR
,
2546 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2547 TREE_OPERAND (expr
, 1))), 1);
2550 if (integer_onep (TREE_OPERAND (expr
, 1))
2551 && TREE_TYPE (expr
) != truthvalue_type_node
)
2552 /* Using convert here would cause infinite recursion. */
2553 return build1 (NOP_EXPR
, truthvalue_type_node
, expr
);
2557 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2558 warning ("suggest parentheses around assignment used as truth value");
2565 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2567 tree t
= save_expr (expr
);
2568 return (build_binary_op
2569 ((TREE_SIDE_EFFECTS (expr
)
2570 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2571 lang_hooks
.truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2572 lang_hooks
.truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2576 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2579 static tree
builtin_function_2 (const char *, const char *, tree
, tree
,
2580 int, enum built_in_class
, int, int,
2583 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2584 down to the element type of an array. */
2587 c_build_qualified_type (tree type
, int type_quals
)
2589 if (type
== error_mark_node
)
2592 if (TREE_CODE (type
) == ARRAY_TYPE
)
2593 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2595 TYPE_DOMAIN (type
));
2597 /* A restrict-qualified pointer type must be a pointer to object or
2598 incomplete type. Note that the use of POINTER_TYPE_P also allows
2599 REFERENCE_TYPEs, which is appropriate for C++. */
2600 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2601 && (!POINTER_TYPE_P (type
)
2602 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2604 error ("invalid use of `restrict'");
2605 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2608 return build_qualified_type (type
, type_quals
);
2611 /* Apply the TYPE_QUALS to the new DECL. */
2614 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
2616 tree type
= TREE_TYPE (decl
);
2618 if (type
== error_mark_node
)
2621 if (((type_quals
& TYPE_QUAL_CONST
)
2622 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
2623 /* An object declared 'const' is only readonly after it is
2624 initialized. We don't have any way of expressing this currently,
2625 so we need to be conservative and unset TREE_READONLY for types
2626 with constructors. Otherwise aliasing code will ignore stores in
2627 an inline constructor. */
2628 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
2629 TREE_READONLY (decl
) = 1;
2630 if (type_quals
& TYPE_QUAL_VOLATILE
)
2632 TREE_SIDE_EFFECTS (decl
) = 1;
2633 TREE_THIS_VOLATILE (decl
) = 1;
2635 if (type_quals
& TYPE_QUAL_RESTRICT
)
2637 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
2638 /* Allow 'restrict' on arrays of pointers.
2639 FIXME currently we just ignore it. */
2640 type
= TREE_TYPE (type
);
2642 || !POINTER_TYPE_P (type
)
2643 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
2644 error ("invalid use of `restrict'");
2645 else if (flag_strict_aliasing
&& type
== TREE_TYPE (decl
))
2646 /* Indicate we need to make a unique alias set for this pointer.
2647 We can't do it here because it might be pointing to an
2649 DECL_POINTER_ALIAS_SET (decl
) = -2;
2653 /* Hash function for the problem of multiple type definitions in
2654 different files. This must hash all types that will compare
2655 equal via comptypes to the same value. In practice it hashes
2656 on some of the simple stuff and leaves the details to comptypes. */
2659 c_type_hash (const void *p
)
2665 switch (TREE_CODE (t
))
2667 /* For pointers, hash on pointee type plus some swizzling. */
2669 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
2670 /* Hash on number of elements and total size. */
2673 t2
= TYPE_VALUES (t
);
2677 t2
= TYPE_FIELDS (t
);
2679 case QUAL_UNION_TYPE
:
2681 t2
= TYPE_FIELDS (t
);
2685 t2
= TYPE_FIELDS (t
);
2690 for (; t2
; t2
= TREE_CHAIN (t2
))
2692 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
2693 return ((size
<< 24) | (i
<< shift
));
2696 /* Return the typed-based alias set for T, which may be an expression
2697 or a type. Return -1 if we don't do anything special. */
2700 c_common_get_alias_set (tree t
)
2704 static htab_t type_hash_table
;
2706 /* Permit type-punning when accessing a union, provided the access
2707 is directly through the union. For example, this code does not
2708 permit taking the address of a union member and then storing
2709 through it. Even the type-punning allowed here is a GCC
2710 extension, albeit a common and useful one; the C standard says
2711 that such accesses have implementation-defined behavior. */
2713 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2714 u
= TREE_OPERAND (u
, 0))
2715 if (TREE_CODE (u
) == COMPONENT_REF
2716 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2719 /* That's all the expressions we handle specially. */
2723 /* The C standard guarantees that any object may be accessed via an
2724 lvalue that has character type. */
2725 if (t
== char_type_node
2726 || t
== signed_char_type_node
2727 || t
== unsigned_char_type_node
)
2730 /* If it has the may_alias attribute, it can alias anything. */
2731 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t
)))
2734 /* The C standard specifically allows aliasing between signed and
2735 unsigned variants of the same type. We treat the signed
2736 variant as canonical. */
2737 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
2739 tree t1
= c_common_signed_type (t
);
2741 /* t1 == t can happen for boolean nodes which are always unsigned. */
2743 return get_alias_set (t1
);
2745 else if (POINTER_TYPE_P (t
))
2749 /* Unfortunately, there is no canonical form of a pointer type.
2750 In particular, if we have `typedef int I', then `int *', and
2751 `I *' are different types. So, we have to pick a canonical
2752 representative. We do this below.
2754 Technically, this approach is actually more conservative that
2755 it needs to be. In particular, `const int *' and `int *'
2756 should be in different alias sets, according to the C and C++
2757 standard, since their types are not the same, and so,
2758 technically, an `int **' and `const int **' cannot point at
2761 But, the standard is wrong. In particular, this code is
2766 const int* const* cipp = ipp;
2768 And, it doesn't make sense for that to be legal unless you
2769 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2770 the pointed-to types. This issue has been reported to the
2772 t1
= build_type_no_quals (t
);
2774 return get_alias_set (t1
);
2777 /* Handle the case of multiple type nodes referring to "the same" type,
2778 which occurs with IMA. These share an alias set. FIXME: Currently only
2779 C90 is handled. (In C99 type compatibility is not transitive, which
2780 complicates things mightily. The alias set splay trees can theoretically
2781 represent this, but insertion is tricky when you consider all the
2782 different orders things might arrive in.) */
2784 if (c_language
!= clk_c
|| flag_isoc99
)
2787 /* Save time if there's only one input file. */
2788 if (!current_file_decl
|| TREE_CHAIN (current_file_decl
) == NULL_TREE
)
2791 /* Pointers need special handling if they point to any type that
2792 needs special handling (below). */
2793 if (TREE_CODE (t
) == POINTER_TYPE
)
2796 /* Find bottom type under any nested POINTERs. */
2797 for (t2
= TREE_TYPE (t
);
2798 TREE_CODE (t2
) == POINTER_TYPE
;
2799 t2
= TREE_TYPE (t2
))
2801 if (TREE_CODE (t2
) != RECORD_TYPE
2802 && TREE_CODE (t2
) != ENUMERAL_TYPE
2803 && TREE_CODE (t2
) != QUAL_UNION_TYPE
2804 && TREE_CODE (t2
) != UNION_TYPE
)
2806 if (TYPE_SIZE (t2
) == 0)
2809 /* These are the only cases that need special handling. */
2810 if (TREE_CODE (t
) != RECORD_TYPE
2811 && TREE_CODE (t
) != ENUMERAL_TYPE
2812 && TREE_CODE (t
) != QUAL_UNION_TYPE
2813 && TREE_CODE (t
) != UNION_TYPE
2814 && TREE_CODE (t
) != POINTER_TYPE
)
2817 if (TYPE_SIZE (t
) == 0)
2820 /* Look up t in hash table. Only one of the compatible types within each
2821 alias set is recorded in the table. */
2822 if (!type_hash_table
)
2823 type_hash_table
= htab_create (1021, c_type_hash
,
2824 (htab_eq
) lang_hooks
.types_compatible_p
,
2826 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
2828 return TYPE_ALIAS_SET ((tree
)*slot
);
2830 /* Our caller will assign and record (in t) a new alias set; all we need
2831 to do is remember t in the hash table. */
2837 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2838 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2839 flag controls whether we should diagnose possibly ill-formed
2840 constructs or not. */
2842 c_sizeof_or_alignof_type (tree type
, enum tree_code op
, int complain
)
2844 const char *op_name
;
2846 enum tree_code type_code
= TREE_CODE (type
);
2848 my_friendly_assert (op
== SIZEOF_EXPR
|| op
== ALIGNOF_EXPR
, 20020720);
2849 op_name
= op
== SIZEOF_EXPR
? "sizeof" : "__alignof__";
2851 if (type_code
== FUNCTION_TYPE
)
2853 if (op
== SIZEOF_EXPR
)
2855 if (complain
&& (pedantic
|| warn_pointer_arith
))
2856 pedwarn ("invalid application of `sizeof' to a function type");
2857 value
= size_one_node
;
2860 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2862 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
2864 if (type_code
== VOID_TYPE
2865 && complain
&& (pedantic
|| warn_pointer_arith
))
2866 pedwarn ("invalid application of `%s' to a void type", op_name
);
2867 value
= size_one_node
;
2869 else if (!COMPLETE_TYPE_P (type
))
2872 error ("invalid application of `%s' to incomplete type `%T' ",
2874 value
= size_zero_node
;
2878 if (op
== SIZEOF_EXPR
)
2879 /* Convert in case a char is more than one unit. */
2880 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
2881 size_int (TYPE_PRECISION (char_type_node
)
2884 value
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
2887 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2888 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2889 never happen. However, this node should really have type
2890 `size_t', which is just a typedef for an ordinary integer type. */
2891 value
= fold (build1 (NOP_EXPR
, size_type_node
, value
));
2892 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)), 20001021);
2897 /* Implement the __alignof keyword: Return the minimum required
2898 alignment of EXPR, measured in bytes. For VAR_DECL's and
2899 FIELD_DECL's return DECL_ALIGN (which can be set from an
2900 "aligned" __attribute__ specification). */
2903 c_alignof_expr (tree expr
)
2907 if (TREE_CODE (expr
) == VAR_DECL
)
2908 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
2910 else if (TREE_CODE (expr
) == COMPONENT_REF
2911 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
2913 error ("`__alignof' applied to a bit-field");
2916 else if (TREE_CODE (expr
) == COMPONENT_REF
2917 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
2918 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
2920 else if (TREE_CODE (expr
) == INDIRECT_REF
)
2922 tree t
= TREE_OPERAND (expr
, 0);
2924 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2926 while (TREE_CODE (t
) == NOP_EXPR
2927 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
2931 t
= TREE_OPERAND (t
, 0);
2932 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2933 if (thisalign
> bestalign
)
2934 best
= t
, bestalign
= thisalign
;
2936 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
2939 return c_alignof (TREE_TYPE (expr
));
2941 return fold (build1 (NOP_EXPR
, size_type_node
, t
));
2944 /* Handle C and C++ default attributes. */
2946 enum built_in_attribute
2948 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2949 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2950 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2951 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2952 #include "builtin-attrs.def"
2953 #undef DEF_ATTR_NULL_TREE
2955 #undef DEF_ATTR_IDENT
2956 #undef DEF_ATTR_TREE_LIST
2960 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
2962 static void c_init_attributes (void);
2964 /* Build tree nodes and builtin functions common to both C and C++ language
2968 c_common_nodes_and_builtins (void)
2972 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2973 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2974 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2975 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2976 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2977 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2978 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2979 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2980 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2981 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2982 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2983 #include "builtin-types.def"
2984 #undef DEF_PRIMITIVE_TYPE
2985 #undef DEF_FUNCTION_TYPE_0
2986 #undef DEF_FUNCTION_TYPE_1
2987 #undef DEF_FUNCTION_TYPE_2
2988 #undef DEF_FUNCTION_TYPE_3
2989 #undef DEF_FUNCTION_TYPE_4
2990 #undef DEF_FUNCTION_TYPE_VAR_0
2991 #undef DEF_FUNCTION_TYPE_VAR_1
2992 #undef DEF_FUNCTION_TYPE_VAR_2
2993 #undef DEF_FUNCTION_TYPE_VAR_3
2994 #undef DEF_POINTER_TYPE
2998 typedef enum builtin_type builtin_type
;
3000 tree builtin_types
[(int) BT_LAST
];
3001 int wchar_type_size
;
3002 tree array_domain_type
;
3003 tree va_list_ref_type_node
;
3004 tree va_list_arg_type_node
;
3006 /* Define `int' and `char' first so that dbx will output them first. */
3007 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3008 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3010 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3011 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3012 but not C. Are the conditionals here needed? */
3013 if (c_dialect_cxx ())
3014 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3015 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3016 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3017 record_builtin_type (RID_MAX
, "long unsigned int",
3018 long_unsigned_type_node
);
3019 if (c_dialect_cxx ())
3020 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3021 record_builtin_type (RID_MAX
, "long long int",
3022 long_long_integer_type_node
);
3023 record_builtin_type (RID_MAX
, "long long unsigned int",
3024 long_long_unsigned_type_node
);
3025 if (c_dialect_cxx ())
3026 record_builtin_type (RID_MAX
, "long long unsigned",
3027 long_long_unsigned_type_node
);
3028 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3029 record_builtin_type (RID_MAX
, "short unsigned int",
3030 short_unsigned_type_node
);
3031 if (c_dialect_cxx ())
3032 record_builtin_type (RID_MAX
, "unsigned short",
3033 short_unsigned_type_node
);
3035 /* Define both `signed char' and `unsigned char'. */
3036 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
3037 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
3039 /* These are types that c_common_type_for_size and
3040 c_common_type_for_mode use. */
3041 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3043 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3045 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3047 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3049 #if HOST_BITS_PER_WIDE_INT >= 64
3050 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3051 get_identifier ("__int128_t"),
3054 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3055 unsigned_intQI_type_node
));
3056 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3057 unsigned_intHI_type_node
));
3058 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3059 unsigned_intSI_type_node
));
3060 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3061 unsigned_intDI_type_node
));
3062 #if HOST_BITS_PER_WIDE_INT >= 64
3063 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3064 get_identifier ("__uint128_t"),
3065 unsigned_intTI_type_node
));
3068 /* Create the widest literal types. */
3069 widest_integer_literal_type_node
3070 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
3071 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3072 widest_integer_literal_type_node
));
3074 widest_unsigned_literal_type_node
3075 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
3076 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
3077 widest_unsigned_literal_type_node
));
3079 /* `unsigned long' is the standard type for sizeof.
3080 Note that stddef.h uses `unsigned long',
3081 and this must agree, even if long and int are the same size. */
3083 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
3084 signed_size_type_node
= c_common_signed_type (size_type_node
);
3085 set_sizetype (size_type_node
);
3088 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
3090 build_common_tree_nodes_2 (flag_short_double
);
3092 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
3093 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
3094 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
3096 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3097 get_identifier ("complex int"),
3098 complex_integer_type_node
));
3099 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3100 get_identifier ("complex float"),
3101 complex_float_type_node
));
3102 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
3103 get_identifier ("complex double"),
3104 complex_double_type_node
));
3105 lang_hooks
.decls
.pushdecl
3106 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
3107 complex_long_double_type_node
));
3109 if (c_dialect_cxx ())
3110 /* For C++, make fileptr_type_node a distinct void * type until
3111 FILE type is defined. */
3112 fileptr_type_node
= build_type_copy (ptr_type_node
);
3114 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
3116 void_zero_node
= build_int_2 (0, 0);
3117 TREE_TYPE (void_zero_node
) = void_type_node
;
3119 void_list_node
= build_void_list_node ();
3121 /* Make a type to be the domain of a few array types
3122 whose domains don't really matter.
3123 200 is small enough that it always fits in size_t
3124 and large enough that it can hold most function names for the
3125 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3126 array_domain_type
= build_index_type (size_int (200));
3128 /* Make a type for arrays of characters.
3129 With luck nothing will ever really depend on the length of this
3131 char_array_type_node
3132 = build_array_type (char_type_node
, array_domain_type
);
3134 /* Likewise for arrays of ints. */
3136 = build_array_type (integer_type_node
, array_domain_type
);
3138 string_type_node
= build_pointer_type (char_type_node
);
3139 const_string_type_node
3140 = build_pointer_type (build_qualified_type
3141 (char_type_node
, TYPE_QUAL_CONST
));
3143 /* This is special for C++ so functions can be overloaded. */
3144 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
3145 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
3146 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
3147 if (c_dialect_cxx ())
3149 if (TYPE_UNSIGNED (wchar_type_node
))
3150 wchar_type_node
= make_unsigned_type (wchar_type_size
);
3152 wchar_type_node
= make_signed_type (wchar_type_size
);
3153 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
3157 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
3158 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
3161 /* This is for wide string constants. */
3162 wchar_array_type_node
3163 = build_array_type (wchar_type_node
, array_domain_type
);
3166 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
3169 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
3171 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
3173 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
3175 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
3176 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
3178 lang_hooks
.decls
.pushdecl
3179 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
3180 va_list_type_node
));
3182 lang_hooks
.decls
.pushdecl
3183 (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
3184 ptrdiff_type_node
));
3186 lang_hooks
.decls
.pushdecl
3187 (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
3190 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
3192 va_list_arg_type_node
= va_list_ref_type_node
=
3193 build_pointer_type (TREE_TYPE (va_list_type_node
));
3197 va_list_arg_type_node
= va_list_type_node
;
3198 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
3201 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3202 builtin_types[(int) ENUM] = VALUE;
3203 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3204 builtin_types[(int) ENUM] \
3205 = build_function_type (builtin_types[(int) RETURN], \
3207 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3208 builtin_types[(int) ENUM] \
3209 = build_function_type (builtin_types[(int) RETURN], \
3210 tree_cons (NULL_TREE, \
3211 builtin_types[(int) ARG1], \
3213 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3214 builtin_types[(int) ENUM] \
3215 = build_function_type \
3216 (builtin_types[(int) RETURN], \
3217 tree_cons (NULL_TREE, \
3218 builtin_types[(int) ARG1], \
3219 tree_cons (NULL_TREE, \
3220 builtin_types[(int) ARG2], \
3222 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3223 builtin_types[(int) ENUM] \
3224 = build_function_type \
3225 (builtin_types[(int) RETURN], \
3226 tree_cons (NULL_TREE, \
3227 builtin_types[(int) ARG1], \
3228 tree_cons (NULL_TREE, \
3229 builtin_types[(int) ARG2], \
3230 tree_cons (NULL_TREE, \
3231 builtin_types[(int) ARG3], \
3233 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3234 builtin_types[(int) ENUM] \
3235 = build_function_type \
3236 (builtin_types[(int) RETURN], \
3237 tree_cons (NULL_TREE, \
3238 builtin_types[(int) ARG1], \
3239 tree_cons (NULL_TREE, \
3240 builtin_types[(int) ARG2], \
3243 builtin_types[(int) ARG3], \
3244 tree_cons (NULL_TREE, \
3245 builtin_types[(int) ARG4], \
3246 void_list_node)))));
3247 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3248 builtin_types[(int) ENUM] \
3249 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3250 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3251 builtin_types[(int) ENUM] \
3252 = build_function_type (builtin_types[(int) RETURN], \
3253 tree_cons (NULL_TREE, \
3254 builtin_types[(int) ARG1], \
3257 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3258 builtin_types[(int) ENUM] \
3259 = build_function_type \
3260 (builtin_types[(int) RETURN], \
3261 tree_cons (NULL_TREE, \
3262 builtin_types[(int) ARG1], \
3263 tree_cons (NULL_TREE, \
3264 builtin_types[(int) ARG2], \
3267 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3268 builtin_types[(int) ENUM] \
3269 = build_function_type \
3270 (builtin_types[(int) RETURN], \
3271 tree_cons (NULL_TREE, \
3272 builtin_types[(int) ARG1], \
3273 tree_cons (NULL_TREE, \
3274 builtin_types[(int) ARG2], \
3275 tree_cons (NULL_TREE, \
3276 builtin_types[(int) ARG3], \
3279 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3280 builtin_types[(int) ENUM] \
3281 = build_pointer_type (builtin_types[(int) TYPE]);
3282 #include "builtin-types.def"
3283 #undef DEF_PRIMITIVE_TYPE
3284 #undef DEF_FUNCTION_TYPE_1
3285 #undef DEF_FUNCTION_TYPE_2
3286 #undef DEF_FUNCTION_TYPE_3
3287 #undef DEF_FUNCTION_TYPE_4
3288 #undef DEF_FUNCTION_TYPE_VAR_0
3289 #undef DEF_FUNCTION_TYPE_VAR_1
3290 #undef DEF_FUNCTION_TYPE_VAR_2
3291 #undef DEF_FUNCTION_TYPE_VAR_3
3292 #undef DEF_POINTER_TYPE
3294 c_init_attributes ();
3296 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3297 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3302 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3306 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3309 ? (NAME + strlen ("__builtin_")) \
3311 built_in_attributes[(int) ATTRS]); \
3313 decl = builtin_function_2 (NAME, \
3314 NAME + strlen ("__builtin_"), \
3315 builtin_types[TYPE], \
3316 builtin_types[LIBTYPE], \
3321 built_in_attributes[(int) ATTRS]); \
3323 built_in_decls[(int) ENUM] = decl; \
3325 implicit_built_in_decls[(int) ENUM] = decl; \
3327 #include "builtins.def"
3330 targetm
.init_builtins ();
3332 main_identifier_node
= get_identifier ("main");
3336 build_va_arg (tree expr
, tree type
)
3338 return build1 (VA_ARG_EXPR
, type
, expr
);
3342 /* Linked list of disabled built-in functions. */
3344 typedef struct disabled_builtin
3347 struct disabled_builtin
*next
;
3349 static disabled_builtin
*disabled_builtins
= NULL
;
3351 static bool builtin_function_disabled_p (const char *);
3353 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3354 begins with "__builtin_", give an error. */
3357 disable_builtin_function (const char *name
)
3359 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3360 error ("cannot disable built-in function `%s'", name
);
3363 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
3365 new->next
= disabled_builtins
;
3366 disabled_builtins
= new;
3371 /* Return true if the built-in function NAME has been disabled, false
3375 builtin_function_disabled_p (const char *name
)
3377 disabled_builtin
*p
;
3378 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3380 if (strcmp (name
, p
->name
) == 0)
3387 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3388 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3389 of these may be NULL (though both being NULL is useless).
3390 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3391 TYPE is the type of the function with the ordinary name. These
3392 may differ if the ordinary name is declared with a looser type to avoid
3393 conflicts with headers. FUNCTION_CODE and CLASS are as for
3394 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3395 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3396 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3397 ATTRS is the tree list representing the builtin's function attributes.
3398 Returns the declaration of BUILTIN_NAME, if any, otherwise
3399 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3400 or if NONANSI_P and flag_no_nonansi_builtin. */
3403 builtin_function_2 (const char *builtin_name
, const char *name
,
3404 tree builtin_type
, tree type
, int function_code
,
3405 enum built_in_class
class, int library_name_p
,
3406 int nonansi_p
, tree attrs
)
3408 tree bdecl
= NULL_TREE
;
3409 tree decl
= NULL_TREE
;
3411 if (builtin_name
!= 0)
3412 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
3413 class, library_name_p
? name
: NULL
, attrs
);
3415 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
3416 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3417 decl
= builtin_function (name
, type
, function_code
, class, NULL
, attrs
);
3419 return (bdecl
!= 0 ? bdecl
: decl
);
3422 /* Nonzero if the type T promotes to int. This is (nearly) the
3423 integral promotions defined in ISO C99 6.3.1.1/2. */
3426 c_promoting_integer_type_p (tree t
)
3428 switch (TREE_CODE (t
))
3431 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3432 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3433 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3434 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3435 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3436 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3439 /* ??? Technically all enumerations not larger than an int
3440 promote to an int. But this is used along code paths
3441 that only want to notice a size change. */
3442 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3452 /* Return 1 if PARMS specifies a fixed number of parameters
3453 and none of their types is affected by default promotions. */
3456 self_promoting_args_p (tree parms
)
3459 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3461 tree type
= TREE_VALUE (t
);
3463 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3469 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3472 if (c_promoting_integer_type_p (type
))
3478 /* Recursively examines the array elements of TYPE, until a non-array
3479 element type is found. */
3482 strip_array_types (tree type
)
3484 while (TREE_CODE (type
) == ARRAY_TYPE
)
3485 type
= TREE_TYPE (type
);
3490 /* Recursively remove any '*' or '&' operator from TYPE. */
3492 strip_pointer_operator (tree t
)
3494 while (POINTER_TYPE_P (t
))
3499 static tree
expand_unordered_cmp (tree
, tree
, enum tree_code
, enum tree_code
);
3501 /* Expand a call to an unordered comparison function such as
3502 __builtin_isgreater(). FUNCTION is the function's declaration and
3503 PARAMS a list of the values passed. For __builtin_isunordered(),
3504 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3505 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3506 that give the opposite of the desired result. UNORDERED_CODE is
3507 used for modes that can hold NaNs and ORDERED_CODE is used for the
3511 expand_unordered_cmp (tree function
, tree params
,
3512 enum tree_code unordered_code
,
3513 enum tree_code ordered_code
)
3515 tree arg0
, arg1
, type
;
3516 enum tree_code code0
, code1
;
3518 /* Check that we have exactly two arguments. */
3519 if (params
== 0 || TREE_CHAIN (params
) == 0)
3521 error ("too few arguments to function `%s'",
3522 IDENTIFIER_POINTER (DECL_NAME (function
)));
3523 return error_mark_node
;
3525 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3527 error ("too many arguments to function `%s'",
3528 IDENTIFIER_POINTER (DECL_NAME (function
)));
3529 return error_mark_node
;
3532 arg0
= TREE_VALUE (params
);
3533 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3535 code0
= TREE_CODE (TREE_TYPE (arg0
));
3536 code1
= TREE_CODE (TREE_TYPE (arg1
));
3538 /* Make sure that the arguments have a common type of REAL. */
3540 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3541 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3542 type
= common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
));
3544 if (type
== 0 || TREE_CODE (type
) != REAL_TYPE
)
3546 error ("non-floating-point argument to function `%s'",
3547 IDENTIFIER_POINTER (DECL_NAME (function
)));
3548 return error_mark_node
;
3551 if (unordered_code
== UNORDERED_EXPR
)
3553 if (MODE_HAS_NANS (TYPE_MODE (type
)))
3554 return build_binary_op (unordered_code
,
3555 convert (type
, arg0
),
3556 convert (type
, arg1
),
3559 return integer_zero_node
;
3562 return build_unary_op (TRUTH_NOT_EXPR
,
3563 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type
))
3566 convert (type
, arg0
),
3567 convert (type
, arg1
),
3573 /* Recognize certain built-in functions so we can make tree-codes
3574 other than CALL_EXPR. We do this when it enables fold-const.c
3575 to do something useful. */
3576 /* ??? By rights this should go in builtins.c, but only C and C++
3577 implement build_{binary,unary}_op. Not exactly sure what bits
3578 of functionality are actually needed from those functions, or
3579 where the similar functionality exists in the other front ends. */
3582 expand_tree_builtin (tree function
, tree params
, tree coerced_params
)
3584 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
3587 switch (DECL_FUNCTION_CODE (function
))
3591 case BUILT_IN_LLABS
:
3592 case BUILT_IN_IMAXABS
:
3594 case BUILT_IN_FABSL
:
3595 case BUILT_IN_FABSF
:
3596 if (coerced_params
== 0)
3597 return integer_zero_node
;
3598 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3601 case BUILT_IN_CONJF
:
3602 case BUILT_IN_CONJL
:
3603 if (coerced_params
== 0)
3604 return integer_zero_node
;
3605 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3607 case BUILT_IN_CREAL
:
3608 case BUILT_IN_CREALF
:
3609 case BUILT_IN_CREALL
:
3610 if (coerced_params
== 0)
3611 return integer_zero_node
;
3612 return non_lvalue (build_unary_op (REALPART_EXPR
,
3613 TREE_VALUE (coerced_params
), 0));
3615 case BUILT_IN_CIMAG
:
3616 case BUILT_IN_CIMAGF
:
3617 case BUILT_IN_CIMAGL
:
3618 if (coerced_params
== 0)
3619 return integer_zero_node
;
3620 return non_lvalue (build_unary_op (IMAGPART_EXPR
,
3621 TREE_VALUE (coerced_params
), 0));
3623 case BUILT_IN_ISGREATER
:
3624 return expand_unordered_cmp (function
, params
, UNLE_EXPR
, LE_EXPR
);
3626 case BUILT_IN_ISGREATEREQUAL
:
3627 return expand_unordered_cmp (function
, params
, UNLT_EXPR
, LT_EXPR
);
3629 case BUILT_IN_ISLESS
:
3630 return expand_unordered_cmp (function
, params
, UNGE_EXPR
, GE_EXPR
);
3632 case BUILT_IN_ISLESSEQUAL
:
3633 return expand_unordered_cmp (function
, params
, UNGT_EXPR
, GT_EXPR
);
3635 case BUILT_IN_ISLESSGREATER
:
3636 return expand_unordered_cmp (function
, params
, UNEQ_EXPR
, EQ_EXPR
);
3638 case BUILT_IN_ISUNORDERED
:
3639 return expand_unordered_cmp (function
, params
, UNORDERED_EXPR
, NOP_EXPR
);
3648 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3649 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3650 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3651 value, the traversal is aborted, and the value returned by FUNC is
3652 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3653 the node being visited are not walked.
3655 We don't need a without_duplicates variant of this one because the
3656 statement tree is a tree, not a graph. */
3659 walk_stmt_tree (tree
*tp
, walk_tree_fn func
, void *data
)
3661 enum tree_code code
;
3666 #define WALK_SUBTREE(NODE) \
3669 result = walk_stmt_tree (&(NODE), func, data); \
3675 /* Skip empty subtrees. */
3679 /* Skip subtrees below non-statement nodes. */
3680 if (!STATEMENT_CODE_P (TREE_CODE (*tp
)))
3683 /* Call the function. */
3685 result
= (*func
) (tp
, &walk_subtrees
, data
);
3687 /* If we found something, return it. */
3691 /* FUNC may have modified the tree, recheck that we're looking at a
3693 code
= TREE_CODE (*tp
);
3694 if (!STATEMENT_CODE_P (code
))
3697 /* Visit the subtrees unless FUNC decided that there was nothing
3698 interesting below this point in the tree. */
3701 /* Walk over all the sub-trees of this operand. Statement nodes
3702 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3703 len
= TREE_CODE_LENGTH (code
);
3705 /* Go through the subtrees. We need to do this in forward order so
3706 that the scope of a FOR_EXPR is handled properly. */
3707 for (i
= 0; i
< len
; ++i
)
3708 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3711 /* Finally visit the chain. This can be tail-recursion optimized if
3712 we write it this way. */
3713 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3718 /* Used to compare case labels. K1 and K2 are actually tree nodes
3719 representing case labels, or NULL_TREE for a `default' label.
3720 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3721 K2, and 0 if K1 and K2 are equal. */
3724 case_compare (splay_tree_key k1
, splay_tree_key k2
)
3726 /* Consider a NULL key (such as arises with a `default' label) to be
3727 smaller than anything else. */
3733 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3736 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3737 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3738 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3739 case label was declared using the usual C/C++ syntax, rather than
3740 the GNU case range extension. CASES is a tree containing all the
3741 case ranges processed so far; COND is the condition for the
3742 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3743 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3746 c_add_case_label (splay_tree cases
, tree cond
, tree low_value
,
3752 splay_tree_node node
;
3754 /* Create the LABEL_DECL itself. */
3755 label
= create_artificial_label ();
3757 /* If there was an error processing the switch condition, bail now
3758 before we get more confused. */
3759 if (!cond
|| cond
== error_mark_node
)
3762 if ((low_value
&& TREE_TYPE (low_value
)
3763 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3764 || (high_value
&& TREE_TYPE (high_value
)
3765 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3766 error ("pointers are not permitted as case values");
3768 /* Case ranges are a GNU extension. */
3769 if (high_value
&& pedantic
)
3770 pedwarn ("range expressions in switch statements are non-standard");
3772 type
= TREE_TYPE (cond
);
3775 low_value
= check_case_value (low_value
);
3776 low_value
= convert_and_check (type
, low_value
);
3780 high_value
= check_case_value (high_value
);
3781 high_value
= convert_and_check (type
, high_value
);
3784 /* If an error has occurred, bail out now. */
3785 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
3788 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3789 really a case range, even though it was written that way. Remove
3790 the HIGH_VALUE to simplify later processing. */
3791 if (tree_int_cst_equal (low_value
, high_value
))
3792 high_value
= NULL_TREE
;
3793 if (low_value
&& high_value
3794 && !tree_int_cst_lt (low_value
, high_value
))
3795 warning ("empty range specified");
3797 /* Look up the LOW_VALUE in the table of case labels we already
3799 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3800 /* If there was not an exact match, check for overlapping ranges.
3801 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3802 that's a `default' label and the only overlap is an exact match. */
3803 if (!node
&& (low_value
|| high_value
))
3805 splay_tree_node low_bound
;
3806 splay_tree_node high_bound
;
3808 /* Even though there wasn't an exact match, there might be an
3809 overlap between this case range and another case range.
3810 Since we've (inductively) not allowed any overlapping case
3811 ranges, we simply need to find the greatest low case label
3812 that is smaller that LOW_VALUE, and the smallest low case
3813 label that is greater than LOW_VALUE. If there is an overlap
3814 it will occur in one of these two ranges. */
3815 low_bound
= splay_tree_predecessor (cases
,
3816 (splay_tree_key
) low_value
);
3817 high_bound
= splay_tree_successor (cases
,
3818 (splay_tree_key
) low_value
);
3820 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3821 the LOW_VALUE, so there is no need to check unless the
3822 LOW_BOUND is in fact itself a case range. */
3824 && CASE_HIGH ((tree
) low_bound
->value
)
3825 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3828 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3829 range is bigger than the low end of the current range, so we
3830 are only interested if the current range is a real range, and
3831 not an ordinary case label. */
3834 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3839 /* If there was an overlap, issue an error. */
3842 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
3846 error ("duplicate (or overlapping) case value");
3847 error ("%Jthis is the first entry overlapping that value", duplicate
);
3851 error ("duplicate case value") ;
3852 error ("%Jpreviously used here", duplicate
);
3856 error ("multiple default labels in one switch");
3857 error ("%Jthis is the first default label", duplicate
);
3862 /* Add a CASE_LABEL to the statement-tree. */
3863 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3864 /* Register this case label in the splay tree. */
3865 splay_tree_insert (cases
,
3866 (splay_tree_key
) low_value
,
3867 (splay_tree_value
) case_label
);
3872 /* Add a label so that the back-end doesn't think that the beginning of
3873 the switch is unreachable. Note that we do not add a case label, as
3874 that just leads to duplicates and thence to aborts later on. */
3877 tree t
= create_artificial_label ();
3878 add_stmt (build_stmt (LABEL_EXPR
, t
));
3880 return error_mark_node
;
3883 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3884 Used to verify that case values match up with enumerator values. */
3887 match_case_to_enum_1 (tree key
, tree type
, tree label
)
3889 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
3891 /* ??? Not working too hard to print the double-word value.
3892 Should perhaps be done with %lwd in the diagnostic routines? */
3893 if (TREE_INT_CST_HIGH (key
) == 0)
3894 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
3895 TREE_INT_CST_LOW (key
));
3896 else if (!TYPE_UNSIGNED (type
)
3897 && TREE_INT_CST_HIGH (key
) == -1
3898 && TREE_INT_CST_LOW (key
) != 0)
3899 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
3900 -TREE_INT_CST_LOW (key
));
3902 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3903 TREE_INT_CST_HIGH (key
), TREE_INT_CST_LOW (key
));
3905 if (TYPE_NAME (type
) == 0)
3906 warning ("%Jcase value `%s' not in enumerated type",
3907 CASE_LABEL (label
), buf
);
3909 warning ("%Jcase value `%s' not in enumerated type `%T'",
3910 CASE_LABEL (label
), buf
, type
);
3914 match_case_to_enum (splay_tree_node node
, void *data
)
3916 tree label
= (tree
) node
->value
;
3919 /* Skip default case. */
3920 if (!CASE_LOW (label
))
3923 /* If TREE_ADDRESSABLE is not set, that means CASE_LOW did not appear
3924 when we did our enum->case scan. Reset our scratch bit after. */
3925 if (!TREE_ADDRESSABLE (label
))
3926 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
3928 TREE_ADDRESSABLE (label
) = 0;
3930 /* If CASE_HIGH is non-null, we have a range. Here we must search.
3931 Note that the old code in stmt.c did not check for the values in
3932 the range either, just the endpoints. */
3933 if (CASE_HIGH (label
))
3935 tree chain
, key
= CASE_HIGH (label
);
3937 for (chain
= TYPE_VALUES (type
);
3938 chain
&& !tree_int_cst_equal (key
, TREE_VALUE (chain
));
3939 chain
= TREE_CHAIN (chain
))
3942 match_case_to_enum_1 (key
, type
, label
);
3948 /* Handle -Wswitch*. Called from the front end after parsing the switch
3950 /* ??? Should probably be somewhere generic, since other languages besides
3951 C and C++ would want this. We'd want to agree on the datastructure,
3952 however, which is a problem. Alternately, we operate on gimplified
3953 switch_exprs, which I don't especially like. At the moment, however,
3954 C/C++ are the only tree-ssa languages that support enumerations at all,
3955 so the point is moot. */
3958 c_do_switch_warnings (splay_tree cases
, tree switch_stmt
)
3960 splay_tree_node default_node
;
3961 location_t
*switch_locus
;
3964 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
3967 switch_locus
= EXPR_LOCUS (switch_stmt
);
3969 switch_locus
= &input_location
;
3970 type
= SWITCH_TYPE (switch_stmt
);
3972 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
3973 if (warn_switch_default
&& !default_node
)
3974 warning ("%Hswitch missing default case", switch_locus
);
3976 /* If the switch expression was an enumerated type, check that
3977 exactly all enumeration literals are covered by the cases.
3978 The check is made when -Wswitch was specified and there is no
3979 default case, or when -Wswitch-enum was specified. */
3980 if (((warn_switch
&& !default_node
) || warn_switch_enum
)
3981 && type
&& TREE_CODE (type
) == ENUMERAL_TYPE
3982 && TREE_CODE (SWITCH_COND (switch_stmt
)) != INTEGER_CST
)
3986 /* The time complexity here is O(N*lg(N)) worst case, but for the
3987 common case of monotonically increasing enumerators, it is
3988 O(N), since the nature of the splay tree will keep the next
3989 element adjacent to the root at all times. */
3991 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
3993 splay_tree_node node
3994 = splay_tree_lookup (cases
, (splay_tree_key
) TREE_VALUE (chain
));
3998 /* Mark the CASE_LOW part of the case entry as seen, so
3999 that we save time later. Choose TREE_ADDRESSABLE
4000 randomly as a bit that won't have been set to-date. */
4001 tree label
= (tree
) node
->value
;
4002 TREE_ADDRESSABLE (label
) = 1;
4006 /* Warn if there are enumerators that don't correspond to
4007 case expressions. */
4008 warning ("%Henumeration value `%E' not handled in switch",
4009 switch_locus
, TREE_PURPOSE (chain
));
4013 /* Warn if there are case expressions that don't correspond to
4014 enumerators. This can occur since C and C++ don't enforce
4015 type-checking of assignments to enumeration variables.
4017 The time complexity here is O(N**2) worst case, since we've
4018 not sorted the enumeration values. However, in the absence
4019 of case ranges this is O(N), since all single cases that
4020 corresponded to enumerations have been marked above. */
4022 splay_tree_foreach (cases
, match_case_to_enum
, type
);
4026 /* Finish an expression taking the address of LABEL (an
4027 IDENTIFIER_NODE). Returns an expression for the address. */
4030 finish_label_address_expr (tree label
)
4035 pedwarn ("taking the address of a label is non-standard");
4037 if (label
== error_mark_node
)
4038 return error_mark_node
;
4040 label
= lookup_label (label
);
4041 if (label
== NULL_TREE
)
4042 result
= null_pointer_node
;
4045 TREE_USED (label
) = 1;
4046 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4047 /* The current function in not necessarily uninlinable.
4048 Computed gotos are incompatible with inlining, but the value
4049 here could be used only in a diagnostic, for example. */
4055 /* Hook used by expand_expr to expand language-specific tree codes. */
4056 /* The only things that should go here are bits needed to expand
4057 constant initializers. Everything else should be handled by the
4058 gimplification routines. */
4061 c_expand_expr (tree exp
, rtx target
, enum machine_mode tmode
,
4062 int modifier
/* Actually enum_modifier. */,
4065 switch (TREE_CODE (exp
))
4067 case COMPOUND_LITERAL_EXPR
:
4069 /* Initialize the anonymous variable declared in the compound
4070 literal, then return the variable. */
4071 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4072 emit_local_var (decl
);
4073 return expand_expr_real (decl
, target
, tmode
, modifier
, alt_rtl
);
4081 /* Hook used by safe_from_p to handle language-specific tree codes. */
4084 c_safe_from_p (rtx target
, tree exp
)
4086 /* We can see statements here when processing the body of a
4087 statement-expression. For a declaration statement declaring a
4088 variable, look at the variable's initializer. */
4089 if (TREE_CODE (exp
) == DECL_STMT
)
4091 tree decl
= DECL_STMT_DECL (exp
);
4093 if (TREE_CODE (decl
) == VAR_DECL
4094 && DECL_INITIAL (decl
)
4095 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
4099 /* Assume everything else is safe. */
4103 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4106 c_common_unsafe_for_reeval (tree exp
)
4108 /* Statement expressions may not be reevaluated, likewise compound
4110 if (TREE_CODE (exp
) == STMT_EXPR
4111 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
4114 /* Walk all other expressions. */
4118 /* Hook used by staticp to handle language-specific tree codes. */
4121 c_staticp (tree exp
)
4123 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4124 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
4130 /* Given a boolean expression ARG, return a tree representing an increment
4131 or decrement (as indicated by CODE) of ARG. The front end must check for
4132 invalid cases (e.g., decrement in C++). */
4134 boolean_increment (enum tree_code code
, tree arg
)
4137 tree true_res
= boolean_true_node
;
4139 arg
= stabilize_reference (arg
);
4142 case PREINCREMENT_EXPR
:
4143 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4145 case POSTINCREMENT_EXPR
:
4146 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4147 arg
= save_expr (arg
);
4148 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4149 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4151 case PREDECREMENT_EXPR
:
4152 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4154 case POSTDECREMENT_EXPR
:
4155 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4156 arg
= save_expr (arg
);
4157 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4158 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4163 TREE_SIDE_EFFECTS (val
) = 1;
4167 /* Built-in macros for stddef.h, that require macros defined in this
4170 c_stddef_cpp_builtins(void)
4172 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4173 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4174 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4175 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4179 c_init_attributes (void)
4181 /* Fill in the built_in_attributes array. */
4182 #define DEF_ATTR_NULL_TREE(ENUM) \
4183 built_in_attributes[(int) ENUM] = NULL_TREE;
4184 #define DEF_ATTR_INT(ENUM, VALUE) \
4185 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4186 #define DEF_ATTR_IDENT(ENUM, STRING) \
4187 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4188 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4189 built_in_attributes[(int) ENUM] \
4190 = tree_cons (built_in_attributes[(int) PURPOSE], \
4191 built_in_attributes[(int) VALUE], \
4192 built_in_attributes[(int) CHAIN]);
4193 #include "builtin-attrs.def"
4194 #undef DEF_ATTR_NULL_TREE
4196 #undef DEF_ATTR_IDENT
4197 #undef DEF_ATTR_TREE_LIST
4200 /* Attribute handlers common to C front ends. */
4202 /* Handle a "packed" attribute; arguments as in
4203 struct attribute_spec.handler. */
4206 handle_packed_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4207 int flags
, bool *no_add_attrs
)
4211 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4212 *node
= build_type_copy (*node
);
4213 TYPE_PACKED (*node
) = 1;
4214 if (TYPE_MAIN_VARIANT (*node
) == *node
)
4216 /* If it is the main variant, then pack the other variants
4217 too. This happens in,
4220 struct Foo const *ptr; // creates a variant w/o packed flag
4221 } __ attribute__((packed)); // packs it now.
4225 for (probe
= *node
; probe
; probe
= TYPE_NEXT_VARIANT (probe
))
4226 TYPE_PACKED (probe
) = 1;
4230 else if (TREE_CODE (*node
) == FIELD_DECL
)
4231 DECL_PACKED (*node
) = 1;
4232 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4233 used for DECL_REGISTER. It wouldn't mean anything anyway.
4234 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4235 that changes what the typedef is typing. */
4238 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4239 *no_add_attrs
= true;
4245 /* Handle a "nocommon" attribute; arguments as in
4246 struct attribute_spec.handler. */
4249 handle_nocommon_attribute (tree
*node
, tree name
,
4250 tree args ATTRIBUTE_UNUSED
,
4251 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4253 if (TREE_CODE (*node
) == VAR_DECL
)
4254 DECL_COMMON (*node
) = 0;
4257 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4258 *no_add_attrs
= true;
4264 /* Handle a "common" attribute; arguments as in
4265 struct attribute_spec.handler. */
4268 handle_common_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4269 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4271 if (TREE_CODE (*node
) == VAR_DECL
)
4272 DECL_COMMON (*node
) = 1;
4275 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4276 *no_add_attrs
= true;
4282 /* Handle a "noreturn" attribute; arguments as in
4283 struct attribute_spec.handler. */
4286 handle_noreturn_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4287 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4289 tree type
= TREE_TYPE (*node
);
4291 /* See FIXME comment in c_common_attribute_table. */
4292 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4293 TREE_THIS_VOLATILE (*node
) = 1;
4294 else if (TREE_CODE (type
) == POINTER_TYPE
4295 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4297 = build_pointer_type
4298 (build_type_variant (TREE_TYPE (type
),
4299 TYPE_READONLY (TREE_TYPE (type
)), 1));
4302 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4303 *no_add_attrs
= true;
4309 /* Handle a "noinline" attribute; arguments as in
4310 struct attribute_spec.handler. */
4313 handle_noinline_attribute (tree
*node
, tree name
,
4314 tree args ATTRIBUTE_UNUSED
,
4315 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4317 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4318 DECL_UNINLINABLE (*node
) = 1;
4321 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4322 *no_add_attrs
= true;
4328 /* Handle a "always_inline" attribute; arguments as in
4329 struct attribute_spec.handler. */
4332 handle_always_inline_attribute (tree
*node
, tree name
,
4333 tree args ATTRIBUTE_UNUSED
,
4334 int flags ATTRIBUTE_UNUSED
,
4337 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4339 /* Do nothing else, just set the attribute. We'll get at
4340 it later with lookup_attribute. */
4344 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4345 *no_add_attrs
= true;
4351 /* Handle a "used" attribute; arguments as in
4352 struct attribute_spec.handler. */
4355 handle_used_attribute (tree
*pnode
, tree name
, tree args ATTRIBUTE_UNUSED
,
4356 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4360 if (TREE_CODE (node
) == FUNCTION_DECL
4361 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
4363 TREE_USED (node
) = 1;
4367 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4368 *no_add_attrs
= true;
4374 /* Handle a "unused" attribute; arguments as in
4375 struct attribute_spec.handler. */
4378 handle_unused_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4379 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4385 if (TREE_CODE (decl
) == PARM_DECL
4386 || TREE_CODE (decl
) == VAR_DECL
4387 || TREE_CODE (decl
) == FUNCTION_DECL
4388 || TREE_CODE (decl
) == LABEL_DECL
4389 || TREE_CODE (decl
) == TYPE_DECL
)
4390 TREE_USED (decl
) = 1;
4393 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4394 *no_add_attrs
= true;
4399 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4400 *node
= build_type_copy (*node
);
4401 TREE_USED (*node
) = 1;
4407 /* Handle a "const" attribute; arguments as in
4408 struct attribute_spec.handler. */
4411 handle_const_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4412 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4414 tree type
= TREE_TYPE (*node
);
4416 /* See FIXME comment on noreturn in c_common_attribute_table. */
4417 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4418 TREE_READONLY (*node
) = 1;
4419 else if (TREE_CODE (type
) == POINTER_TYPE
4420 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4422 = build_pointer_type
4423 (build_type_variant (TREE_TYPE (type
), 1,
4424 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
4427 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4428 *no_add_attrs
= true;
4434 /* Handle a "transparent_union" attribute; arguments as in
4435 struct attribute_spec.handler. */
4438 handle_transparent_union_attribute (tree
*node
, tree name
,
4439 tree args ATTRIBUTE_UNUSED
, int flags
,
4442 tree decl
= NULL_TREE
;
4449 type
= &TREE_TYPE (decl
);
4450 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
4452 else if (TYPE_P (*node
))
4453 type
= node
, is_type
= 1;
4456 && TREE_CODE (*type
) == UNION_TYPE
4458 || (TYPE_FIELDS (*type
) != 0
4459 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))))
4461 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4462 *type
= build_type_copy (*type
);
4463 TYPE_TRANSPARENT_UNION (*type
) = 1;
4465 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
4466 && TREE_CODE (*type
) == UNION_TYPE
4467 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))
4468 DECL_TRANSPARENT_UNION (decl
) = 1;
4471 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4472 *no_add_attrs
= true;
4478 /* Handle a "constructor" attribute; arguments as in
4479 struct attribute_spec.handler. */
4482 handle_constructor_attribute (tree
*node
, tree name
,
4483 tree args ATTRIBUTE_UNUSED
,
4484 int flags ATTRIBUTE_UNUSED
,
4488 tree type
= TREE_TYPE (decl
);
4490 if (TREE_CODE (decl
) == FUNCTION_DECL
4491 && TREE_CODE (type
) == FUNCTION_TYPE
4492 && decl_function_context (decl
) == 0)
4494 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
4495 TREE_USED (decl
) = 1;
4499 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4500 *no_add_attrs
= true;
4506 /* Handle a "destructor" attribute; arguments as in
4507 struct attribute_spec.handler. */
4510 handle_destructor_attribute (tree
*node
, tree name
,
4511 tree args ATTRIBUTE_UNUSED
,
4512 int flags ATTRIBUTE_UNUSED
,
4516 tree type
= TREE_TYPE (decl
);
4518 if (TREE_CODE (decl
) == FUNCTION_DECL
4519 && TREE_CODE (type
) == FUNCTION_TYPE
4520 && decl_function_context (decl
) == 0)
4522 DECL_STATIC_DESTRUCTOR (decl
) = 1;
4523 TREE_USED (decl
) = 1;
4527 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4528 *no_add_attrs
= true;
4534 /* Handle a "mode" attribute; arguments as in
4535 struct attribute_spec.handler. */
4538 handle_mode_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4539 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4543 *no_add_attrs
= true;
4545 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
4546 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4550 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
4551 int len
= strlen (p
);
4552 enum machine_mode mode
= VOIDmode
;
4556 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
4557 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
4559 char *newp
= alloca (len
- 1);
4561 strcpy (newp
, &p
[2]);
4562 newp
[len
- 4] = '\0';
4566 /* Change this type to have a type with the specified mode.
4567 First check for the special modes. */
4568 if (! strcmp (p
, "byte"))
4570 else if (!strcmp (p
, "word"))
4572 else if (! strcmp (p
, "pointer"))
4575 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
4576 if (!strcmp (p
, GET_MODE_NAME (j
)))
4577 mode
= (enum machine_mode
) j
;
4579 if (mode
== VOIDmode
)
4581 error ("unknown machine mode `%s'", p
);
4585 if (VECTOR_MODE_P (mode
))
4587 warning ("specifying vector types with __attribute__ ((mode)) "
4589 warning ("use __attribute__ ((vector_size)) instead");
4592 typefm
= lang_hooks
.types
.type_for_mode (mode
, TYPE_UNSIGNED (type
));
4593 if (typefm
== NULL_TREE
)
4594 error ("no data type for mode `%s'", p
);
4596 else if ((TREE_CODE (type
) == POINTER_TYPE
4597 || TREE_CODE (type
) == REFERENCE_TYPE
)
4598 && !targetm
.valid_pointer_mode (mode
))
4599 error ("invalid pointer mode `%s'", p
);
4602 /* If this is a vector, make sure we either have hardware
4603 support, or we can emulate it. */
4604 if (VECTOR_MODE_P (mode
) && !vector_mode_valid_p (mode
))
4606 error ("unable to emulate '%s'", GET_MODE_NAME (mode
));
4610 if (TREE_CODE (type
) == POINTER_TYPE
)
4612 ptr_type
= build_pointer_type_for_mode (TREE_TYPE (type
),
4616 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
4618 ptr_type
= build_reference_type_for_mode (TREE_TYPE (type
),
4624 /* No need to layout the type here. The caller should do this. */
4631 /* Handle a "section" attribute; arguments as in
4632 struct attribute_spec.handler. */
4635 handle_section_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
, tree args
,
4636 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4640 if (targetm
.have_named_sections
)
4642 if ((TREE_CODE (decl
) == FUNCTION_DECL
4643 || TREE_CODE (decl
) == VAR_DECL
)
4644 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
4646 if (TREE_CODE (decl
) == VAR_DECL
4647 && current_function_decl
!= NULL_TREE
4648 && ! TREE_STATIC (decl
))
4650 error ("%Jsection attribute cannot be specified for "
4651 "local variables", decl
);
4652 *no_add_attrs
= true;
4655 /* The decl may have already been given a section attribute
4656 from a previous declaration. Ensure they match. */
4657 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
4658 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
4659 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
4661 error ("%Jsection of '%D' conflicts with previous declaration",
4663 *no_add_attrs
= true;
4666 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
4670 error ("%Jsection attribute not allowed for '%D'", *node
, *node
);
4671 *no_add_attrs
= true;
4676 error ("%Jsection attributes are not supported for this target", *node
);
4677 *no_add_attrs
= true;
4683 /* Handle a "aligned" attribute; arguments as in
4684 struct attribute_spec.handler. */
4687 handle_aligned_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
, tree args
,
4688 int flags
, bool *no_add_attrs
)
4690 tree decl
= NULL_TREE
;
4693 tree align_expr
= (args
? TREE_VALUE (args
)
4694 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
4700 type
= &TREE_TYPE (decl
);
4701 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
4703 else if (TYPE_P (*node
))
4704 type
= node
, is_type
= 1;
4706 /* Strip any NOPs of any kind. */
4707 while (TREE_CODE (align_expr
) == NOP_EXPR
4708 || TREE_CODE (align_expr
) == CONVERT_EXPR
4709 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
4710 align_expr
= TREE_OPERAND (align_expr
, 0);
4712 if (TREE_CODE (align_expr
) != INTEGER_CST
)
4714 error ("requested alignment is not a constant");
4715 *no_add_attrs
= true;
4717 else if ((i
= tree_log2 (align_expr
)) == -1)
4719 error ("requested alignment is not a power of 2");
4720 *no_add_attrs
= true;
4722 else if (i
> HOST_BITS_PER_INT
- 2)
4724 error ("requested alignment is too large");
4725 *no_add_attrs
= true;
4729 /* If we have a TYPE_DECL, then copy the type, so that we
4730 don't accidentally modify a builtin type. See pushdecl. */
4731 if (decl
&& TREE_TYPE (decl
) != error_mark_node
4732 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
4734 tree tt
= TREE_TYPE (decl
);
4735 *type
= build_type_copy (*type
);
4736 DECL_ORIGINAL_TYPE (decl
) = tt
;
4737 TYPE_NAME (*type
) = decl
;
4738 TREE_USED (*type
) = TREE_USED (decl
);
4739 TREE_TYPE (decl
) = *type
;
4741 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4742 *type
= build_type_copy (*type
);
4744 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
4745 TYPE_USER_ALIGN (*type
) = 1;
4747 else if (TREE_CODE (decl
) != VAR_DECL
4748 && TREE_CODE (decl
) != FIELD_DECL
)
4750 error ("%Jalignment may not be specified for '%D'", decl
, decl
);
4751 *no_add_attrs
= true;
4755 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
4756 DECL_USER_ALIGN (decl
) = 1;
4762 /* Handle a "weak" attribute; arguments as in
4763 struct attribute_spec.handler. */
4766 handle_weak_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
,
4767 tree args ATTRIBUTE_UNUSED
,
4768 int flags ATTRIBUTE_UNUSED
,
4769 bool *no_add_attrs ATTRIBUTE_UNUSED
)
4771 declare_weak (*node
);
4776 /* Handle an "alias" attribute; arguments as in
4777 struct attribute_spec.handler. */
4780 handle_alias_attribute (tree
*node
, tree name
, tree args
,
4781 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4785 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
4786 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
4788 error ("%J'%D' defined both normally and as an alias", decl
, decl
);
4789 *no_add_attrs
= true;
4792 /* Note that the very first time we process a nested declaration,
4793 decl_function_context will not be set. Indeed, *would* never
4794 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4795 we do below. After such frobbery, pushdecl would set the context.
4796 In any case, this is never what we want. */
4797 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
4801 id
= TREE_VALUE (args
);
4802 if (TREE_CODE (id
) != STRING_CST
)
4804 error ("alias arg not a string");
4805 *no_add_attrs
= true;
4808 id
= get_identifier (TREE_STRING_POINTER (id
));
4809 /* This counts as a use of the object pointed to. */
4812 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4813 DECL_INITIAL (decl
) = error_mark_node
;
4816 DECL_EXTERNAL (decl
) = 0;
4817 TREE_STATIC (decl
) = 1;
4822 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4823 *no_add_attrs
= true;
4829 /* Handle an "visibility" attribute; arguments as in
4830 struct attribute_spec.handler. */
4833 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
4834 int flags ATTRIBUTE_UNUSED
,
4838 tree id
= TREE_VALUE (args
);
4840 *no_add_attrs
= true;
4842 if (decl_function_context (decl
) != 0 || ! TREE_PUBLIC (decl
))
4844 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4848 if (TREE_CODE (id
) != STRING_CST
)
4850 error ("visibility arg not a string");
4854 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
4855 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4856 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
4857 DECL_VISIBILITY (decl
) = VISIBILITY_INTERNAL
;
4858 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
4859 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
4860 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
4861 DECL_VISIBILITY (decl
) = VISIBILITY_PROTECTED
;
4863 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4868 /* Handle an "tls_model" attribute; arguments as in
4869 struct attribute_spec.handler. */
4872 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
4873 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4877 if (! DECL_THREAD_LOCAL (decl
))
4879 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4880 *no_add_attrs
= true;
4886 id
= TREE_VALUE (args
);
4887 if (TREE_CODE (id
) != STRING_CST
)
4889 error ("tls_model arg not a string");
4890 *no_add_attrs
= true;
4893 if (strcmp (TREE_STRING_POINTER (id
), "local-exec")
4894 && strcmp (TREE_STRING_POINTER (id
), "initial-exec")
4895 && strcmp (TREE_STRING_POINTER (id
), "local-dynamic")
4896 && strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
4898 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4899 *no_add_attrs
= true;
4907 /* Handle a "no_instrument_function" attribute; arguments as in
4908 struct attribute_spec.handler. */
4911 handle_no_instrument_function_attribute (tree
*node
, tree name
,
4912 tree args ATTRIBUTE_UNUSED
,
4913 int flags ATTRIBUTE_UNUSED
,
4918 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4920 error ("%J'%E' attribute applies only to functions", decl
, name
);
4921 *no_add_attrs
= true;
4923 else if (DECL_INITIAL (decl
))
4925 error ("%Jcan't set '%E' attribute after definition", decl
, name
);
4926 *no_add_attrs
= true;
4929 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
4934 /* Handle a "malloc" attribute; arguments as in
4935 struct attribute_spec.handler. */
4938 handle_malloc_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4939 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4941 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4942 DECL_IS_MALLOC (*node
) = 1;
4943 /* ??? TODO: Support types. */
4946 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4947 *no_add_attrs
= true;
4953 /* Handle a "no_limit_stack" attribute; arguments as in
4954 struct attribute_spec.handler. */
4957 handle_no_limit_stack_attribute (tree
*node
, tree name
,
4958 tree args ATTRIBUTE_UNUSED
,
4959 int flags ATTRIBUTE_UNUSED
,
4964 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4966 error ("%J'%E' attribute applies only to functions", decl
, name
);
4967 *no_add_attrs
= true;
4969 else if (DECL_INITIAL (decl
))
4971 error ("%Jcan't set '%E' attribute after definition", decl
, name
);
4972 *no_add_attrs
= true;
4975 DECL_NO_LIMIT_STACK (decl
) = 1;
4980 /* Handle a "pure" attribute; arguments as in
4981 struct attribute_spec.handler. */
4984 handle_pure_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
4985 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
4987 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4988 DECL_IS_PURE (*node
) = 1;
4989 /* ??? TODO: Support types. */
4992 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4993 *no_add_attrs
= true;
4999 /* Handle a "deprecated" attribute; arguments as in
5000 struct attribute_spec.handler. */
5003 handle_deprecated_attribute (tree
*node
, tree name
,
5004 tree args ATTRIBUTE_UNUSED
, int flags
,
5007 tree type
= NULL_TREE
;
5009 const char *what
= NULL
;
5014 type
= TREE_TYPE (decl
);
5016 if (TREE_CODE (decl
) == TYPE_DECL
5017 || TREE_CODE (decl
) == PARM_DECL
5018 || TREE_CODE (decl
) == VAR_DECL
5019 || TREE_CODE (decl
) == FUNCTION_DECL
5020 || TREE_CODE (decl
) == FIELD_DECL
)
5021 TREE_DEPRECATED (decl
) = 1;
5025 else if (TYPE_P (*node
))
5027 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5028 *node
= build_type_copy (*node
);
5029 TREE_DEPRECATED (*node
) = 1;
5037 *no_add_attrs
= true;
5038 if (type
&& TYPE_NAME (type
))
5040 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
5041 what
= IDENTIFIER_POINTER (TYPE_NAME (*node
));
5042 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
5043 && DECL_NAME (TYPE_NAME (type
)))
5044 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
5047 warning ("`%s' attribute ignored for `%s'",
5048 IDENTIFIER_POINTER (name
), what
);
5050 warning ("`%s' attribute ignored",
5051 IDENTIFIER_POINTER (name
));
5057 /* Handle a "vector_size" attribute; arguments as in
5058 struct attribute_spec.handler. */
5061 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
5062 int flags ATTRIBUTE_UNUSED
,
5065 unsigned HOST_WIDE_INT vecsize
, nunits
;
5066 enum machine_mode mode
, orig_mode
, new_mode
;
5067 tree type
= *node
, new_type
, size
;
5069 *no_add_attrs
= true;
5071 /* Stripping NON_LVALUE_EXPR allows declarations such as
5072 typedef short v4si __attribute__((vector_size (4 * sizeof(short)))). */
5073 size
= TREE_VALUE (args
);
5074 if (TREE_CODE (size
) == NON_LVALUE_EXPR
)
5075 size
= TREE_OPERAND (size
, 0);
5077 if (! host_integerp (size
, 1))
5079 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5083 /* Get the vector size (in bytes). */
5084 vecsize
= tree_low_cst (size
, 1);
5086 /* We need to provide for vector pointers, vector arrays, and
5087 functions returning vectors. For example:
5089 __attribute__((vector_size(16))) short *foo;
5091 In this case, the mode is SI, but the type being modified is
5092 HI, so we need to look further. */
5094 while (POINTER_TYPE_P (type
)
5095 || TREE_CODE (type
) == FUNCTION_TYPE
5096 || TREE_CODE (type
) == METHOD_TYPE
5097 || TREE_CODE (type
) == ARRAY_TYPE
)
5098 type
= TREE_TYPE (type
);
5100 /* Get the mode of the type being modified. */
5101 orig_mode
= TYPE_MODE (type
);
5103 if (TREE_CODE (type
) == RECORD_TYPE
5104 || (GET_MODE_CLASS (orig_mode
) != MODE_FLOAT
5105 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
5106 || ! host_integerp (TYPE_SIZE_UNIT (type
), 1))
5108 error ("invalid vector type for attribute `%s'",
5109 IDENTIFIER_POINTER (name
));
5113 /* Calculate how many units fit in the vector. */
5114 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5116 /* Find a suitably sized vector. */
5117 new_mode
= VOIDmode
;
5118 for (mode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode
) == MODE_INT
5120 : MODE_VECTOR_FLOAT
);
5122 mode
= GET_MODE_WIDER_MODE (mode
))
5123 if (vecsize
== GET_MODE_SIZE (mode
)
5124 && nunits
== (unsigned HOST_WIDE_INT
) GET_MODE_NUNITS (mode
))
5130 if (new_mode
== VOIDmode
)
5132 error ("no vector mode with the size and type specified could be found");
5136 new_type
= build_vector_type_for_mode (type
, new_mode
);
5138 /* Build back pointers if needed. */
5139 *node
= reconstruct_complex_type (*node
, new_type
);
5144 /* Handle the "nonnull" attribute. */
5146 handle_nonnull_attribute (tree
*node
, tree name ATTRIBUTE_UNUSED
,
5147 tree args
, int flags ATTRIBUTE_UNUSED
,
5151 unsigned HOST_WIDE_INT attr_arg_num
;
5153 /* If no arguments are specified, all pointer arguments should be
5154 non-null. Verify a full prototype is given so that the arguments
5155 will have the correct types when we actually check them later. */
5158 if (! TYPE_ARG_TYPES (type
))
5160 error ("nonnull attribute without arguments on a non-prototype");
5161 *no_add_attrs
= true;
5166 /* Argument list specified. Verify that each argument number references
5167 a pointer argument. */
5168 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
5171 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
5173 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5175 error ("nonnull argument has invalid operand number (arg %lu)",
5176 (unsigned long) attr_arg_num
);
5177 *no_add_attrs
= true;
5181 argument
= TYPE_ARG_TYPES (type
);
5184 for (ck_num
= 1; ; ck_num
++)
5186 if (! argument
|| ck_num
== arg_num
)
5188 argument
= TREE_CHAIN (argument
);
5192 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
5194 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5195 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5196 *no_add_attrs
= true;
5200 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
5202 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5203 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
5204 *no_add_attrs
= true;
5213 /* Check the argument list of a function call for null in argument slots
5214 that are marked as requiring a non-null pointer argument. */
5217 check_function_nonnull (tree attrs
, tree params
)
5219 tree a
, args
, param
;
5222 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
5224 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
5226 args
= TREE_VALUE (a
);
5228 /* Walk the argument list. If we encounter an argument number we
5229 should check for non-null, do it. If the attribute has no args,
5230 then every pointer argument is checked (in which case the check
5231 for pointer type is done in check_nonnull_arg). */
5232 for (param
= params
, param_num
= 1; ;
5233 param_num
++, param
= TREE_CHAIN (param
))
5237 if (! args
|| nonnull_check_p (args
, param_num
))
5238 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
5246 /* Helper for check_function_nonnull; given a list of operands which
5247 must be non-null in ARGS, determine if operand PARAM_NUM should be
5251 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
5253 unsigned HOST_WIDE_INT arg_num
= 0;
5255 for (; args
; args
= TREE_CHAIN (args
))
5257 if (! get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
5260 if (arg_num
== param_num
)
5266 /* Check that the function argument PARAM (which is operand number
5267 PARAM_NUM) is non-null. This is called by check_function_nonnull
5268 via check_function_arguments_recurse. */
5271 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED
, tree param
,
5272 unsigned HOST_WIDE_INT param_num
)
5274 /* Just skip checking the argument if it's not a pointer. This can
5275 happen if the "nonnull" attribute was given without an operand
5276 list (which means to check every pointer argument). */
5278 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
5281 if (integer_zerop (param
))
5282 warning ("null argument where non-null required (arg %lu)",
5283 (unsigned long) param_num
);
5286 /* Helper for nonnull attribute handling; fetch the operand number
5287 from the attribute argument list. */
5290 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
5292 /* Strip any conversions from the arg number and verify they
5294 while (TREE_CODE (arg_num_expr
) == NOP_EXPR
5295 || TREE_CODE (arg_num_expr
) == CONVERT_EXPR
5296 || TREE_CODE (arg_num_expr
) == NON_LVALUE_EXPR
)
5297 arg_num_expr
= TREE_OPERAND (arg_num_expr
, 0);
5299 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
5300 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
5303 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
5307 /* Handle a "nothrow" attribute; arguments as in
5308 struct attribute_spec.handler. */
5311 handle_nothrow_attribute (tree
*node
, tree name
, tree args ATTRIBUTE_UNUSED
,
5312 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5314 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5315 TREE_NOTHROW (*node
) = 1;
5316 /* ??? TODO: Support types. */
5319 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5320 *no_add_attrs
= true;
5326 /* Handle a "cleanup" attribute; arguments as in
5327 struct attribute_spec.handler. */
5330 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
5331 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5334 tree cleanup_id
, cleanup_decl
;
5336 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5337 for global destructors in C++. This requires infrastructure that
5338 we don't have generically at the moment. It's also not a feature
5339 we'd be missing too much, since we do have attribute constructor. */
5340 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
5342 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5343 *no_add_attrs
= true;
5347 /* Verify that the argument is a function in scope. */
5348 /* ??? We could support pointers to functions here as well, if
5349 that was considered desirable. */
5350 cleanup_id
= TREE_VALUE (args
);
5351 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
5353 error ("cleanup arg not an identifier");
5354 *no_add_attrs
= true;
5357 cleanup_decl
= lookup_name (cleanup_id
);
5358 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
5360 error ("cleanup arg not a function");
5361 *no_add_attrs
= true;
5365 /* That the function has proper type is checked with the
5366 eventual call to build_function_call. */
5371 /* Handle a "warn_unused_result" attribute. No special handling. */
5374 handle_warn_unused_result_attribute (tree
*node
, tree name
,
5375 tree args ATTRIBUTE_UNUSED
,
5376 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5378 /* Ignore the attribute for functions not returning any value. */
5379 if (VOID_TYPE_P (TREE_TYPE (*node
)))
5381 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5382 *no_add_attrs
= true;
5388 /* Check for valid arguments being passed to a function. */
5390 check_function_arguments (tree attrs
, tree params
)
5392 /* Check for null being passed in a pointer argument that must be
5393 non-null. We also need to do this if format checking is enabled. */
5396 check_function_nonnull (attrs
, params
);
5398 /* Check for errors in format strings. */
5401 check_function_format (NULL
, attrs
, params
);
5404 /* Generic argument checking recursion routine. PARAM is the argument to
5405 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5406 once the argument is resolved. CTX is context for the callback. */
5408 check_function_arguments_recurse (void (*callback
)
5409 (void *, tree
, unsigned HOST_WIDE_INT
),
5410 void *ctx
, tree param
,
5411 unsigned HOST_WIDE_INT param_num
)
5413 if (TREE_CODE (param
) == NOP_EXPR
)
5415 /* Strip coercion. */
5416 check_function_arguments_recurse (callback
, ctx
,
5417 TREE_OPERAND (param
, 0), param_num
);
5421 if (TREE_CODE (param
) == CALL_EXPR
)
5423 tree type
= TREE_TYPE (TREE_TYPE (TREE_OPERAND (param
, 0)));
5425 bool found_format_arg
= false;
5427 /* See if this is a call to a known internationalization function
5428 that modifies a format arg. Such a function may have multiple
5429 format_arg attributes (for example, ngettext). */
5431 for (attrs
= TYPE_ATTRIBUTES (type
);
5433 attrs
= TREE_CHAIN (attrs
))
5434 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
5437 tree format_num_expr
;
5441 /* Extract the argument number, which was previously checked
5443 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
5444 while (TREE_CODE (format_num_expr
) == NOP_EXPR
5445 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
5446 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
5447 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
5449 if (TREE_CODE (format_num_expr
) != INTEGER_CST
5450 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
5453 format_num
= TREE_INT_CST_LOW (format_num_expr
);
5455 for (inner_args
= TREE_OPERAND (param
, 1), i
= 1;
5457 inner_args
= TREE_CHAIN (inner_args
), i
++)
5458 if (i
== format_num
)
5460 check_function_arguments_recurse (callback
, ctx
,
5461 TREE_VALUE (inner_args
),
5463 found_format_arg
= true;
5468 /* If we found a format_arg attribute and did a recursive check,
5469 we are done with checking this argument. Otherwise, we continue
5470 and this will be considered a non-literal. */
5471 if (found_format_arg
)
5475 if (TREE_CODE (param
) == COND_EXPR
)
5477 /* Check both halves of the conditional expression. */
5478 check_function_arguments_recurse (callback
, ctx
,
5479 TREE_OPERAND (param
, 1), param_num
);
5480 check_function_arguments_recurse (callback
, ctx
,
5481 TREE_OPERAND (param
, 2), param_num
);
5485 (*callback
) (ctx
, param
, param_num
);
5488 /* C implementation of lang_hooks.tree_inlining.walk_subtrees. Tracks the
5489 locus from EXPR_LOCUS and handles DECL_STMT specially. */
5492 c_walk_subtrees (tree
*tp
, int *walk_subtrees_p ATTRIBUTE_UNUSED
,
5493 walk_tree_fn func
, void *data
, void *htab
)
5495 enum tree_code code
= TREE_CODE (*tp
);
5496 location_t save_locus
;
5499 #define WALK_SUBTREE(NODE) \
5502 result = walk_tree (&(NODE), func, data, htab); \
5503 if (result) goto out; \
5507 if (code
!= DECL_STMT
)
5510 /* Set input_location here so we get the right instantiation context
5511 if we call instantiate_decl from inlinable_function_p. */
5512 save_locus
= input_location
;
5513 if (EXPR_LOCUS (*tp
))
5514 input_location
= *EXPR_LOCUS (*tp
);
5516 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
5517 into declarations that are just mentioned, rather than
5518 declared; they don't really belong to this part of the tree.
5519 And, we can see cycles: the initializer for a declaration can
5520 refer to the declaration itself. */
5521 WALK_SUBTREE (DECL_INITIAL (DECL_STMT_DECL (*tp
)));
5522 WALK_SUBTREE (DECL_SIZE (DECL_STMT_DECL (*tp
)));
5523 WALK_SUBTREE (DECL_SIZE_UNIT (DECL_STMT_DECL (*tp
)));
5524 WALK_SUBTREE (TREE_CHAIN (*tp
));
5525 *walk_subtrees_p
= 0;
5527 /* We didn't find what we were looking for. */
5529 input_location
= save_locus
;
5535 /* Function to help qsort sort FIELD_DECLs by name order. */
5538 field_decl_cmp (const void *x_p
, const void *y_p
)
5540 const tree
*const x
= x_p
;
5541 const tree
*const y
= y_p
;
5542 if (DECL_NAME (*x
) == DECL_NAME (*y
))
5543 /* A nontype is "greater" than a type. */
5544 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
5545 if (DECL_NAME (*x
) == NULL_TREE
)
5547 if (DECL_NAME (*y
) == NULL_TREE
)
5549 if (DECL_NAME (*x
) < DECL_NAME (*y
))
5555 gt_pointer_operator new_value
;
5559 /* This routine compares two fields like field_decl_cmp but using the
5560 pointer operator in resort_data. */
5563 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
5565 const tree
*const x
= x_p
;
5566 const tree
*const y
= y_p
;
5568 if (DECL_NAME (*x
) == DECL_NAME (*y
))
5569 /* A nontype is "greater" than a type. */
5570 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
5571 if (DECL_NAME (*x
) == NULL_TREE
)
5573 if (DECL_NAME (*y
) == NULL_TREE
)
5576 tree d1
= DECL_NAME (*x
);
5577 tree d2
= DECL_NAME (*y
);
5578 resort_data
.new_value (&d1
, resort_data
.cookie
);
5579 resort_data
.new_value (&d2
, resort_data
.cookie
);
5586 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5589 resort_sorted_fields (void *obj
,
5590 void *orig_obj ATTRIBUTE_UNUSED
,
5591 gt_pointer_operator new_value
,
5594 struct sorted_fields_type
*sf
= obj
;
5595 resort_data
.new_value
= new_value
;
5596 resort_data
.cookie
= cookie
;
5597 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
5598 resort_field_decl_cmp
);
5601 /* Issue the error given by MSGID, indicating that it occurred before
5602 TOKEN, which had the associated VALUE. */
5605 c_parse_error (const char *msgid
, enum cpp_ttype token
, tree value
)
5607 const char *string
= _(msgid
);
5609 if (token
== CPP_EOF
)
5610 error ("%s at end of input", string
);
5611 else if (token
== CPP_CHAR
|| token
== CPP_WCHAR
)
5613 unsigned int val
= TREE_INT_CST_LOW (value
);
5614 const char *const ell
= (token
== CPP_CHAR
) ? "" : "L";
5615 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
5616 error ("%s before %s'%c'", string
, ell
, val
);
5618 error ("%s before %s'\\x%x'", string
, ell
, val
);
5620 else if (token
== CPP_STRING
5621 || token
== CPP_WSTRING
)
5622 error ("%s before string constant", string
);
5623 else if (token
== CPP_NUMBER
)
5624 error ("%s before numeric constant", string
);
5625 else if (token
== CPP_NAME
)
5626 error ("%s before \"%s\"", string
, IDENTIFIER_POINTER (value
));
5627 else if (token
< N_TTYPES
)
5628 error ("%s before '%s' token", string
, cpp_type2name (token
));
5630 error ("%s", string
);
5633 /* Walk a gimplified function and warn for functions whose return value is
5634 ignored and attribute((warn_unused_result)) is set. This is done before
5635 inlining, so we don't have to worry about that. */
5638 c_warn_unused_result (tree
*top_p
)
5641 tree_stmt_iterator i
;
5644 switch (TREE_CODE (t
))
5646 case STATEMENT_LIST
:
5647 for (i
= tsi_start (*top_p
); !tsi_end_p (i
); tsi_next (&i
))
5648 c_warn_unused_result (tsi_stmt_ptr (i
));
5652 c_warn_unused_result (&COND_EXPR_THEN (t
));
5653 c_warn_unused_result (&COND_EXPR_ELSE (t
));
5656 c_warn_unused_result (&BIND_EXPR_BODY (t
));
5658 case TRY_FINALLY_EXPR
:
5659 case TRY_CATCH_EXPR
:
5660 c_warn_unused_result (&TREE_OPERAND (t
, 0));
5661 c_warn_unused_result (&TREE_OPERAND (t
, 1));
5664 c_warn_unused_result (&CATCH_BODY (t
));
5666 case EH_FILTER_EXPR
:
5667 c_warn_unused_result (&EH_FILTER_FAILURE (t
));
5671 /* This is a naked call, as opposed to a CALL_EXPR nested inside
5672 a MODIFY_EXPR. All calls whose value is ignored should be
5673 represented like this. Look for the attribute. */
5674 fdecl
= get_callee_fndecl (t
);
5676 ftype
= TREE_TYPE (fdecl
);
5679 ftype
= TREE_TYPE (TREE_OPERAND (t
, 0));
5680 /* Look past pointer-to-function to the function type itself. */
5681 ftype
= TREE_TYPE (ftype
);
5684 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
5687 warning ("%Hignoring return value of `%D', "
5688 "declared with attribute warn_unused_result",
5689 EXPR_LOCUS (t
), fdecl
);
5691 warning ("%Hignoring return value of function "
5692 "declared with attribute warn_unused_result",
5698 /* Not a container, not a call, or a call whose value is used. */
5703 #include "gt-c-common.h"