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, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
40 #include "langhooks.h"
41 #include "tree-inline.h"
44 #include "diagnostic.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
51 #include "target-def.h"
53 #include "fixed-value.h"
56 cpp_reader *parse_in; /* Declared in c-pragma.h. */
58 /* We let tm.h override the types used here, to handle trivial differences
59 such as the choice of unsigned int or long unsigned int for size_t.
60 When machines start needing nontrivial differences in the size type,
61 it would be best to do something here to figure out automatically
62 from other information what type to use. */
65 #define SIZE_TYPE "long unsigned int"
69 #define PID_TYPE "int"
72 /* If GCC knows the exact uint_least16_t and uint_least32_t types from
73 <stdint.h>, use them for char16_t and char32_t. Otherwise, use
74 these guesses; getting the wrong type of a given width will not
75 affect C++ name mangling because in C++ these are distinct types
78 #ifdef UINT_LEAST16_TYPE
79 #define CHAR16_TYPE UINT_LEAST16_TYPE
81 #define CHAR16_TYPE "short unsigned int"
84 #ifdef UINT_LEAST32_TYPE
85 #define CHAR32_TYPE UINT_LEAST32_TYPE
87 #define CHAR32_TYPE "unsigned int"
91 #define WCHAR_TYPE "int"
94 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
95 #define MODIFIED_WCHAR_TYPE \
96 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
99 #define PTRDIFF_TYPE "long int"
103 #define WINT_TYPE "unsigned int"
107 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
109 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
115 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
117 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
118 ? "long unsigned int" \
119 : "long long unsigned int"))
122 /* There are no default definitions of these <stdint.h> types. */
124 #ifndef SIG_ATOMIC_TYPE
125 #define SIG_ATOMIC_TYPE ((const char *) NULL)
129 #define INT8_TYPE ((const char *) NULL)
133 #define INT16_TYPE ((const char *) NULL)
137 #define INT32_TYPE ((const char *) NULL)
141 #define INT64_TYPE ((const char *) NULL)
145 #define UINT8_TYPE ((const char *) NULL)
149 #define UINT16_TYPE ((const char *) NULL)
153 #define UINT32_TYPE ((const char *) NULL)
157 #define UINT64_TYPE ((const char *) NULL)
160 #ifndef INT_LEAST8_TYPE
161 #define INT_LEAST8_TYPE ((const char *) NULL)
164 #ifndef INT_LEAST16_TYPE
165 #define INT_LEAST16_TYPE ((const char *) NULL)
168 #ifndef INT_LEAST32_TYPE
169 #define INT_LEAST32_TYPE ((const char *) NULL)
172 #ifndef INT_LEAST64_TYPE
173 #define INT_LEAST64_TYPE ((const char *) NULL)
176 #ifndef UINT_LEAST8_TYPE
177 #define UINT_LEAST8_TYPE ((const char *) NULL)
180 #ifndef UINT_LEAST16_TYPE
181 #define UINT_LEAST16_TYPE ((const char *) NULL)
184 #ifndef UINT_LEAST32_TYPE
185 #define UINT_LEAST32_TYPE ((const char *) NULL)
188 #ifndef UINT_LEAST64_TYPE
189 #define UINT_LEAST64_TYPE ((const char *) NULL)
192 #ifndef INT_FAST8_TYPE
193 #define INT_FAST8_TYPE ((const char *) NULL)
196 #ifndef INT_FAST16_TYPE
197 #define INT_FAST16_TYPE ((const char *) NULL)
200 #ifndef INT_FAST32_TYPE
201 #define INT_FAST32_TYPE ((const char *) NULL)
204 #ifndef INT_FAST64_TYPE
205 #define INT_FAST64_TYPE ((const char *) NULL)
208 #ifndef UINT_FAST8_TYPE
209 #define UINT_FAST8_TYPE ((const char *) NULL)
212 #ifndef UINT_FAST16_TYPE
213 #define UINT_FAST16_TYPE ((const char *) NULL)
216 #ifndef UINT_FAST32_TYPE
217 #define UINT_FAST32_TYPE ((const char *) NULL)
220 #ifndef UINT_FAST64_TYPE
221 #define UINT_FAST64_TYPE ((const char *) NULL)
225 #define INTPTR_TYPE ((const char *) NULL)
229 #define UINTPTR_TYPE ((const char *) NULL)
232 /* The following symbols are subsumed in the c_global_trees array, and
233 listed here individually for documentation purposes.
235 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
237 tree short_integer_type_node;
238 tree long_integer_type_node;
239 tree long_long_integer_type_node;
241 tree short_unsigned_type_node;
242 tree long_unsigned_type_node;
243 tree long_long_unsigned_type_node;
245 tree truthvalue_type_node;
246 tree truthvalue_false_node;
247 tree truthvalue_true_node;
249 tree ptrdiff_type_node;
251 tree unsigned_char_type_node;
252 tree signed_char_type_node;
253 tree wchar_type_node;
255 tree char16_type_node;
256 tree char32_type_node;
258 tree float_type_node;
259 tree double_type_node;
260 tree long_double_type_node;
262 tree complex_integer_type_node;
263 tree complex_float_type_node;
264 tree complex_double_type_node;
265 tree complex_long_double_type_node;
267 tree dfloat32_type_node;
268 tree dfloat64_type_node;
269 tree_dfloat128_type_node;
271 tree intQI_type_node;
272 tree intHI_type_node;
273 tree intSI_type_node;
274 tree intDI_type_node;
275 tree intTI_type_node;
277 tree unsigned_intQI_type_node;
278 tree unsigned_intHI_type_node;
279 tree unsigned_intSI_type_node;
280 tree unsigned_intDI_type_node;
281 tree unsigned_intTI_type_node;
283 tree widest_integer_literal_type_node;
284 tree widest_unsigned_literal_type_node;
286 Nodes for types `void *' and `const void *'.
288 tree ptr_type_node, const_ptr_type_node;
290 Nodes for types `char *' and `const char *'.
292 tree string_type_node, const_string_type_node;
294 Type `char[SOMENUMBER]'.
295 Used when an array of char is needed and the size is irrelevant.
297 tree char_array_type_node;
299 Type `int[SOMENUMBER]' or something like it.
300 Used when an array of int needed and the size is irrelevant.
302 tree int_array_type_node;
304 Type `wchar_t[SOMENUMBER]' or something like it.
305 Used when a wide string literal is created.
307 tree wchar_array_type_node;
309 Type `char16_t[SOMENUMBER]' or something like it.
310 Used when a UTF-16 string literal is created.
312 tree char16_array_type_node;
314 Type `char32_t[SOMENUMBER]' or something like it.
315 Used when a UTF-32 string literal is created.
317 tree char32_array_type_node;
319 Type `int ()' -- used for implicit declaration of functions.
321 tree default_function_type;
323 A VOID_TYPE node, packaged in a TREE_LIST.
327 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
328 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
329 VAR_DECLS, but C++ does.)
331 tree function_name_decl_node;
332 tree pretty_function_name_decl_node;
333 tree c99_function_name_decl_node;
335 Stack of nested function name VAR_DECLs.
337 tree saved_function_name_decls;
341 tree c_global_trees[CTI_MAX];
343 /* Switches common to the C front ends. */
345 /* Nonzero if preprocessing only. */
347 int flag_preprocess_only;
349 /* Nonzero means don't output line number information. */
351 char flag_no_line_commands;
353 /* Nonzero causes -E output not to be done, but directives such as
354 #define that have side effects are still obeyed. */
358 /* Nonzero means dump macros in some fashion. */
360 char flag_dump_macros;
362 /* Nonzero means pass #include lines through to the output. */
364 char flag_dump_includes;
366 /* Nonzero means process PCH files while preprocessing. */
368 bool flag_pch_preprocess;
370 /* The file name to which we should write a precompiled header, or
371 NULL if no header will be written in this compile. */
373 const char *pch_file;
375 /* Nonzero if an ISO standard was selected. It rejects macros in the
379 /* Nonzero if -undef was given. It suppresses target built-in macros
383 /* Nonzero means don't recognize the non-ANSI builtin functions. */
387 /* Nonzero means don't recognize the non-ANSI builtin functions.
390 int flag_no_nonansi_builtin;
392 /* Nonzero means give `double' the same size as `float'. */
394 int flag_short_double;
396 /* Nonzero means give `wchar_t' the same size as `short'. */
398 int flag_short_wchar;
400 /* Nonzero means allow implicit conversions between vectors with
401 differing numbers of subparts and/or differing element types. */
402 int flag_lax_vector_conversions;
404 /* Nonzero means allow Microsoft extensions without warnings or errors. */
405 int flag_ms_extensions;
407 /* Nonzero means don't recognize the keyword `asm'. */
411 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
413 int flag_signed_bitfields = 1;
415 /* Warn about #pragma directives that are not recognized. */
417 int warn_unknown_pragmas; /* Tri state variable. */
419 /* Warn about format/argument anomalies in calls to formatted I/O functions
420 (*printf, *scanf, strftime, strfmon, etc.). */
424 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
425 with GCC this doesn't matter as __null is guaranteed to have the right
428 int warn_strict_null_sentinel;
430 /* Zero means that faster, ...NonNil variants of objc_msgSend...
431 calls will be used in ObjC; passing nil receivers to such calls
432 will most likely result in crashes. */
433 int flag_nil_receivers = 1;
435 /* Nonzero means that code generation will be altered to support
436 "zero-link" execution. This currently affects ObjC only, but may
437 affect other languages in the future. */
438 int flag_zero_link = 0;
440 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
441 unit. It will inform the ObjC runtime that class definition(s) herein
442 contained are to replace one(s) previously loaded. */
443 int flag_replace_objc_classes = 0;
445 /* C/ObjC language option variables. */
448 /* Nonzero means allow type mismatches in conditional expressions;
449 just make their values `void'. */
451 int flag_cond_mismatch;
453 /* Nonzero means enable C89 Amendment 1 features. */
457 /* Nonzero means use the ISO C99 dialect of C. */
461 /* Nonzero means that we have builtin functions, and main is an int. */
466 /* ObjC language option variables. */
469 /* Open and close the file for outputting class declarations, if
472 int flag_gen_declaration;
474 /* Tells the compiler that this is a special run. Do not perform any
475 compiling, instead we are to test some platform dependent features
476 and output a C header file with appropriate definitions. */
478 int print_struct_values;
480 /* Tells the compiler what is the constant string class for ObjC. */
482 const char *constant_string_class_name;
485 /* C++ language option variables. */
488 /* Nonzero means don't recognize any extension keywords. */
490 int flag_no_gnu_keywords;
492 /* Nonzero means do emit exported implementations of functions even if
493 they can be inlined. */
495 int flag_implement_inlines = 1;
497 /* Nonzero means that implicit instantiations will be emitted if needed. */
499 int flag_implicit_templates = 1;
501 /* Nonzero means that implicit instantiations of inline templates will be
502 emitted if needed, even if instantiations of non-inline templates
505 int flag_implicit_inline_templates = 1;
507 /* Nonzero means generate separate instantiation control files and
508 juggle them at link time. */
510 int flag_use_repository;
512 /* Nonzero if we want to issue diagnostics that the standard says are not
515 int flag_optional_diags = 1;
517 /* Nonzero means we should attempt to elide constructors when possible. */
519 int flag_elide_constructors = 1;
521 /* Nonzero means that member functions defined in class scope are
522 inline by default. */
524 int flag_default_inline = 1;
526 /* Controls whether compiler generates 'type descriptor' that give
527 run-time type information. */
531 /* Nonzero if we want to conserve space in the .o files. We do this
532 by putting uninitialized data and runtime initialized data into
533 .common instead of .data at the expense of not flagging multiple
536 int flag_conserve_space;
538 /* Nonzero if we want to obey access control semantics. */
540 int flag_access_control = 1;
542 /* Nonzero if we want to check the return value of new and avoid calling
543 constructors if it is a null pointer. */
547 /* The C++ dialect being used. C++98 is the default. */
549 enum cxx_dialect cxx_dialect = cxx98;
551 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
552 initialization variables.
553 0: Old rules, set by -fno-for-scope.
554 2: New ISO rules, set by -ffor-scope.
555 1: Try to implement new ISO rules, but with backup compatibility
556 (and warnings). This is the default, for now. */
558 int flag_new_for_scope = 1;
560 /* Nonzero if we want to emit defined symbols with common-like linkage as
561 weak symbols where possible, in order to conform to C++ semantics.
562 Otherwise, emit them as local symbols. */
566 /* 0 means we want the preprocessor to not emit line directives for
567 the current working directory. 1 means we want it to do it. -1
568 means we should decide depending on whether debugging information
569 is being emitted or not. */
571 int flag_working_directory = -1;
573 /* Nonzero to use __cxa_atexit, rather than atexit, to register
574 destructors for local statics and global objects. '2' means it has been
575 set nonzero as a default, not by a command-line flag. */
577 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
579 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
580 code. '2' means it has not been set explicitly on the command line. */
582 int flag_use_cxa_get_exception_ptr = 2;
584 /* Nonzero means to implement standard semantics for exception
585 specifications, calling unexpected if an exception is thrown that
586 doesn't match the specification. Zero means to treat them as
587 assertions and optimize accordingly, but not check them. */
589 int flag_enforce_eh_specs = 1;
591 /* Nonzero means to generate thread-safe code for initializing local
594 int flag_threadsafe_statics = 1;
596 /* Nonzero if we want to pretty-print template specializations as the
597 template signature followed by the arguments. */
599 int flag_pretty_templates = 1;
601 /* Nonzero means warn about implicit declarations. */
603 int warn_implicit = 1;
605 /* Maximum template instantiation depth. This limit is rather
606 arbitrary, but it exists to limit the time it takes to notice
607 infinite template instantiations. */
609 int max_tinst_depth = 500;
613 /* The elements of `ridpointers' are identifier nodes for the reserved
614 type names and storage classes. It is indexed by a RID_... value. */
617 tree (*make_fname_decl) (tree, int);
619 /* Nonzero means the expression being parsed will never be evaluated.
620 This is a count, since unevaluated expressions can nest. */
623 /* Whether lexing has been completed, so subsequent preprocessor
624 errors should use the compiler's input_location. */
625 bool done_lexing = false;
627 /* Information about how a function name is generated. */
630 tree *const decl; /* pointer to the VAR_DECL. */
631 const unsigned rid; /* RID number for the identifier. */
632 const int pretty; /* How pretty is it? */
635 /* The three ways of getting then name of the current function. */
637 const struct fname_var_t fname_vars[] =
639 /* C99 compliant __func__, must be first. */
640 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
641 /* GCC __FUNCTION__ compliant. */
642 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
643 /* GCC __PRETTY_FUNCTION__ compliant. */
644 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
648 static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
649 static tree check_case_value (tree);
650 static bool check_case_bounds (tree, tree, tree *, tree *);
652 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
653 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
654 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
655 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
656 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
657 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
658 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
659 static tree handle_always_inline_attribute (tree *, tree, tree, int,
661 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
662 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
663 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
664 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
665 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
666 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
667 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
669 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
670 static tree handle_transparent_union_attribute (tree *, tree, tree,
672 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
673 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
674 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
675 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
676 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
677 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
678 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
679 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
680 static tree handle_visibility_attribute (tree *, tree, tree, int,
682 static tree handle_tls_model_attribute (tree *, tree, tree, int,
684 static tree handle_no_instrument_function_attribute (tree *, tree,
686 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
687 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
688 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
690 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
691 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
692 static tree handle_deprecated_attribute (tree *, tree, tree, int,
694 static tree handle_vector_size_attribute (tree *, tree, tree, int,
696 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
697 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
698 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
699 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
701 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
702 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
703 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
704 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
705 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
707 static void check_function_nonnull (tree, int, tree *);
708 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
709 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
710 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
711 static int resort_field_decl_cmp (const void *, const void *);
713 /* Reserved words. The third field is a mask: keywords are disabled
714 if they match the mask.
717 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
718 C --std=c99: D_CXXONLY | D_OBJC
719 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
720 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
721 C++ --std=c0x: D_CONLY | D_OBJC
722 ObjC++ is like C++ except that D_OBJC is not set
724 If -fno-asm is used, D_ASM is added to the mask. If
725 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
726 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
727 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
729 const struct c_common_resword c_common_reswords[] =
731 { "_Bool", RID_BOOL, D_CONLY },
732 { "_Complex", RID_COMPLEX, 0 },
733 { "_Imaginary", RID_IMAGINARY, D_CONLY },
734 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
735 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
736 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
737 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
738 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
739 { "_Sat", RID_SAT, D_CONLY | D_EXT },
740 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
741 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
742 { "__alignof", RID_ALIGNOF, 0 },
743 { "__alignof__", RID_ALIGNOF, 0 },
744 { "__asm", RID_ASM, 0 },
745 { "__asm__", RID_ASM, 0 },
746 { "__attribute", RID_ATTRIBUTE, 0 },
747 { "__attribute__", RID_ATTRIBUTE, 0 },
748 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
749 { "__builtin_offsetof", RID_OFFSETOF, 0 },
750 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
751 { "__builtin_va_arg", RID_VA_ARG, 0 },
752 { "__complex", RID_COMPLEX, 0 },
753 { "__complex__", RID_COMPLEX, 0 },
754 { "__const", RID_CONST, 0 },
755 { "__const__", RID_CONST, 0 },
756 { "__decltype", RID_DECLTYPE, D_CXXONLY },
757 { "__extension__", RID_EXTENSION, 0 },
758 { "__func__", RID_C99_FUNCTION_NAME, 0 },
759 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
760 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
761 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
762 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
763 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
764 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
765 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
766 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
767 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
768 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
769 { "__is_class", RID_IS_CLASS, D_CXXONLY },
770 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
771 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
772 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
773 { "__is_pod", RID_IS_POD, D_CXXONLY },
774 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
775 { "__is_union", RID_IS_UNION, D_CXXONLY },
776 { "__imag", RID_IMAGPART, 0 },
777 { "__imag__", RID_IMAGPART, 0 },
778 { "__inline", RID_INLINE, 0 },
779 { "__inline__", RID_INLINE, 0 },
780 { "__label__", RID_LABEL, 0 },
781 { "__null", RID_NULL, 0 },
782 { "__real", RID_REALPART, 0 },
783 { "__real__", RID_REALPART, 0 },
784 { "__restrict", RID_RESTRICT, 0 },
785 { "__restrict__", RID_RESTRICT, 0 },
786 { "__signed", RID_SIGNED, 0 },
787 { "__signed__", RID_SIGNED, 0 },
788 { "__thread", RID_THREAD, 0 },
789 { "__typeof", RID_TYPEOF, 0 },
790 { "__typeof__", RID_TYPEOF, 0 },
791 { "__volatile", RID_VOLATILE, 0 },
792 { "__volatile__", RID_VOLATILE, 0 },
793 { "asm", RID_ASM, D_ASM },
794 { "auto", RID_AUTO, 0 },
795 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
796 { "break", RID_BREAK, 0 },
797 { "case", RID_CASE, 0 },
798 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
799 { "char", RID_CHAR, 0 },
800 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
801 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
802 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
803 { "const", RID_CONST, 0 },
804 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
805 { "continue", RID_CONTINUE, 0 },
806 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
807 { "default", RID_DEFAULT, 0 },
808 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
810 { "double", RID_DOUBLE, 0 },
811 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
812 { "else", RID_ELSE, 0 },
813 { "enum", RID_ENUM, 0 },
814 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
815 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
816 { "extern", RID_EXTERN, 0 },
817 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
818 { "float", RID_FLOAT, 0 },
819 { "for", RID_FOR, 0 },
820 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
821 { "goto", RID_GOTO, 0 },
823 { "inline", RID_INLINE, D_EXT89 },
824 { "int", RID_INT, 0 },
825 { "long", RID_LONG, 0 },
826 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
827 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
828 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
829 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
830 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
831 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
832 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
833 { "register", RID_REGISTER, 0 },
834 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
835 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
836 { "return", RID_RETURN, 0 },
837 { "short", RID_SHORT, 0 },
838 { "signed", RID_SIGNED, 0 },
839 { "sizeof", RID_SIZEOF, 0 },
840 { "static", RID_STATIC, 0 },
841 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
842 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
843 { "struct", RID_STRUCT, 0 },
844 { "switch", RID_SWITCH, 0 },
845 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
846 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
847 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
848 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
849 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
850 { "typedef", RID_TYPEDEF, 0 },
851 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
852 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
853 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
854 { "union", RID_UNION, 0 },
855 { "unsigned", RID_UNSIGNED, 0 },
856 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
857 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
858 { "void", RID_VOID, 0 },
859 { "volatile", RID_VOLATILE, 0 },
860 { "wchar_t", RID_WCHAR, D_CXXONLY },
861 { "while", RID_WHILE, 0 },
862 /* These Objective-C keywords are recognized only immediately after
864 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
865 { "defs", RID_AT_DEFS, D_OBJC },
866 { "encode", RID_AT_ENCODE, D_OBJC },
867 { "end", RID_AT_END, D_OBJC },
868 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
869 { "interface", RID_AT_INTERFACE, D_OBJC },
870 { "protocol", RID_AT_PROTOCOL, D_OBJC },
871 { "selector", RID_AT_SELECTOR, D_OBJC },
872 { "finally", RID_AT_FINALLY, D_OBJC },
873 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
874 /* These are recognized only in protocol-qualifier context
876 { "bycopy", RID_BYCOPY, D_OBJC },
877 { "byref", RID_BYREF, D_OBJC },
878 { "in", RID_IN, D_OBJC },
879 { "inout", RID_INOUT, D_OBJC },
880 { "oneway", RID_ONEWAY, D_OBJC },
881 { "out", RID_OUT, D_OBJC },
884 const unsigned int num_c_common_reswords =
885 sizeof c_common_reswords / sizeof (struct c_common_resword);
887 /* Table of machine-independent attributes common to all C-like languages. */
888 const struct attribute_spec c_common_attribute_table[] =
890 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
891 { "packed", 0, 0, false, false, false,
892 handle_packed_attribute },
893 { "nocommon", 0, 0, true, false, false,
894 handle_nocommon_attribute },
895 { "common", 0, 0, true, false, false,
896 handle_common_attribute },
897 /* FIXME: logically, noreturn attributes should be listed as
898 "false, true, true" and apply to function types. But implementing this
899 would require all the places in the compiler that use TREE_THIS_VOLATILE
900 on a decl to identify non-returning functions to be located and fixed
901 to check the function type instead. */
902 { "noreturn", 0, 0, true, false, false,
903 handle_noreturn_attribute },
904 { "volatile", 0, 0, true, false, false,
905 handle_noreturn_attribute },
906 { "noinline", 0, 0, true, false, false,
907 handle_noinline_attribute },
908 { "always_inline", 0, 0, true, false, false,
909 handle_always_inline_attribute },
910 { "gnu_inline", 0, 0, true, false, false,
911 handle_gnu_inline_attribute },
912 { "artificial", 0, 0, true, false, false,
913 handle_artificial_attribute },
914 { "flatten", 0, 0, true, false, false,
915 handle_flatten_attribute },
916 { "used", 0, 0, true, false, false,
917 handle_used_attribute },
918 { "unused", 0, 0, false, false, false,
919 handle_unused_attribute },
920 { "externally_visible", 0, 0, true, false, false,
921 handle_externally_visible_attribute },
922 /* The same comments as for noreturn attributes apply to const ones. */
923 { "const", 0, 0, true, false, false,
924 handle_const_attribute },
925 { "transparent_union", 0, 0, false, false, false,
926 handle_transparent_union_attribute },
927 { "constructor", 0, 1, true, false, false,
928 handle_constructor_attribute },
929 { "destructor", 0, 1, true, false, false,
930 handle_destructor_attribute },
931 { "mode", 1, 1, false, true, false,
932 handle_mode_attribute },
933 { "section", 1, 1, true, false, false,
934 handle_section_attribute },
935 { "aligned", 0, 1, false, false, false,
936 handle_aligned_attribute },
937 { "weak", 0, 0, true, false, false,
938 handle_weak_attribute },
939 { "alias", 1, 1, true, false, false,
940 handle_alias_attribute },
941 { "weakref", 0, 1, true, false, false,
942 handle_weakref_attribute },
943 { "no_instrument_function", 0, 0, true, false, false,
944 handle_no_instrument_function_attribute },
945 { "malloc", 0, 0, true, false, false,
946 handle_malloc_attribute },
947 { "returns_twice", 0, 0, true, false, false,
948 handle_returns_twice_attribute },
949 { "no_stack_limit", 0, 0, true, false, false,
950 handle_no_limit_stack_attribute },
951 { "pure", 0, 0, true, false, false,
952 handle_pure_attribute },
953 /* For internal use (marking of builtins) only. The name contains space
954 to prevent its usage in source code. */
955 { "no vops", 0, 0, true, false, false,
956 handle_novops_attribute },
957 { "deprecated", 0, 1, false, false, false,
958 handle_deprecated_attribute },
959 { "vector_size", 1, 1, false, true, false,
960 handle_vector_size_attribute },
961 { "visibility", 1, 1, false, false, false,
962 handle_visibility_attribute },
963 { "tls_model", 1, 1, true, false, false,
964 handle_tls_model_attribute },
965 { "nonnull", 0, -1, false, true, true,
966 handle_nonnull_attribute },
967 { "nothrow", 0, 0, true, false, false,
968 handle_nothrow_attribute },
969 { "may_alias", 0, 0, false, true, false, NULL },
970 { "cleanup", 1, 1, true, false, false,
971 handle_cleanup_attribute },
972 { "warn_unused_result", 0, 0, false, true, true,
973 handle_warn_unused_result_attribute },
974 { "sentinel", 0, 1, false, true, true,
975 handle_sentinel_attribute },
976 /* For internal use (marking of builtins) only. The name contains space
977 to prevent its usage in source code. */
978 { "type generic", 0, 0, false, true, true,
979 handle_type_generic_attribute },
980 { "alloc_size", 1, 2, false, true, true,
981 handle_alloc_size_attribute },
982 { "cold", 0, 0, true, false, false,
983 handle_cold_attribute },
984 { "hot", 0, 0, true, false, false,
985 handle_hot_attribute },
986 { "warning", 1, 1, true, false, false,
987 handle_error_attribute },
988 { "error", 1, 1, true, false, false,
989 handle_error_attribute },
990 { "target", 1, -1, true, false, false,
991 handle_target_attribute },
992 { "optimize", 1, -1, true, false, false,
993 handle_optimize_attribute },
994 { NULL, 0, 0, false, false, false, NULL }
997 /* Give the specifications for the format attributes, used by C and all
1000 const struct attribute_spec c_common_format_attribute_table[] =
1002 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1003 { "format", 3, 3, false, true, true,
1004 handle_format_attribute },
1005 { "format_arg", 1, 1, false, true, true,
1006 handle_format_arg_attribute },
1007 { NULL, 0, 0, false, false, false, NULL }
1010 /* Push current bindings for the function name VAR_DECLS. */
1013 start_fname_decls (void)
1016 tree saved = NULL_TREE;
1018 for (ix = 0; fname_vars[ix].decl; ix++)
1020 tree decl = *fname_vars[ix].decl;
1024 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
1025 *fname_vars[ix].decl = NULL_TREE;
1028 if (saved || saved_function_name_decls)
1029 /* Normally they'll have been NULL, so only push if we've got a
1030 stack, or they are non-NULL. */
1031 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1032 saved_function_name_decls);
1035 /* Finish up the current bindings, adding them into the current function's
1036 statement tree. This must be done _before_ finish_stmt_tree is called.
1037 If there is no current function, we must be at file scope and no statements
1038 are involved. Pop the previous bindings. */
1041 finish_fname_decls (void)
1044 tree stmts = NULL_TREE;
1045 tree stack = saved_function_name_decls;
1047 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1048 append_to_statement_list (TREE_VALUE (stack), &stmts);
1052 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
1054 if (TREE_CODE (*bodyp) == BIND_EXPR)
1055 bodyp = &BIND_EXPR_BODY (*bodyp);
1057 append_to_statement_list_force (*bodyp, &stmts);
1061 for (ix = 0; fname_vars[ix].decl; ix++)
1062 *fname_vars[ix].decl = NULL_TREE;
1066 /* We had saved values, restore them. */
1069 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1071 tree decl = TREE_PURPOSE (saved);
1072 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1074 *fname_vars[ix].decl = decl;
1076 stack = TREE_CHAIN (stack);
1078 saved_function_name_decls = stack;
1081 /* Return the text name of the current function, suitably prettified
1082 by PRETTY_P. Return string must be freed by caller. */
1085 fname_as_string (int pretty_p)
1087 const char *name = "top level";
1090 cpp_string cstr = { 0, 0 }, strname;
1098 if (current_function_decl)
1099 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
1101 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
1103 namep = XNEWVEC (char, len);
1104 snprintf (namep, len, "\"%s\"", name);
1105 strname.text = (unsigned char *) namep;
1106 strname.len = len - 1;
1108 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
1111 return (const char *) cstr.text;
1117 /* Return the VAR_DECL for a const char array naming the current
1118 function. If the VAR_DECL has not yet been created, create it
1119 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1120 ID is its name (unfortunately C and C++ hold the RID values of
1121 keywords in different places, so we can't derive RID from ID in
1122 this language independent code. LOC is the location of the
1126 fname_decl (location_t loc, unsigned int rid, tree id)
1129 tree decl = NULL_TREE;
1131 for (ix = 0; fname_vars[ix].decl; ix++)
1132 if (fname_vars[ix].rid == rid)
1135 decl = *fname_vars[ix].decl;
1138 /* If a tree is built here, it would normally have the lineno of
1139 the current statement. Later this tree will be moved to the
1140 beginning of the function and this line number will be wrong.
1141 To avoid this problem set the lineno to 0 here; that prevents
1142 it from appearing in the RTL. */
1144 location_t saved_location = input_location;
1145 input_location = UNKNOWN_LOCATION;
1147 stmts = push_stmt_list ();
1148 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1149 stmts = pop_stmt_list (stmts);
1150 if (!IS_EMPTY_STMT (stmts))
1151 saved_function_name_decls
1152 = tree_cons (decl, stmts, saved_function_name_decls);
1153 *fname_vars[ix].decl = decl;
1154 input_location = saved_location;
1156 if (!ix && !current_function_decl)
1157 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1162 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1165 fix_string_type (tree value)
1167 int length = TREE_STRING_LENGTH (value);
1169 tree e_type, i_type, a_type;
1171 /* Compute the number of elements, for the array type. */
1172 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1175 e_type = char_type_node;
1177 else if (TREE_TYPE (value) == char16_array_type_node)
1179 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1180 e_type = char16_type_node;
1182 else if (TREE_TYPE (value) == char32_array_type_node)
1184 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1185 e_type = char32_type_node;
1189 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1190 e_type = wchar_type_node;
1193 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1194 limit in C++98 Annex B is very large (65536) and is not normative,
1195 so we do not diagnose it (warn_overlength_strings is forced off
1196 in c_common_post_options). */
1197 if (warn_overlength_strings)
1199 const int nchars_max = flag_isoc99 ? 4095 : 509;
1200 const int relevant_std = flag_isoc99 ? 99 : 90;
1201 if (nchars - 1 > nchars_max)
1202 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1203 separate the %d from the 'C'. 'ISO' should not be
1204 translated, but it may be moved after 'C%d' in languages
1205 where modifiers follow nouns. */
1206 pedwarn (input_location, OPT_Woverlength_strings,
1207 "string length %qd is greater than the length %qd "
1208 "ISO C%d compilers are required to support",
1209 nchars - 1, nchars_max, relevant_std);
1212 /* Create the array type for the string constant. The ISO C++
1213 standard says that a string literal has type `const char[N]' or
1214 `const wchar_t[N]'. We use the same logic when invoked as a C
1215 front-end with -Wwrite-strings.
1216 ??? We should change the type of an expression depending on the
1217 state of a warning flag. We should just be warning -- see how
1218 this is handled in the C++ front-end for the deprecated implicit
1219 conversion from string literals to `char*' or `wchar_t*'.
1221 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1222 array type being the unqualified version of that type.
1223 Therefore, if we are constructing an array of const char, we must
1224 construct the matching unqualified array type first. The C front
1225 end does not require this, but it does no harm, so we do it
1227 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1228 a_type = build_array_type (e_type, i_type);
1229 if (c_dialect_cxx() || warn_write_strings)
1230 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1232 TREE_TYPE (value) = a_type;
1233 TREE_CONSTANT (value) = 1;
1234 TREE_READONLY (value) = 1;
1235 TREE_STATIC (value) = 1;
1239 /* Fully fold EXPR, an expression that was not folded (beyond integer
1240 constant expressions and null pointer constants) when being built
1241 up. If IN_INIT, this is in a static initializer and certain
1242 changes are made to the folding done. Clear *MAYBE_CONST if
1243 MAYBE_CONST is not NULL and EXPR is definitely not a constant
1244 expression because it contains an evaluated operator (in C99) or an
1245 operator outside of sizeof returning an integer constant (in C90)
1246 not permitted in constant expressions, or because it contains an
1247 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
1248 set to true by callers before calling this function.) Return the
1249 folded expression. Function arguments have already been folded
1250 before calling this function, as have the contents of SAVE_EXPR,
1251 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1252 C_MAYBE_CONST_EXPR. */
1255 c_fully_fold (tree expr, bool in_init, bool *maybe_const)
1258 tree eptype = NULL_TREE;
1260 bool maybe_const_itself = true;
1262 /* This function is not relevant to C++ because C++ folds while
1263 parsing, and may need changes to be correct for C++ when C++
1264 stops folding while parsing. */
1265 if (c_dialect_cxx ())
1269 maybe_const = &dummy;
1270 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
1272 eptype = TREE_TYPE (expr);
1273 expr = TREE_OPERAND (expr, 0);
1275 ret = c_fully_fold_internal (expr, in_init, maybe_const,
1276 &maybe_const_itself);
1278 ret = fold_convert (eptype, ret);
1279 *maybe_const &= maybe_const_itself;
1283 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1284 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1285 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1286 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1287 both evaluated and unevaluated subexpressions while
1288 *MAYBE_CONST_ITSELF is carried from only evaluated
1292 c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1293 bool *maybe_const_itself)
1296 enum tree_code code = TREE_CODE (expr);
1297 enum tree_code_class kind = TREE_CODE_CLASS (code);
1298 location_t loc = EXPR_LOCATION (expr);
1299 tree op0, op1, op2, op3;
1300 tree orig_op0, orig_op1, orig_op2;
1301 bool op0_const = true, op1_const = true, op2_const = true;
1302 bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1303 bool nowarning = TREE_NO_WARNING (expr);
1305 /* This function is not relevant to C++ because C++ folds while
1306 parsing, and may need changes to be correct for C++ when C++
1307 stops folding while parsing. */
1308 if (c_dialect_cxx ())
1311 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1312 anything else not counted as an expression cannot usefully be
1313 folded further at this point. */
1314 if (!IS_EXPR_CODE_CLASS (kind)
1315 || kind == tcc_statement
1316 || code == SAVE_EXPR)
1319 /* Operands of variable-length expressions (function calls) have
1320 already been folded, as have __builtin_* function calls, and such
1321 expressions cannot occur in constant expressions. */
1322 if (kind == tcc_vl_exp)
1324 *maybe_const_operands = false;
1329 if (code == C_MAYBE_CONST_EXPR)
1331 tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1332 tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1333 if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1334 *maybe_const_operands = false;
1335 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1336 *maybe_const_itself = false;
1337 if (pre && !in_init)
1338 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1344 /* Assignment, increment, decrement, function call and comma
1345 operators, and statement expressions, cannot occur in constant
1346 expressions if evaluated / outside of sizeof. (Function calls
1347 were handled above, though VA_ARG_EXPR is treated like a function
1348 call here, and statement expressions are handled through
1349 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1353 case PREDECREMENT_EXPR:
1354 case PREINCREMENT_EXPR:
1355 case POSTDECREMENT_EXPR:
1356 case POSTINCREMENT_EXPR:
1358 *maybe_const_operands = false;
1365 *maybe_const_operands = false;
1373 /* Fold individual tree codes as appropriate. */
1376 case COMPOUND_LITERAL_EXPR:
1377 /* Any non-constancy will have been marked in a containing
1378 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1382 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1383 op1 = TREE_OPERAND (expr, 1);
1384 op2 = TREE_OPERAND (expr, 2);
1385 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1386 maybe_const_itself);
1387 if (op0 != orig_op0)
1388 ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1391 TREE_READONLY (ret) = TREE_READONLY (expr);
1392 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1397 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1398 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1399 op2 = TREE_OPERAND (expr, 2);
1400 op3 = TREE_OPERAND (expr, 3);
1401 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1402 maybe_const_itself);
1403 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1404 maybe_const_itself);
1405 op1 = decl_constant_value_for_optimization (op1);
1406 if (op0 != orig_op0 || op1 != orig_op1)
1407 ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1410 TREE_READONLY (ret) = TREE_READONLY (expr);
1411 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1412 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1419 case PREDECREMENT_EXPR:
1420 case PREINCREMENT_EXPR:
1421 case POSTDECREMENT_EXPR:
1422 case POSTINCREMENT_EXPR:
1426 case POINTER_PLUS_EXPR:
1427 case TRUNC_DIV_EXPR:
1429 case FLOOR_DIV_EXPR:
1430 case TRUNC_MOD_EXPR:
1432 case EXACT_DIV_EXPR:
1445 case TRUTH_AND_EXPR:
1447 case TRUTH_XOR_EXPR:
1448 case UNORDERED_EXPR:
1455 /* Binary operations evaluating both arguments (increment and
1456 decrement are binary internally in GCC). */
1457 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1458 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1459 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1460 maybe_const_itself);
1461 if (code != MODIFY_EXPR
1462 && code != PREDECREMENT_EXPR
1463 && code != PREINCREMENT_EXPR
1464 && code != POSTDECREMENT_EXPR
1465 && code != POSTINCREMENT_EXPR)
1466 op0 = decl_constant_value_for_optimization (op0);
1467 /* The RHS of a MODIFY_EXPR was fully folded when building that
1468 expression for the sake of conversion warnings. */
1469 if (code != MODIFY_EXPR)
1470 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1471 maybe_const_itself);
1472 op1 = decl_constant_value_for_optimization (op1);
1473 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1475 ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
1476 : fold_build2 (code, TREE_TYPE (expr), op0, op1);
1482 case FIX_TRUNC_EXPR:
1485 case NON_LVALUE_EXPR:
1488 case TRUTH_NOT_EXPR:
1493 /* Unary operations. */
1494 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1495 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1496 maybe_const_itself);
1497 if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1498 op0 = decl_constant_value_for_optimization (op0);
1499 if (op0 != orig_op0 || in_init)
1501 ? fold_build1_initializer (code, TREE_TYPE (expr), op0)
1502 : fold_build1 (code, TREE_TYPE (expr), op0);
1505 if (code == INDIRECT_REF
1507 && TREE_CODE (ret) == INDIRECT_REF)
1509 TREE_READONLY (ret) = TREE_READONLY (expr);
1510 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1511 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1515 case TRUTH_ANDIF_EXPR:
1516 case TRUTH_ORIF_EXPR:
1517 /* Binary operations not necessarily evaluating both
1519 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1520 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1521 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1522 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1523 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1525 ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
1526 : fold_build2 (code, TREE_TYPE (expr), op0, op1);
1529 *maybe_const_operands &= op0_const;
1530 *maybe_const_itself &= op0_const_self;
1534 && (code == TRUTH_ANDIF_EXPR
1535 ? op0 == truthvalue_false_node
1536 : op0 == truthvalue_true_node)))
1537 *maybe_const_operands &= op1_const;
1540 && (code == TRUTH_ANDIF_EXPR
1541 ? op0 == truthvalue_false_node
1542 : op0 == truthvalue_true_node)))
1543 *maybe_const_itself &= op1_const_self;
1547 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1548 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1549 orig_op2 = op2 = TREE_OPERAND (expr, 2);
1550 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1551 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1552 op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
1553 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
1554 ret = fold_build3 (code, TREE_TYPE (expr), op0, op1, op2);
1557 *maybe_const_operands &= op0_const;
1558 *maybe_const_itself &= op0_const_self;
1562 && op0 == truthvalue_false_node))
1563 *maybe_const_operands &= op1_const;
1566 && op0 == truthvalue_false_node))
1567 *maybe_const_itself &= op1_const_self;
1571 && op0 == truthvalue_true_node))
1572 *maybe_const_operands &= op2_const;
1575 && op0 == truthvalue_true_node))
1576 *maybe_const_itself &= op2_const_self;
1579 case EXCESS_PRECISION_EXPR:
1580 /* Each case where an operand with excess precision may be
1581 encountered must remove the EXCESS_PRECISION_EXPR around
1582 inner operands and possibly put one around the whole
1583 expression or possibly convert to the semantic type (which
1584 c_fully_fold does); we cannot tell at this stage which is
1585 appropriate in any particular case. */
1589 /* Various codes may appear through folding built-in functions
1590 and their arguments. */
1595 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1596 have been done by this point, so remove them again. */
1597 nowarning |= TREE_NO_WARNING (ret);
1598 STRIP_TYPE_NOPS (ret);
1599 if (nowarning && !TREE_NO_WARNING (ret))
1601 if (!CAN_HAVE_LOCATION_P (ret))
1602 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1603 TREE_NO_WARNING (ret) = 1;
1606 protected_set_expr_location (ret, loc);
1610 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1611 return EXP. Otherwise, return either EXP or its known constant
1612 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1613 Is the BLKmode test appropriate? */
1616 decl_constant_value_for_optimization (tree exp)
1620 /* This function is only used by C, for c_fully_fold and other
1621 optimization, and may not be correct for C++. */
1622 if (c_dialect_cxx ())
1626 || TREE_CODE (exp) != VAR_DECL
1627 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1628 || DECL_MODE (exp) == BLKmode)
1631 ret = decl_constant_value (exp);
1632 /* Avoid unwanted tree sharing between the initializer and current
1633 function's body where the tree can be modified e.g. by the
1635 if (ret != exp && TREE_STATIC (exp))
1636 ret = unshare_expr (ret);
1640 /* Print a warning if a constant expression had overflow in folding.
1641 Invoke this function on every expression that the language
1642 requires to be a constant expression.
1643 Note the ANSI C standard says it is erroneous for a
1644 constant expression to overflow. */
1647 constant_expression_warning (tree value)
1649 if (warn_overflow && pedantic
1650 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1651 || TREE_CODE (value) == FIXED_CST
1652 || TREE_CODE (value) == VECTOR_CST
1653 || TREE_CODE (value) == COMPLEX_CST)
1654 && TREE_OVERFLOW (value))
1655 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1658 /* The same as above but print an unconditional error. */
1660 constant_expression_error (tree value)
1662 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1663 || TREE_CODE (value) == FIXED_CST
1664 || TREE_CODE (value) == VECTOR_CST
1665 || TREE_CODE (value) == COMPLEX_CST)
1666 && TREE_OVERFLOW (value))
1667 error ("overflow in constant expression");
1670 /* Print a warning if an expression had overflow in folding and its
1673 Invoke this function on every expression that
1674 (1) appears in the source code, and
1675 (2) is a constant expression that overflowed, and
1676 (3) is not already checked by convert_and_check;
1677 however, do not invoke this function on operands of explicit casts
1678 or when the expression is the result of an operator and any operand
1679 already overflowed. */
1682 overflow_warning (tree value)
1684 if (skip_evaluation) return;
1686 switch (TREE_CODE (value))
1689 warning (OPT_Woverflow, "integer overflow in expression");
1693 warning (OPT_Woverflow, "floating point overflow in expression");
1697 warning (OPT_Woverflow, "fixed-point overflow in expression");
1701 warning (OPT_Woverflow, "vector overflow in expression");
1705 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1706 warning (OPT_Woverflow, "complex integer overflow in expression");
1707 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1708 warning (OPT_Woverflow, "complex floating point overflow in expression");
1716 /* Warn about uses of logical || / && operator in a context where it
1717 is likely that the bitwise equivalent was intended by the
1718 programmer. We have seen an expression in which CODE is a binary
1719 operator used to combine expressions OP_LEFT and OP_RIGHT, which
1720 before folding had CODE_LEFT and CODE_RIGHT. */
1723 warn_logical_operator (location_t location, enum tree_code code,
1724 enum tree_code code_left, tree op_left,
1725 enum tree_code ARG_UNUSED (code_right), tree op_right)
1727 if (code != TRUTH_ANDIF_EXPR
1728 && code != TRUTH_AND_EXPR
1729 && code != TRUTH_ORIF_EXPR
1730 && code != TRUTH_OR_EXPR)
1733 /* Warn if &&/|| are being used in a context where it is
1734 likely that the bitwise equivalent was intended by the
1735 programmer. That is, an expression such as op && MASK
1736 where op should not be any boolean expression, nor a
1737 constant, and mask seems to be a non-boolean integer constant. */
1738 if (!truth_value_p (code_left)
1739 && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1740 && !CONSTANT_CLASS_P (op_left)
1741 && !TREE_NO_WARNING (op_left)
1742 && TREE_CODE (op_right) == INTEGER_CST
1743 && !integer_zerop (op_right)
1744 && !integer_onep (op_right))
1746 if (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR)
1747 warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1748 " applied to non-boolean constant");
1750 warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1751 " applied to non-boolean constant");
1752 TREE_NO_WARNING (op_left) = true;
1757 /* Print a warning about casts that might indicate violation
1758 of strict aliasing rules if -Wstrict-aliasing is used and
1759 strict aliasing mode is in effect. OTYPE is the original
1760 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1763 strict_aliasing_warning (tree otype, tree type, tree expr)
1765 /* Strip pointer conversion chains and get to the correct original type. */
1767 otype = TREE_TYPE (expr);
1769 if (!(flag_strict_aliasing
1770 && POINTER_TYPE_P (type)
1771 && POINTER_TYPE_P (otype)
1772 && !VOID_TYPE_P (TREE_TYPE (type)))
1773 /* If the type we are casting to is a ref-all pointer
1774 dereferencing it is always valid. */
1775 || TYPE_REF_CAN_ALIAS_ALL (type))
1778 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1779 && (DECL_P (TREE_OPERAND (expr, 0))
1780 || handled_component_p (TREE_OPERAND (expr, 0))))
1782 /* Casting the address of an object to non void pointer. Warn
1783 if the cast breaks type based aliasing. */
1784 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1786 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1787 "might break strict-aliasing rules");
1792 /* warn_strict_aliasing >= 3. This includes the default (3).
1793 Only warn if the cast is dereferenced immediately. */
1794 alias_set_type set1 =
1795 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1796 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1798 if (set1 != set2 && set2 != 0
1799 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1801 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1802 "pointer will break strict-aliasing rules");
1805 else if (warn_strict_aliasing == 2
1806 && !alias_sets_must_conflict_p (set1, set2))
1808 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1809 "pointer might break strict-aliasing rules");
1815 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1817 /* At this level, warn for any conversions, even if an address is
1818 not taken in the same statement. This will likely produce many
1819 false positives, but could be useful to pinpoint problems that
1820 are not revealed at higher levels. */
1821 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1822 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1823 if (!COMPLETE_TYPE_P (type)
1824 || !alias_sets_must_conflict_p (set1, set2))
1826 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1827 "pointer might break strict-aliasing rules");
1835 /* Warn for unlikely, improbable, or stupid DECL declarations
1839 check_main_parameter_types (tree decl)
1844 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1845 args = TREE_CHAIN (args))
1847 tree type = args ? TREE_VALUE (args) : 0;
1849 if (type == void_type_node || type == error_mark_node )
1856 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1857 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1862 if (TREE_CODE (type) != POINTER_TYPE
1863 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1864 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1866 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1871 if (TREE_CODE (type) != POINTER_TYPE
1872 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1873 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1875 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1876 "%<char **%>", decl);
1881 /* It is intentional that this message does not mention the third
1882 argument because it's only mentioned in an appendix of the
1884 if (argct > 0 && (argct < 2 || argct > 3))
1885 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1888 /* True if pointers to distinct types T1 and T2 can be converted to
1889 each other without an explicit cast. Only returns true for opaque
1892 vector_targets_convertible_p (const_tree t1, const_tree t2)
1894 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1895 && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1896 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1902 /* True if vector types T1 and T2 can be converted to each other
1903 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1904 can only be converted with -flax-vector-conversions yet that is not
1905 in effect, emit a note telling the user about that option if such
1906 a note has not previously been emitted. */
1908 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1910 static bool emitted_lax_note = false;
1911 bool convertible_lax;
1913 if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1914 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1918 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1919 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1920 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1921 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1922 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1924 if (!convertible_lax || flag_lax_vector_conversions)
1925 return convertible_lax;
1927 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1928 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1931 if (emit_lax_note && !emitted_lax_note)
1933 emitted_lax_note = true;
1934 inform (input_location, "use -flax-vector-conversions to permit "
1935 "conversions between vectors with differing "
1936 "element types or numbers of subparts");
1942 /* This is a helper function of build_binary_op.
1944 For certain operations if both args were extended from the same
1945 smaller type, do the arithmetic in that type and then extend.
1947 BITWISE indicates a bitwise operation.
1948 For them, this optimization is safe only if
1949 both args are zero-extended or both are sign-extended.
1950 Otherwise, we might change the result.
1951 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1952 but calculated in (unsigned short) it would be (unsigned short)-1.
1954 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1956 int unsigned0, unsigned1;
1961 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1962 excessive narrowing when we call get_narrower below. For
1963 example, suppose that OP0 is of unsigned int extended
1964 from signed char and that RESULT_TYPE is long long int.
1965 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1968 (long long int) (unsigned int) signed_char
1970 which get_narrower would narrow down to
1972 (unsigned int) signed char
1974 If we do not cast OP0 first, get_narrower would return
1975 signed_char, which is inconsistent with the case of the
1977 op0 = convert (result_type, op0);
1978 op1 = convert (result_type, op1);
1980 arg0 = get_narrower (op0, &unsigned0);
1981 arg1 = get_narrower (op1, &unsigned1);
1983 /* UNS is 1 if the operation to be done is an unsigned one. */
1984 uns = TYPE_UNSIGNED (result_type);
1986 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1987 but it *requires* conversion to FINAL_TYPE. */
1989 if ((TYPE_PRECISION (TREE_TYPE (op0))
1990 == TYPE_PRECISION (TREE_TYPE (arg0)))
1991 && TREE_TYPE (op0) != result_type)
1992 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1993 if ((TYPE_PRECISION (TREE_TYPE (op1))
1994 == TYPE_PRECISION (TREE_TYPE (arg1)))
1995 && TREE_TYPE (op1) != result_type)
1996 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1998 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2000 /* For bitwise operations, signedness of nominal type
2001 does not matter. Consider only how operands were extended. */
2005 /* Note that in all three cases below we refrain from optimizing
2006 an unsigned operation on sign-extended args.
2007 That would not be valid. */
2009 /* Both args variable: if both extended in same way
2010 from same width, do it in that width.
2011 Do it unsigned if args were zero-extended. */
2012 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2013 < TYPE_PRECISION (result_type))
2014 && (TYPE_PRECISION (TREE_TYPE (arg1))
2015 == TYPE_PRECISION (TREE_TYPE (arg0)))
2016 && unsigned0 == unsigned1
2017 && (unsigned0 || !uns))
2018 return c_common_signed_or_unsigned_type
2019 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2021 else if (TREE_CODE (arg0) == INTEGER_CST
2022 && (unsigned1 || !uns)
2023 && (TYPE_PRECISION (TREE_TYPE (arg1))
2024 < TYPE_PRECISION (result_type))
2026 = c_common_signed_or_unsigned_type (unsigned1,
2028 && !POINTER_TYPE_P (type)
2029 && int_fits_type_p (arg0, type))
2032 else if (TREE_CODE (arg1) == INTEGER_CST
2033 && (unsigned0 || !uns)
2034 && (TYPE_PRECISION (TREE_TYPE (arg0))
2035 < TYPE_PRECISION (result_type))
2037 = c_common_signed_or_unsigned_type (unsigned0,
2039 && !POINTER_TYPE_P (type)
2040 && int_fits_type_p (arg1, type))
2046 /* Warns if the conversion of EXPR to TYPE may alter a value.
2047 This is a helper function for warnings_for_convert_and_check. */
2050 conversion_warning (tree type, tree expr)
2052 bool give_warning = false;
2055 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
2056 tree expr_type = TREE_TYPE (expr);
2058 if (!warn_conversion && !warn_sign_conversion)
2061 /* If any operand is artificial, then this expression was generated
2062 by the compiler and we do not warn. */
2063 for (i = 0; i < expr_num_operands; i++)
2065 tree op = TREE_OPERAND (expr, i);
2066 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
2070 switch (TREE_CODE (expr))
2078 case TRUTH_ANDIF_EXPR:
2079 case TRUTH_ORIF_EXPR:
2080 case TRUTH_AND_EXPR:
2082 case TRUTH_XOR_EXPR:
2083 case TRUTH_NOT_EXPR:
2084 /* Conversion from boolean to a signed:1 bit-field (which only
2085 can hold the values 0 and -1) doesn't lose information - but
2086 it does change the value. */
2087 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
2088 warning (OPT_Wconversion,
2089 "conversion to %qT from boolean expression", type);
2095 /* Warn for real constant that is not an exact integer converted
2097 if (TREE_CODE (expr_type) == REAL_TYPE
2098 && TREE_CODE (type) == INTEGER_TYPE)
2100 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
2101 give_warning = true;
2103 /* Warn for an integer constant that does not fit into integer type. */
2104 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2105 && TREE_CODE (type) == INTEGER_TYPE
2106 && !int_fits_type_p (expr, type))
2108 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
2109 && tree_int_cst_sgn (expr) < 0)
2110 warning (OPT_Wsign_conversion,
2111 "negative integer implicitly converted to unsigned type");
2112 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
2113 warning (OPT_Wsign_conversion, "conversion of unsigned constant "
2114 "value to negative integer");
2116 give_warning = true;
2118 else if (TREE_CODE (type) == REAL_TYPE)
2120 /* Warn for an integer constant that does not fit into real type. */
2121 if (TREE_CODE (expr_type) == INTEGER_TYPE)
2123 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
2124 if (!exact_real_truncate (TYPE_MODE (type), &a))
2125 give_warning = true;
2127 /* Warn for a real constant that does not fit into a smaller
2129 else if (TREE_CODE (expr_type) == REAL_TYPE
2130 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2132 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
2133 if (!exact_real_truncate (TYPE_MODE (type), &a))
2134 give_warning = true;
2139 warning (OPT_Wconversion,
2140 "conversion to %qT alters %qT constant value",
2147 /* In case of COND_EXPR, if both operands are constants or
2148 COND_EXPR, then we do not care about the type of COND_EXPR,
2149 only about the conversion of each operand. */
2150 tree op1 = TREE_OPERAND (expr, 1);
2151 tree op2 = TREE_OPERAND (expr, 2);
2153 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
2154 || TREE_CODE (op1) == COND_EXPR)
2155 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
2156 || TREE_CODE (op2) == COND_EXPR))
2158 conversion_warning (type, op1);
2159 conversion_warning (type, op2);
2165 default: /* 'expr' is not a constant. */
2167 /* Warn for real types converted to integer types. */
2168 if (TREE_CODE (expr_type) == REAL_TYPE
2169 && TREE_CODE (type) == INTEGER_TYPE)
2170 give_warning = true;
2172 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2173 && TREE_CODE (type) == INTEGER_TYPE)
2175 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2176 expr = get_unwidened (expr, 0);
2177 expr_type = TREE_TYPE (expr);
2179 /* Don't warn for short y; short x = ((int)y & 0xff); */
2180 if (TREE_CODE (expr) == BIT_AND_EXPR
2181 || TREE_CODE (expr) == BIT_IOR_EXPR
2182 || TREE_CODE (expr) == BIT_XOR_EXPR)
2184 /* If both args were extended from a shortest type,
2185 use that type if that is safe. */
2186 expr_type = shorten_binary_op (expr_type,
2187 TREE_OPERAND (expr, 0),
2188 TREE_OPERAND (expr, 1),
2191 if (TREE_CODE (expr) == BIT_AND_EXPR)
2193 tree op0 = TREE_OPERAND (expr, 0);
2194 tree op1 = TREE_OPERAND (expr, 1);
2195 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2196 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2198 /* If one of the operands is a non-negative constant
2199 that fits in the target type, then the type of the
2200 other operand does not matter. */
2201 if ((TREE_CODE (op0) == INTEGER_CST
2202 && int_fits_type_p (op0, c_common_signed_type (type))
2203 && int_fits_type_p (op0, c_common_unsigned_type (type)))
2204 || (TREE_CODE (op1) == INTEGER_CST
2205 && int_fits_type_p (op1, c_common_signed_type (type))
2206 && int_fits_type_p (op1,
2207 c_common_unsigned_type (type))))
2209 /* If constant is unsigned and fits in the target
2210 type, then the result will also fit. */
2211 else if ((TREE_CODE (op0) == INTEGER_CST
2213 && int_fits_type_p (op0, type))
2214 || (TREE_CODE (op1) == INTEGER_CST
2216 && int_fits_type_p (op1, type)))
2220 /* Warn for integer types converted to smaller integer types. */
2221 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2222 give_warning = true;
2224 /* When they are the same width but different signedness,
2225 then the value may change. */
2226 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2227 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
2228 /* Even when converted to a bigger type, if the type is
2229 unsigned but expr is signed, then negative values
2231 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
2232 warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
2233 "may change the sign of the result",
2237 /* Warn for integer types converted to real types if and only if
2238 all the range of values of the integer type cannot be
2239 represented by the real type. */
2240 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2241 && TREE_CODE (type) == REAL_TYPE)
2243 tree type_low_bound = TYPE_MIN_VALUE (expr_type);
2244 tree type_high_bound = TYPE_MAX_VALUE (expr_type);
2245 REAL_VALUE_TYPE real_low_bound
2246 = real_value_from_int_cst (0, type_low_bound);
2247 REAL_VALUE_TYPE real_high_bound
2248 = real_value_from_int_cst (0, type_high_bound);
2250 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2251 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2252 give_warning = true;
2255 /* Warn for real types converted to smaller real types. */
2256 else if (TREE_CODE (expr_type) == REAL_TYPE
2257 && TREE_CODE (type) == REAL_TYPE
2258 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2259 give_warning = true;
2263 warning (OPT_Wconversion,
2264 "conversion to %qT from %qT may alter its value",
2269 /* Produce warnings after a conversion. RESULT is the result of
2270 converting EXPR to TYPE. This is a helper function for
2271 convert_and_check and cp_convert_and_check. */
2274 warnings_for_convert_and_check (tree type, tree expr, tree result)
2276 if (TREE_CODE (expr) == INTEGER_CST
2277 && (TREE_CODE (type) == INTEGER_TYPE
2278 || TREE_CODE (type) == ENUMERAL_TYPE)
2279 && !int_fits_type_p (expr, type))
2281 /* Do not diagnose overflow in a constant expression merely
2282 because a conversion overflowed. */
2283 if (TREE_OVERFLOW (result))
2284 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2286 if (TYPE_UNSIGNED (type))
2288 /* This detects cases like converting -129 or 256 to
2290 if (!int_fits_type_p (expr, c_common_signed_type (type)))
2291 warning (OPT_Woverflow,
2292 "large integer implicitly truncated to unsigned type");
2294 conversion_warning (type, expr);
2296 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
2297 warning (OPT_Woverflow,
2298 "overflow in implicit constant conversion");
2299 /* No warning for converting 0x80000000 to int. */
2301 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2302 || TYPE_PRECISION (TREE_TYPE (expr))
2303 != TYPE_PRECISION (type)))
2304 warning (OPT_Woverflow,
2305 "overflow in implicit constant conversion");
2308 conversion_warning (type, expr);
2310 else if ((TREE_CODE (result) == INTEGER_CST
2311 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
2312 warning (OPT_Woverflow,
2313 "overflow in implicit constant conversion");
2315 conversion_warning (type, expr);
2319 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2320 Invoke this function on every expression that is converted implicitly,
2321 i.e. because of language rules and not because of an explicit cast. */
2324 convert_and_check (tree type, tree expr)
2327 tree expr_for_warning;
2329 /* Convert from a value with possible excess precision rather than
2330 via the semantic type, but do not warn about values not fitting
2331 exactly in the semantic type. */
2332 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2334 tree orig_type = TREE_TYPE (expr);
2335 expr = TREE_OPERAND (expr, 0);
2336 expr_for_warning = convert (orig_type, expr);
2337 if (orig_type == type)
2338 return expr_for_warning;
2341 expr_for_warning = expr;
2343 if (TREE_TYPE (expr) == type)
2346 result = convert (type, expr);
2348 if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
2349 warnings_for_convert_and_check (type, expr_for_warning, result);
2354 /* A node in a list that describes references to variables (EXPR), which are
2355 either read accesses if WRITER is zero, or write accesses, in which case
2356 WRITER is the parent of EXPR. */
2363 /* Used to implement a cache the results of a call to verify_tree. We only
2364 use this for SAVE_EXPRs. */
2367 struct tlist_cache *next;
2368 struct tlist *cache_before_sp;
2369 struct tlist *cache_after_sp;
2373 /* Obstack to use when allocating tlist structures, and corresponding
2375 static struct obstack tlist_obstack;
2376 static char *tlist_firstobj = 0;
2378 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2380 static struct tlist *warned_ids;
2381 /* SAVE_EXPRs need special treatment. We process them only once and then
2382 cache the results. */
2383 static struct tlist_cache *save_expr_cache;
2385 static void add_tlist (struct tlist **, struct tlist *, tree, int);
2386 static void merge_tlist (struct tlist **, struct tlist *, int);
2387 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2388 static int warning_candidate_p (tree);
2389 static bool candidate_equal_p (const_tree, const_tree);
2390 static void warn_for_collisions (struct tlist *);
2391 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2392 static struct tlist *new_tlist (struct tlist *, tree, tree);
2394 /* Create a new struct tlist and fill in its fields. */
2395 static struct tlist *
2396 new_tlist (struct tlist *next, tree t, tree writer)
2399 l = XOBNEW (&tlist_obstack, struct tlist);
2406 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2407 is nonnull, we ignore any node we find which has a writer equal to it. */
2410 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
2414 struct tlist *next = add->next;
2417 if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer))
2418 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2423 /* Merge the nodes of ADD into TO. This merging process is done so that for
2424 each variable that already exists in TO, no new node is added; however if
2425 there is a write access recorded in ADD, and an occurrence on TO is only
2426 a read access, then the occurrence in TO will be modified to record the
2430 merge_tlist (struct tlist **to, struct tlist *add, int copy)
2432 struct tlist **end = to;
2435 end = &(*end)->next;
2441 struct tlist *next = add->next;
2443 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
2444 if (candidate_equal_p (tmp2->expr, add->expr))
2448 tmp2->writer = add->writer;
2452 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2453 end = &(*end)->next;
2460 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2461 references in list LIST conflict with it, excluding reads if ONLY writers
2465 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2470 /* Avoid duplicate warnings. */
2471 for (tmp = warned_ids; tmp; tmp = tmp->next)
2472 if (candidate_equal_p (tmp->expr, written))
2477 if (candidate_equal_p (list->expr, written)
2478 && !candidate_equal_p (list->writer, writer)
2479 && (!only_writes || list->writer))
2481 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
2482 warning_at (EXPR_HAS_LOCATION (writer)
2483 ? EXPR_LOCATION (writer) : input_location,
2484 OPT_Wsequence_point, "operation on %qE may be undefined",
2491 /* Given a list LIST of references to variables, find whether any of these
2492 can cause conflicts due to missing sequence points. */
2495 warn_for_collisions (struct tlist *list)
2499 for (tmp = list; tmp; tmp = tmp->next)
2502 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2506 /* Return nonzero if X is a tree that can be verified by the sequence point
2509 warning_candidate_p (tree x)
2511 /* !VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2512 (lvalue_p) crash on TRY/CATCH. */
2513 return !(DECL_P (x) && DECL_ARTIFICIAL (x))
2514 && TREE_TYPE (x) && !VOID_TYPE_P (TREE_TYPE (x)) && lvalue_p (x);
2517 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2519 candidate_equal_p (const_tree x, const_tree y)
2521 return (x == y) || (x && y && operand_equal_p (x, y, 0));
2524 /* Walk the tree X, and record accesses to variables. If X is written by the
2525 parent tree, WRITER is the parent.
2526 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2527 expression or its only operand forces a sequence point, then everything up
2528 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2530 Once we return, we will have emitted warnings if any subexpression before
2531 such a sequence point could be undefined. On a higher level, however, the
2532 sequence point may not be relevant, and we'll merge the two lists.
2534 Example: (b++, a) + b;
2535 The call that processes the COMPOUND_EXPR will store the increment of B
2536 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2537 processes the PLUS_EXPR will need to merge the two lists so that
2538 eventually, all accesses end up on the same list (and we'll warn about the
2539 unordered subexpressions b++ and b.
2541 A note on merging. If we modify the former example so that our expression
2544 care must be taken not simply to add all three expressions into the final
2545 PNO_SP list. The function merge_tlist takes care of that by merging the
2546 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2547 way, so that no more than one access to B is recorded. */
2550 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2553 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2554 enum tree_code code;
2555 enum tree_code_class cl;
2557 /* X may be NULL if it is the operand of an empty statement expression
2563 code = TREE_CODE (x);
2564 cl = TREE_CODE_CLASS (code);
2566 if (warning_candidate_p (x))
2567 *pno_sp = new_tlist (*pno_sp, x, writer);
2575 case TRUTH_ANDIF_EXPR:
2576 case TRUTH_ORIF_EXPR:
2577 tmp_before = tmp_nosp = tmp_list3 = 0;
2578 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2579 warn_for_collisions (tmp_nosp);
2580 merge_tlist (pbefore_sp, tmp_before, 0);
2581 merge_tlist (pbefore_sp, tmp_nosp, 0);
2582 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2583 merge_tlist (pbefore_sp, tmp_list3, 0);
2587 tmp_before = tmp_list2 = 0;
2588 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2589 warn_for_collisions (tmp_list2);
2590 merge_tlist (pbefore_sp, tmp_before, 0);
2591 merge_tlist (pbefore_sp, tmp_list2, 1);
2593 tmp_list3 = tmp_nosp = 0;
2594 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2595 warn_for_collisions (tmp_nosp);
2596 merge_tlist (pbefore_sp, tmp_list3, 0);
2598 tmp_list3 = tmp_list2 = 0;
2599 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2600 warn_for_collisions (tmp_list2);
2601 merge_tlist (pbefore_sp, tmp_list3, 0);
2602 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2603 two first, to avoid warning for (a ? b++ : b++). */
2604 merge_tlist (&tmp_nosp, tmp_list2, 0);
2605 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2608 case PREDECREMENT_EXPR:
2609 case PREINCREMENT_EXPR:
2610 case POSTDECREMENT_EXPR:
2611 case POSTINCREMENT_EXPR:
2612 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2616 tmp_before = tmp_nosp = tmp_list3 = 0;
2617 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2618 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2619 /* Expressions inside the LHS are not ordered wrt. the sequence points
2620 in the RHS. Example:
2622 Despite the fact that the modification of "a" is in the before_sp
2623 list (tmp_before), it conflicts with the use of "a" in the LHS.
2624 We can handle this by adding the contents of tmp_list3
2625 to those of tmp_before, and redoing the collision warnings for that
2627 add_tlist (&tmp_before, tmp_list3, x, 1);
2628 warn_for_collisions (tmp_before);
2629 /* Exclude the LHS itself here; we first have to merge it into the
2630 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2631 didn't exclude the LHS, we'd get it twice, once as a read and once
2633 add_tlist (pno_sp, tmp_list3, x, 0);
2634 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2636 merge_tlist (pbefore_sp, tmp_before, 0);
2637 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2638 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2639 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2643 /* We need to warn about conflicts among arguments and conflicts between
2644 args and the function address. Side effects of the function address,
2645 however, are not ordered by the sequence point of the call. */
2647 call_expr_arg_iterator iter;
2649 tmp_before = tmp_nosp = 0;
2650 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2651 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2653 tmp_list2 = tmp_list3 = 0;
2654 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2655 merge_tlist (&tmp_list3, tmp_list2, 0);
2656 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2658 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2659 warn_for_collisions (tmp_before);
2660 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2665 /* Scan all the list, e.g. indices of multi dimensional array. */
2668 tmp_before = tmp_nosp = 0;
2669 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2670 merge_tlist (&tmp_nosp, tmp_before, 0);
2671 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2678 struct tlist_cache *t;
2679 for (t = save_expr_cache; t; t = t->next)
2680 if (candidate_equal_p (t->expr, x))
2685 t = XOBNEW (&tlist_obstack, struct tlist_cache);
2686 t->next = save_expr_cache;
2688 save_expr_cache = t;
2690 tmp_before = tmp_nosp = 0;
2691 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2692 warn_for_collisions (tmp_nosp);
2697 struct tlist *t = tmp_nosp;
2699 merge_tlist (&tmp_list3, t, 0);
2701 t->cache_before_sp = tmp_before;
2702 t->cache_after_sp = tmp_list3;
2704 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2705 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2710 x = TREE_OPERAND (x, 0);
2717 /* For other expressions, simply recurse on their operands.
2718 Manual tail recursion for unary expressions.
2719 Other non-expressions need not be processed. */
2720 if (cl == tcc_unary)
2722 x = TREE_OPERAND (x, 0);
2726 else if (IS_EXPR_CODE_CLASS (cl))
2729 int max = TREE_OPERAND_LENGTH (x);
2730 for (lp = 0; lp < max; lp++)
2732 tmp_before = tmp_nosp = 0;
2733 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2734 merge_tlist (&tmp_nosp, tmp_before, 0);
2735 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2742 /* Try to warn for undefined behavior in EXPR due to missing sequence
2746 verify_sequence_points (tree expr)
2748 struct tlist *before_sp = 0, *after_sp = 0;
2751 save_expr_cache = 0;
2752 if (tlist_firstobj == 0)
2754 gcc_obstack_init (&tlist_obstack);
2755 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2758 verify_tree (expr, &before_sp, &after_sp, 0);
2759 warn_for_collisions (after_sp);
2760 obstack_free (&tlist_obstack, tlist_firstobj);
2763 /* Validate the expression after `case' and apply default promotions. */
2766 check_case_value (tree value)
2768 if (value == NULL_TREE)
2771 /* ??? Can we ever get nops here for a valid case value? We
2773 STRIP_TYPE_NOPS (value);
2774 /* In C++, the following is allowed:
2777 switch (...) { case i: ... }
2779 So, we try to reduce the VALUE to a constant that way. */
2780 if (c_dialect_cxx ())
2782 value = decl_constant_value (value);
2783 STRIP_TYPE_NOPS (value);
2784 value = fold (value);
2787 if (TREE_CODE (value) == INTEGER_CST)
2788 /* Promote char or short to int. */
2789 value = perform_integral_promotions (value);
2790 else if (value != error_mark_node)
2792 error ("case label does not reduce to an integer constant");
2793 value = error_mark_node;
2796 constant_expression_warning (value);
2801 /* See if the case values LOW and HIGH are in the range of the original
2802 type (i.e. before the default conversion to int) of the switch testing
2804 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2805 the type before promoting it. CASE_LOW_P is a pointer to the lower
2806 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2807 if the case is not a case range.
2808 The caller has to make sure that we are not called with NULL for
2809 CASE_LOW_P (i.e. the default case).
2810 Returns true if the case label is in range of ORIG_TYPE (saturated or
2811 untouched) or false if the label is out of range. */
2814 check_case_bounds (tree type, tree orig_type,
2815 tree *case_low_p, tree *case_high_p)
2817 tree min_value, max_value;
2818 tree case_low = *case_low_p;
2819 tree case_high = case_high_p ? *case_high_p : case_low;
2821 /* If there was a problem with the original type, do nothing. */
2822 if (orig_type == error_mark_node)
2825 min_value = TYPE_MIN_VALUE (orig_type);
2826 max_value = TYPE_MAX_VALUE (orig_type);
2828 /* Case label is less than minimum for type. */
2829 if (tree_int_cst_compare (case_low, min_value) < 0
2830 && tree_int_cst_compare (case_high, min_value) < 0)
2832 warning (0, "case label value is less than minimum value for type");
2836 /* Case value is greater than maximum for type. */
2837 if (tree_int_cst_compare (case_low, max_value) > 0
2838 && tree_int_cst_compare (case_high, max_value) > 0)
2840 warning (0, "case label value exceeds maximum value for type");
2844 /* Saturate lower case label value to minimum. */
2845 if (tree_int_cst_compare (case_high, min_value) >= 0
2846 && tree_int_cst_compare (case_low, min_value) < 0)
2848 warning (0, "lower value in case label range"
2849 " less than minimum value for type");
2850 case_low = min_value;
2853 /* Saturate upper case label value to maximum. */
2854 if (tree_int_cst_compare (case_low, max_value) <= 0
2855 && tree_int_cst_compare (case_high, max_value) > 0)
2857 warning (0, "upper value in case label range"
2858 " exceeds maximum value for type");
2859 case_high = max_value;
2862 if (*case_low_p != case_low)
2863 *case_low_p = convert (type, case_low);
2864 if (case_high_p && *case_high_p != case_high)
2865 *case_high_p = convert (type, case_high);
2870 /* Return an integer type with BITS bits of precision,
2871 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2874 c_common_type_for_size (unsigned int bits, int unsignedp)
2876 if (bits == TYPE_PRECISION (integer_type_node))
2877 return unsignedp ? unsigned_type_node : integer_type_node;
2879 if (bits == TYPE_PRECISION (signed_char_type_node))
2880 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2882 if (bits == TYPE_PRECISION (short_integer_type_node))
2883 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2885 if (bits == TYPE_PRECISION (long_integer_type_node))
2886 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2888 if (bits == TYPE_PRECISION (long_long_integer_type_node))
2889 return (unsignedp ? long_long_unsigned_type_node
2890 : long_long_integer_type_node);
2892 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2893 return (unsignedp ? widest_unsigned_literal_type_node
2894 : widest_integer_literal_type_node);
2896 if (bits <= TYPE_PRECISION (intQI_type_node))
2897 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2899 if (bits <= TYPE_PRECISION (intHI_type_node))
2900 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2902 if (bits <= TYPE_PRECISION (intSI_type_node))
2903 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2905 if (bits <= TYPE_PRECISION (intDI_type_node))
2906 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2911 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2912 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2913 and saturating if SATP is nonzero, otherwise not saturating. */
2916 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2917 int unsignedp, int satp)
2919 enum machine_mode mode;
2921 mode = unsignedp ? UQQmode : QQmode;
2923 mode = unsignedp ? UHAmode : HAmode;
2925 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2926 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2929 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2931 sorry ("GCC cannot support operators with integer types and "
2932 "fixed-point types that have too many integral and "
2933 "fractional bits together");
2937 return c_common_type_for_mode (mode, satp);
2940 /* Used for communication between c_common_type_for_mode and
2941 c_register_builtin_type. */
2942 static GTY(()) tree registered_builtin_types;
2944 /* Return a data type that has machine mode MODE.
2945 If the mode is an integer,
2946 then UNSIGNEDP selects between signed and unsigned types.
2947 If the mode is a fixed-point mode,
2948 then UNSIGNEDP selects between saturating and nonsaturating types. */
2951 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2955 if (mode == TYPE_MODE (integer_type_node))
2956 return unsignedp ? unsigned_type_node : integer_type_node;
2958 if (mode == TYPE_MODE (signed_char_type_node))
2959 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2961 if (mode == TYPE_MODE (short_integer_type_node))
2962 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2964 if (mode == TYPE_MODE (long_integer_type_node))
2965 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2967 if (mode == TYPE_MODE (long_long_integer_type_node))
2968 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2970 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2971 return unsignedp ? widest_unsigned_literal_type_node
2972 : widest_integer_literal_type_node;
2975 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2978 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2981 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2984 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2986 #if HOST_BITS_PER_WIDE_INT >= 64
2987 if (mode == TYPE_MODE (intTI_type_node))
2988 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2991 if (mode == TYPE_MODE (float_type_node))
2992 return float_type_node;
2994 if (mode == TYPE_MODE (double_type_node))
2995 return double_type_node;
2997 if (mode == TYPE_MODE (long_double_type_node))
2998 return long_double_type_node;
3000 if (mode == TYPE_MODE (void_type_node))
3001 return void_type_node;
3003 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
3005 ? make_unsigned_type (GET_MODE_PRECISION (mode))
3006 : make_signed_type (GET_MODE_PRECISION (mode)));
3008 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
3010 ? make_unsigned_type (GET_MODE_PRECISION (mode))
3011 : make_signed_type (GET_MODE_PRECISION (mode)));
3013 if (COMPLEX_MODE_P (mode))
3015 enum machine_mode inner_mode;
3018 if (mode == TYPE_MODE (complex_float_type_node))
3019 return complex_float_type_node;
3020 if (mode == TYPE_MODE (complex_double_type_node))
3021 return complex_double_type_node;
3022 if (mode == TYPE_MODE (complex_long_double_type_node))
3023 return complex_long_double_type_node;
3025 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
3026 return complex_integer_type_node;
3028 inner_mode = GET_MODE_INNER (mode);
3029 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
3030 if (inner_type != NULL_TREE)
3031 return build_complex_type (inner_type);
3033 else if (VECTOR_MODE_P (mode))
3035 enum machine_mode inner_mode = GET_MODE_INNER (mode);
3036 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
3037 if (inner_type != NULL_TREE)
3038 return build_vector_type_for_mode (inner_type, mode);
3041 if (mode == TYPE_MODE (dfloat32_type_node))
3042 return dfloat32_type_node;
3043 if (mode == TYPE_MODE (dfloat64_type_node))
3044 return dfloat64_type_node;
3045 if (mode == TYPE_MODE (dfloat128_type_node))
3046 return dfloat128_type_node;
3048 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
3050 if (mode == TYPE_MODE (short_fract_type_node))
3051 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
3052 if (mode == TYPE_MODE (fract_type_node))
3053 return unsignedp ? sat_fract_type_node : fract_type_node;
3054 if (mode == TYPE_MODE (long_fract_type_node))
3055 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
3056 if (mode == TYPE_MODE (long_long_fract_type_node))
3057 return unsignedp ? sat_long_long_fract_type_node
3058 : long_long_fract_type_node;
3060 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
3061 return unsignedp ? sat_unsigned_short_fract_type_node
3062 : unsigned_short_fract_type_node;
3063 if (mode == TYPE_MODE (unsigned_fract_type_node))
3064 return unsignedp ? sat_unsigned_fract_type_node
3065 : unsigned_fract_type_node;
3066 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
3067 return unsignedp ? sat_unsigned_long_fract_type_node
3068 : unsigned_long_fract_type_node;
3069 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
3070 return unsignedp ? sat_unsigned_long_long_fract_type_node
3071 : unsigned_long_long_fract_type_node;
3073 if (mode == TYPE_MODE (short_accum_type_node))
3074 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
3075 if (mode == TYPE_MODE (accum_type_node))
3076 return unsignedp ? sat_accum_type_node : accum_type_node;
3077 if (mode == TYPE_MODE (long_accum_type_node))
3078 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
3079 if (mode == TYPE_MODE (long_long_accum_type_node))
3080 return unsignedp ? sat_long_long_accum_type_node
3081 : long_long_accum_type_node;
3083 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
3084 return unsignedp ? sat_unsigned_short_accum_type_node
3085 : unsigned_short_accum_type_node;
3086 if (mode == TYPE_MODE (unsigned_accum_type_node))
3087 return unsignedp ? sat_unsigned_accum_type_node
3088 : unsigned_accum_type_node;
3089 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
3090 return unsignedp ? sat_unsigned_long_accum_type_node
3091 : unsigned_long_accum_type_node;
3092 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
3093 return unsignedp ? sat_unsigned_long_long_accum_type_node
3094 : unsigned_long_long_accum_type_node;
3097 return unsignedp ? sat_qq_type_node : qq_type_node;
3099 return unsignedp ? sat_hq_type_node : hq_type_node;
3101 return unsignedp ? sat_sq_type_node : sq_type_node;
3103 return unsignedp ? sat_dq_type_node : dq_type_node;
3105 return unsignedp ? sat_tq_type_node : tq_type_node;
3107 if (mode == UQQmode)
3108 return unsignedp ? sat_uqq_type_node : uqq_type_node;
3109 if (mode == UHQmode)
3110 return unsignedp ? sat_uhq_type_node : uhq_type_node;
3111 if (mode == USQmode)
3112 return unsignedp ? sat_usq_type_node : usq_type_node;
3113 if (mode == UDQmode)
3114 return unsignedp ? sat_udq_type_node : udq_type_node;
3115 if (mode == UTQmode)
3116 return unsignedp ? sat_utq_type_node : utq_type_node;
3119 return unsignedp ? sat_ha_type_node : ha_type_node;
3121 return unsignedp ? sat_sa_type_node : sa_type_node;
3123 return unsignedp ? sat_da_type_node : da_type_node;
3125 return unsignedp ? sat_ta_type_node : ta_type_node;
3127 if (mode == UHAmode)
3128 return unsignedp ? sat_uha_type_node : uha_type_node;
3129 if (mode == USAmode)
3130 return unsignedp ? sat_usa_type_node : usa_type_node;
3131 if (mode == UDAmode)
3132 return unsignedp ? sat_uda_type_node : uda_type_node;
3133 if (mode == UTAmode)
3134 return unsignedp ? sat_uta_type_node : uta_type_node;
3137 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
3138 if (TYPE_MODE (TREE_VALUE (t)) == mode)
3139 return TREE_VALUE (t);
3145 c_common_unsigned_type (tree type)
3147 return c_common_signed_or_unsigned_type (1, type);
3150 /* Return a signed type the same as TYPE in other respects. */
3153 c_common_signed_type (tree type)
3155 return c_common_signed_or_unsigned_type (0, type);
3158 /* Return a type the same as TYPE except unsigned or
3159 signed according to UNSIGNEDP. */
3162 c_common_signed_or_unsigned_type (int unsignedp, tree type)
3166 /* This block of code emulates the behavior of the old
3167 c_common_unsigned_type. In particular, it returns
3168 long_unsigned_type_node if passed a long, even when a int would
3169 have the same size. This is necessary for warnings to work
3170 correctly in archs where sizeof(int) == sizeof(long) */
3172 type1 = TYPE_MAIN_VARIANT (type);
3173 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3174 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3175 if (type1 == integer_type_node || type1 == unsigned_type_node)
3176 return unsignedp ? unsigned_type_node : integer_type_node;
3177 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3178 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3179 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3180 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3181 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3182 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3183 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3184 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3185 #if HOST_BITS_PER_WIDE_INT >= 64
3186 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3187 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3189 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3190 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3191 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3192 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3193 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3194 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3195 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3196 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3198 #define C_COMMON_FIXED_TYPES(NAME) \
3199 if (type1 == short_ ## NAME ## _type_node \
3200 || type1 == unsigned_short_ ## NAME ## _type_node) \
3201 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3202 : short_ ## NAME ## _type_node; \
3203 if (type1 == NAME ## _type_node \
3204 || type1 == unsigned_ ## NAME ## _type_node) \
3205 return unsignedp ? unsigned_ ## NAME ## _type_node \
3206 : NAME ## _type_node; \
3207 if (type1 == long_ ## NAME ## _type_node \
3208 || type1 == unsigned_long_ ## NAME ## _type_node) \
3209 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3210 : long_ ## NAME ## _type_node; \
3211 if (type1 == long_long_ ## NAME ## _type_node \
3212 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3213 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3214 : long_long_ ## NAME ## _type_node;
3216 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3217 if (type1 == NAME ## _type_node \
3218 || type1 == u ## NAME ## _type_node) \
3219 return unsignedp ? u ## NAME ## _type_node \
3220 : NAME ## _type_node;
3222 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3223 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3224 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3225 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3226 : sat_ ## short_ ## NAME ## _type_node; \
3227 if (type1 == sat_ ## NAME ## _type_node \
3228 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3229 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3230 : sat_ ## NAME ## _type_node; \
3231 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3232 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3233 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3234 : sat_ ## long_ ## NAME ## _type_node; \
3235 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3236 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3237 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3238 : sat_ ## long_long_ ## NAME ## _type_node;
3240 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3241 if (type1 == sat_ ## NAME ## _type_node \
3242 || type1 == sat_ ## u ## NAME ## _type_node) \
3243 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3244 : sat_ ## NAME ## _type_node;
3246 C_COMMON_FIXED_TYPES (fract);
3247 C_COMMON_FIXED_TYPES_SAT (fract);
3248 C_COMMON_FIXED_TYPES (accum);
3249 C_COMMON_FIXED_TYPES_SAT (accum);
3251 C_COMMON_FIXED_MODE_TYPES (qq);
3252 C_COMMON_FIXED_MODE_TYPES (hq);
3253 C_COMMON_FIXED_MODE_TYPES (sq);
3254 C_COMMON_FIXED_MODE_TYPES (dq);
3255 C_COMMON_FIXED_MODE_TYPES (tq);
3256 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3257 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3258 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3259 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3260 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3261 C_COMMON_FIXED_MODE_TYPES (ha);
3262 C_COMMON_FIXED_MODE_TYPES (sa);
3263 C_COMMON_FIXED_MODE_TYPES (da);
3264 C_COMMON_FIXED_MODE_TYPES (ta);
3265 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3266 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3267 C_COMMON_FIXED_MODE_TYPES_SAT (da);
3268 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3270 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3271 the precision; they have precision set to match their range, but
3272 may use a wider mode to match an ABI. If we change modes, we may
3273 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3274 the precision as well, so as to yield correct results for
3275 bit-field types. C++ does not have these separate bit-field
3276 types, and producing a signed or unsigned variant of an
3277 ENUMERAL_TYPE may cause other problems as well. */
3279 if (!INTEGRAL_TYPE_P (type)
3280 || TYPE_UNSIGNED (type) == unsignedp)
3283 #define TYPE_OK(node) \
3284 (TYPE_MODE (type) == TYPE_MODE (node) \
3285 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3286 if (TYPE_OK (signed_char_type_node))
3287 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3288 if (TYPE_OK (integer_type_node))
3289 return unsignedp ? unsigned_type_node : integer_type_node;
3290 if (TYPE_OK (short_integer_type_node))
3291 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3292 if (TYPE_OK (long_integer_type_node))
3293 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3294 if (TYPE_OK (long_long_integer_type_node))
3295 return (unsignedp ? long_long_unsigned_type_node
3296 : long_long_integer_type_node);
3297 if (TYPE_OK (widest_integer_literal_type_node))
3298 return (unsignedp ? widest_unsigned_literal_type_node
3299 : widest_integer_literal_type_node);
3301 #if HOST_BITS_PER_WIDE_INT >= 64
3302 if (TYPE_OK (intTI_type_node))
3303 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3305 if (TYPE_OK (intDI_type_node))
3306 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3307 if (TYPE_OK (intSI_type_node))
3308 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3309 if (TYPE_OK (intHI_type_node))
3310 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3311 if (TYPE_OK (intQI_type_node))
3312 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3315 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3318 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3321 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3323 /* Extended integer types of the same width as a standard type have
3324 lesser rank, so those of the same width as int promote to int or
3325 unsigned int and are valid for printf formats expecting int or
3326 unsigned int. To avoid such special cases, avoid creating
3327 extended integer types for bit-fields if a standard integer type
3329 if (width == TYPE_PRECISION (integer_type_node))
3330 return unsignedp ? unsigned_type_node : integer_type_node;
3331 if (width == TYPE_PRECISION (signed_char_type_node))
3332 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3333 if (width == TYPE_PRECISION (short_integer_type_node))
3334 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3335 if (width == TYPE_PRECISION (long_integer_type_node))
3336 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3337 if (width == TYPE_PRECISION (long_long_integer_type_node))
3338 return (unsignedp ? long_long_unsigned_type_node
3339 : long_long_integer_type_node);
3340 return build_nonstandard_integer_type (width, unsignedp);
3343 /* The C version of the register_builtin_type langhook. */
3346 c_register_builtin_type (tree type, const char* name)
3350 decl = build_decl (TYPE_DECL, get_identifier (name), type);
3351 DECL_ARTIFICIAL (decl) = 1;
3352 if (!TYPE_NAME (type))
3353 TYPE_NAME (type) = decl;
3356 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3359 /* Print an error message for invalid operands to arith operation
3360 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3361 LOCATION is the location of the message. */
3364 binary_op_error (location_t location, enum tree_code code,
3365 tree type0, tree type1)
3372 opname = "+"; break;
3374 opname = "-"; break;
3376 opname = "*"; break;
3378 opname = "max"; break;
3380 opname = "min"; break;
3382 opname = "=="; break;
3384 opname = "!="; break;
3386 opname = "<="; break;
3388 opname = ">="; break;
3390 opname = "<"; break;
3392 opname = ">"; break;
3394 opname = "<<"; break;
3396 opname = ">>"; break;
3397 case TRUNC_MOD_EXPR:
3398 case FLOOR_MOD_EXPR:
3399 opname = "%"; break;
3400 case TRUNC_DIV_EXPR:
3401 case FLOOR_DIV_EXPR:
3402 opname = "/"; break;
3404 opname = "&"; break;
3406 opname = "|"; break;
3407 case TRUTH_ANDIF_EXPR:
3408 opname = "&&"; break;
3409 case TRUTH_ORIF_EXPR:
3410 opname = "||"; break;
3412 opname = "^"; break;
3417 "invalid operands to binary %s (have %qT and %qT)", opname,
3421 /* Subroutine of build_binary_op, used for comparison operations.
3422 See if the operands have both been converted from subword integer types
3423 and, if so, perhaps change them both back to their original type.
3424 This function is also responsible for converting the two operands
3425 to the proper common type for comparison.
3427 The arguments of this function are all pointers to local variables
3428 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3429 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3431 If this function returns nonzero, it means that the comparison has
3432 a constant value. What this function returns is an expression for
3436 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3437 enum tree_code *rescode_ptr)
3440 tree op0 = *op0_ptr;
3441 tree op1 = *op1_ptr;
3442 int unsignedp0, unsignedp1;
3444 tree primop0, primop1;
3445 enum tree_code code = *rescode_ptr;
3447 /* Throw away any conversions to wider types
3448 already present in the operands. */
3450 primop0 = get_narrower (op0, &unsignedp0);
3451 primop1 = get_narrower (op1, &unsignedp1);
3453 /* Handle the case that OP0 does not *contain* a conversion
3454 but it *requires* conversion to FINAL_TYPE. */
3456 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3457 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3458 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3459 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3461 /* If one of the operands must be floated, we cannot optimize. */
3462 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3463 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3465 /* If first arg is constant, swap the args (changing operation
3466 so value is preserved), for canonicalization. Don't do this if
3467 the second arg is 0. */
3469 if (TREE_CONSTANT (primop0)
3470 && !integer_zerop (primop1) && !real_zerop (primop1)
3471 && !fixed_zerop (primop1))
3474 int temi = unsignedp0;
3482 unsignedp0 = unsignedp1;
3505 *rescode_ptr = code;
3508 /* If comparing an integer against a constant more bits wide,
3509 maybe we can deduce a value of 1 or 0 independent of the data.
3510 Or else truncate the constant now
3511 rather than extend the variable at run time.
3513 This is only interesting if the constant is the wider arg.
3514 Also, it is not safe if the constant is unsigned and the
3515 variable arg is signed, since in this case the variable
3516 would be sign-extended and then regarded as unsigned.
3517 Our technique fails in this case because the lowest/highest
3518 possible unsigned results don't follow naturally from the
3519 lowest/highest possible values of the variable operand.
3520 For just EQ_EXPR and NE_EXPR there is another technique that
3521 could be used: see if the constant can be faithfully represented
3522 in the other operand's type, by truncating it and reextending it
3523 and see if that preserves the constant's value. */
3525 if (!real1 && !real2
3526 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
3527 && TREE_CODE (primop1) == INTEGER_CST
3528 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3530 int min_gt, max_gt, min_lt, max_lt;
3531 tree maxval, minval;
3532 /* 1 if comparison is nominally unsigned. */
3533 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
3536 type = c_common_signed_or_unsigned_type (unsignedp0,
3537 TREE_TYPE (primop0));
3539 maxval = TYPE_MAX_VALUE (type);
3540 minval = TYPE_MIN_VALUE (type);
3542 if (unsignedp && !unsignedp0)
3543 *restype_ptr = c_common_signed_type (*restype_ptr);
3545 if (TREE_TYPE (primop1) != *restype_ptr)
3547 /* Convert primop1 to target type, but do not introduce
3548 additional overflow. We know primop1 is an int_cst. */
3549 primop1 = force_fit_type_double (*restype_ptr,
3550 TREE_INT_CST_LOW (primop1),
3551 TREE_INT_CST_HIGH (primop1), 0,
3552 TREE_OVERFLOW (primop1));
3554 if (type != *restype_ptr)
3556 minval = convert (*restype_ptr, minval);
3557 maxval = convert (*restype_ptr, maxval);
3560 if (unsignedp && unsignedp0)
3562 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3563 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3564 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3565 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3569 min_gt = INT_CST_LT (primop1, minval);
3570 max_gt = INT_CST_LT (primop1, maxval);
3571 min_lt = INT_CST_LT (minval, primop1);
3572 max_lt = INT_CST_LT (maxval, primop1);
3576 /* This used to be a switch, but Genix compiler can't handle that. */
3577 if (code == NE_EXPR)
3579 if (max_lt || min_gt)
3580 val = truthvalue_true_node;
3582 else if (code == EQ_EXPR)
3584 if (max_lt || min_gt)
3585 val = truthvalue_false_node;
3587 else if (code == LT_EXPR)
3590 val = truthvalue_true_node;
3592 val = truthvalue_false_node;
3594 else if (code == GT_EXPR)
3597 val = truthvalue_true_node;
3599 val = truthvalue_false_node;
3601 else if (code == LE_EXPR)
3604 val = truthvalue_true_node;
3606 val = truthvalue_false_node;
3608 else if (code == GE_EXPR)
3611 val = truthvalue_true_node;
3613 val = truthvalue_false_node;
3616 /* If primop0 was sign-extended and unsigned comparison specd,
3617 we did a signed comparison above using the signed type bounds.
3618 But the comparison we output must be unsigned.
3620 Also, for inequalities, VAL is no good; but if the signed
3621 comparison had *any* fixed result, it follows that the
3622 unsigned comparison just tests the sign in reverse
3623 (positive values are LE, negative ones GE).
3624 So we can generate an unsigned comparison
3625 against an extreme value of the signed type. */
3627 if (unsignedp && !unsignedp0)
3634 primop1 = TYPE_MIN_VALUE (type);
3640 primop1 = TYPE_MAX_VALUE (type);
3647 type = c_common_unsigned_type (type);
3650 if (TREE_CODE (primop0) != INTEGER_CST)
3652 if (val == truthvalue_false_node)
3653 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3654 if (val == truthvalue_true_node)
3655 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3660 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3661 if (TREE_SIDE_EFFECTS (primop0))
3662 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3666 /* Value is not predetermined, but do the comparison
3667 in the type of the operand that is not constant.
3668 TYPE is already properly set. */
3671 /* If either arg is decimal float and the other is float, find the
3672 proper common type to use for comparison. */
3673 else if (real1 && real2
3674 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3675 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3676 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3678 else if (real1 && real2
3679 && (TYPE_PRECISION (TREE_TYPE (primop0))
3680 == TYPE_PRECISION (TREE_TYPE (primop1))))
3681 type = TREE_TYPE (primop0);
3683 /* If args' natural types are both narrower than nominal type
3684 and both extend in the same manner, compare them
3685 in the type of the wider arg.
3686 Otherwise must actually extend both to the nominal
3687 common type lest different ways of extending
3689 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3691 else if (unsignedp0 == unsignedp1 && real1 == real2
3692 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3693 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3695 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3696 type = c_common_signed_or_unsigned_type (unsignedp0
3697 || TYPE_UNSIGNED (*restype_ptr),
3699 /* Make sure shorter operand is extended the right way
3700 to match the longer operand. */
3702 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3703 TREE_TYPE (primop0)),
3706 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3707 TREE_TYPE (primop1)),
3712 /* Here we must do the comparison on the nominal type
3713 using the args exactly as we received them. */
3714 type = *restype_ptr;
3718 if (!real1 && !real2 && integer_zerop (primop1)
3719 && TYPE_UNSIGNED (*restype_ptr))
3725 /* All unsigned values are >= 0, so we warn. However,
3726 if OP0 is a constant that is >= 0, the signedness of
3727 the comparison isn't an issue, so suppress the
3729 if (warn_type_limits && !in_system_header
3730 && !(TREE_CODE (primop0) == INTEGER_CST
3731 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3733 warning (OPT_Wtype_limits,
3734 "comparison of unsigned expression >= 0 is always true");
3735 value = truthvalue_true_node;
3739 if (warn_type_limits && !in_system_header
3740 && !(TREE_CODE (primop0) == INTEGER_CST
3741 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3743 warning (OPT_Wtype_limits,
3744 "comparison of unsigned expression < 0 is always false");
3745 value = truthvalue_false_node;
3754 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3755 if (TREE_SIDE_EFFECTS (primop0))
3756 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3763 *op0_ptr = convert (type, primop0);
3764 *op1_ptr = convert (type, primop1);
3766 *restype_ptr = truthvalue_type_node;
3771 /* Return a tree for the sum or difference (RESULTCODE says which)
3772 of pointer PTROP and integer INTOP. */
3775 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3779 /* The result is a pointer of the same type that is being added. */
3780 tree result_type = TREE_TYPE (ptrop);
3782 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3784 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3785 "pointer of type %<void *%> used in arithmetic");
3786 size_exp = integer_one_node;
3788 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3790 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3791 "pointer to a function used in arithmetic");
3792 size_exp = integer_one_node;
3794 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3796 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3797 "pointer to member function used in arithmetic");
3798 size_exp = integer_one_node;
3801 size_exp = size_in_bytes (TREE_TYPE (result_type));
3803 /* We are manipulating pointer values, so we don't need to warn
3804 about relying on undefined signed overflow. We disable the
3805 warning here because we use integer types so fold won't know that
3806 they are really pointers. */
3807 fold_defer_overflow_warnings ();
3809 /* If what we are about to multiply by the size of the elements
3810 contains a constant term, apply distributive law
3811 and multiply that constant term separately.
3812 This helps produce common subexpressions. */
3813 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3814 && !TREE_CONSTANT (intop)
3815 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3816 && TREE_CONSTANT (size_exp)
3817 /* If the constant comes from pointer subtraction,
3818 skip this optimization--it would cause an error. */
3819 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3820 /* If the constant is unsigned, and smaller than the pointer size,
3821 then we must skip this optimization. This is because it could cause
3822 an overflow error if the constant is negative but INTOP is not. */
3823 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3824 || (TYPE_PRECISION (TREE_TYPE (intop))
3825 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3827 enum tree_code subcode = resultcode;
3828 tree int_type = TREE_TYPE (intop);
3829 if (TREE_CODE (intop) == MINUS_EXPR)
3830 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3831 /* Convert both subexpression types to the type of intop,
3832 because weird cases involving pointer arithmetic
3833 can result in a sum or difference with different type args. */
3834 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3836 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3837 intop = convert (int_type, TREE_OPERAND (intop, 0));
3840 /* Convert the integer argument to a type the same size as sizetype
3841 so the multiply won't overflow spuriously. */
3842 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3843 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3844 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3845 TYPE_UNSIGNED (sizetype)), intop);
3847 /* Replace the integer argument with a suitable product by the object size.
3848 Do this multiplication as signed, then convert to the appropriate
3849 type for the pointer operation. */
3850 intop = convert (sizetype,
3851 build_binary_op (EXPR_LOCATION (intop),
3853 convert (TREE_TYPE (intop), size_exp), 1));
3855 /* Create the sum or difference. */
3856 if (resultcode == MINUS_EXPR)
3857 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3859 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3861 fold_undefer_and_ignore_overflow_warnings ();
3866 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3867 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3868 around the SAVE_EXPR if needed so that c_fully_fold does not need
3869 to look inside SAVE_EXPRs. */
3872 c_save_expr (tree expr)
3874 bool maybe_const = true;
3875 if (c_dialect_cxx ())
3876 return save_expr (expr);
3877 expr = c_fully_fold (expr, false, &maybe_const);
3878 expr = save_expr (expr);
3881 expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3882 C_MAYBE_CONST_EXPR_NON_CONST (expr) = 1;
3887 /* Return whether EXPR is a declaration whose address can never be
3891 decl_with_nonnull_addr_p (const_tree expr)
3893 return (DECL_P (expr)
3894 && (TREE_CODE (expr) == PARM_DECL
3895 || TREE_CODE (expr) == LABEL_DECL
3896 || !DECL_WEAK (expr)));
3899 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3900 or for an `if' or `while' statement or ?..: exp. It should already
3901 have been validated to be of suitable type; otherwise, a bad
3902 diagnostic may result.
3904 The EXPR is located at LOCATION.
3906 This preparation consists of taking the ordinary
3907 representation of an expression expr and producing a valid tree
3908 boolean expression describing whether expr is nonzero. We could
3909 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3910 but we optimize comparisons, &&, ||, and !.
3912 The resulting type should always be `truthvalue_type_node'. */
3915 c_common_truthvalue_conversion (location_t location, tree expr)
3917 switch (TREE_CODE (expr))
3919 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
3920 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3921 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3922 case ORDERED_EXPR: case UNORDERED_EXPR:
3923 if (TREE_TYPE (expr) == truthvalue_type_node)
3925 return build2 (TREE_CODE (expr), truthvalue_type_node,
3926 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3928 case TRUTH_ANDIF_EXPR:
3929 case TRUTH_ORIF_EXPR:
3930 case TRUTH_AND_EXPR:
3932 case TRUTH_XOR_EXPR:
3933 if (TREE_TYPE (expr) == truthvalue_type_node)
3935 return build2 (TREE_CODE (expr), truthvalue_type_node,
3936 c_common_truthvalue_conversion (location,
3937 TREE_OPERAND (expr, 0)),
3938 c_common_truthvalue_conversion (location,
3939 TREE_OPERAND (expr, 1)));
3941 case TRUTH_NOT_EXPR:
3942 if (TREE_TYPE (expr) == truthvalue_type_node)
3944 return build1 (TREE_CODE (expr), truthvalue_type_node,
3945 c_common_truthvalue_conversion (location,
3946 TREE_OPERAND (expr, 0)));
3952 return integer_zerop (expr) ? truthvalue_false_node
3953 : truthvalue_true_node;
3956 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3957 ? truthvalue_true_node
3958 : truthvalue_false_node;
3961 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3962 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3963 ? truthvalue_true_node
3964 : truthvalue_false_node;
3967 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3972 tree inner = TREE_OPERAND (expr, 0);
3973 if (decl_with_nonnull_addr_p (inner))
3975 /* Common Ada/Pascal programmer's mistake. */
3976 warning_at (location,
3978 "the address of %qD will always evaluate as %<true%>",
3980 return truthvalue_true_node;
3983 /* If we still have a decl, it is possible for its address to
3984 be NULL, so we cannot optimize. */
3987 gcc_assert (DECL_WEAK (inner));
3991 if (TREE_SIDE_EFFECTS (inner))
3992 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3993 inner, truthvalue_true_node);
3995 return truthvalue_true_node;
3999 return build_binary_op (EXPR_LOCATION (expr),
4000 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
4001 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4002 c_common_truthvalue_conversion (location,
4003 TREE_OPERAND (expr, 0)),
4004 c_common_truthvalue_conversion (location,
4005 TREE_OPERAND (expr, 1)),
4011 case EXCESS_PRECISION_EXPR:
4012 /* These don't change whether an object is nonzero or zero. */
4013 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
4017 /* These don't change whether an object is zero or nonzero, but
4018 we can't ignore them if their second arg has side-effects. */
4019 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
4020 return build2 (COMPOUND_EXPR, truthvalue_type_node,
4021 TREE_OPERAND (expr, 1),
4022 c_common_truthvalue_conversion
4023 (location, TREE_OPERAND (expr, 0)));
4025 return c_common_truthvalue_conversion (location,
4026 TREE_OPERAND (expr, 0));
4029 /* Distribute the conversion into the arms of a COND_EXPR. */
4030 if (c_dialect_cxx ())
4031 return fold_build3 (COND_EXPR, truthvalue_type_node,
4032 TREE_OPERAND (expr, 0),
4033 c_common_truthvalue_conversion (location,
4036 c_common_truthvalue_conversion (location,
4040 /* Folding will happen later for C. */
4041 return build3 (COND_EXPR, truthvalue_type_node,
4042 TREE_OPERAND (expr, 0),
4043 c_common_truthvalue_conversion (location,
4044 TREE_OPERAND (expr, 1)),
4045 c_common_truthvalue_conversion (location,
4046 TREE_OPERAND (expr, 2)));
4049 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4050 since that affects how `default_conversion' will behave. */
4051 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
4052 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
4054 /* If this is widening the argument, we can ignore it. */
4055 if (TYPE_PRECISION (TREE_TYPE (expr))
4056 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
4057 return c_common_truthvalue_conversion (location,
4058 TREE_OPERAND (expr, 0));
4062 if (!TREE_NO_WARNING (expr)
4063 && warn_parentheses)
4065 warning (OPT_Wparentheses,
4066 "suggest parentheses around assignment used as truth value");
4067 TREE_NO_WARNING (expr) = 1;
4075 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
4077 tree t = c_save_expr (expr);
4078 return (build_binary_op
4079 (EXPR_LOCATION (expr),
4080 (TREE_SIDE_EFFECTS (expr)
4081 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4082 c_common_truthvalue_conversion
4084 build_unary_op (location, REALPART_EXPR, t, 0)),
4085 c_common_truthvalue_conversion
4087 build_unary_op (location, IMAGPART_EXPR, t, 0)),
4091 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
4093 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
4095 (TREE_TYPE (expr))));
4096 return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
4099 return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
4102 static void def_builtin_1 (enum built_in_function fncode,
4104 enum built_in_class fnclass,
4105 tree fntype, tree libtype,
4106 bool both_p, bool fallback_p, bool nonansi_p,
4107 tree fnattrs, bool implicit_p);
4110 /* Apply the TYPE_QUALS to the new DECL. */
4113 c_apply_type_quals_to_decl (int type_quals, tree decl)
4115 tree type = TREE_TYPE (decl);
4117 if (type == error_mark_node)
4120 if (((type_quals & TYPE_QUAL_CONST)
4121 || (type && TREE_CODE (type) == REFERENCE_TYPE))
4122 /* An object declared 'const' is only readonly after it is
4123 initialized. We don't have any way of expressing this currently,
4124 so we need to be conservative and unset TREE_READONLY for types
4125 with constructors. Otherwise aliasing code will ignore stores in
4126 an inline constructor. */
4127 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
4128 TREE_READONLY (decl) = 1;
4129 if (type_quals & TYPE_QUAL_VOLATILE)
4131 TREE_SIDE_EFFECTS (decl) = 1;
4132 TREE_THIS_VOLATILE (decl) = 1;
4134 if (type_quals & TYPE_QUAL_RESTRICT)
4136 while (type && TREE_CODE (type) == ARRAY_TYPE)
4137 /* Allow 'restrict' on arrays of pointers.
4138 FIXME currently we just ignore it. */
4139 type = TREE_TYPE (type);
4141 || !POINTER_TYPE_P (type)
4142 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
4143 error ("invalid use of %<restrict%>");
4144 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
4145 /* Indicate we need to make a unique alias set for this pointer.
4146 We can't do it here because it might be pointing to an
4148 DECL_POINTER_ALIAS_SET (decl) = -2;
4152 /* Hash function for the problem of multiple type definitions in
4153 different files. This must hash all types that will compare
4154 equal via comptypes to the same value. In practice it hashes
4155 on some of the simple stuff and leaves the details to comptypes. */
4158 c_type_hash (const void *p)
4162 const_tree const t = (const_tree) p;
4164 switch (TREE_CODE (t))
4166 /* For pointers, hash on pointee type plus some swizzling. */
4168 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4169 /* Hash on number of elements and total size. */
4172 t2 = TYPE_VALUES (t);
4176 t2 = TYPE_FIELDS (t);
4178 case QUAL_UNION_TYPE:
4180 t2 = TYPE_FIELDS (t);
4184 t2 = TYPE_FIELDS (t);
4189 for (; t2; t2 = TREE_CHAIN (t2))
4191 /* We might have a VLA here. */
4192 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4195 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
4196 return ((size << 24) | (i << shift));
4199 static GTY((param_is (union tree_node))) htab_t type_hash_table;
4201 /* Return the typed-based alias set for T, which may be an expression
4202 or a type. Return -1 if we don't do anything special. */
4205 c_common_get_alias_set (tree t)
4210 /* Permit type-punning when accessing a union, provided the access
4211 is directly through the union. For example, this code does not
4212 permit taking the address of a union member and then storing
4213 through it. Even the type-punning allowed here is a GCC
4214 extension, albeit a common and useful one; the C standard says
4215 that such accesses have implementation-defined behavior. */
4217 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4218 u = TREE_OPERAND (u, 0))
4219 if (TREE_CODE (u) == COMPONENT_REF
4220 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4223 /* That's all the expressions we handle specially. */
4227 /* The C standard guarantees that any object may be accessed via an
4228 lvalue that has character type. */
4229 if (t == char_type_node
4230 || t == signed_char_type_node
4231 || t == unsigned_char_type_node)
4234 /* The C standard specifically allows aliasing between signed and
4235 unsigned variants of the same type. We treat the signed
4236 variant as canonical. */
4237 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4239 tree t1 = c_common_signed_type (t);
4241 /* t1 == t can happen for boolean nodes which are always unsigned. */
4243 return get_alias_set (t1);
4245 else if (POINTER_TYPE_P (t))
4249 /* Unfortunately, there is no canonical form of a pointer type.
4250 In particular, if we have `typedef int I', then `int *', and
4251 `I *' are different types. So, we have to pick a canonical
4252 representative. We do this below.
4254 Technically, this approach is actually more conservative that
4255 it needs to be. In particular, `const int *' and `int *'
4256 should be in different alias sets, according to the C and C++
4257 standard, since their types are not the same, and so,
4258 technically, an `int **' and `const int **' cannot point at
4261 But, the standard is wrong. In particular, this code is
4266 const int* const* cipp = ipp;
4268 And, it doesn't make sense for that to be legal unless you
4269 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4270 the pointed-to types. This issue has been reported to the
4272 t1 = build_type_no_quals (t);
4274 return get_alias_set (t1);
4277 /* Handle the case of multiple type nodes referring to "the same" type,
4278 which occurs with IMA. These share an alias set. FIXME: Currently only
4279 C90 is handled. (In C99 type compatibility is not transitive, which
4280 complicates things mightily. The alias set splay trees can theoretically
4281 represent this, but insertion is tricky when you consider all the
4282 different orders things might arrive in.) */
4284 if (c_language != clk_c || flag_isoc99)
4287 /* Save time if there's only one input file. */
4288 if (num_in_fnames == 1)
4291 /* Pointers need special handling if they point to any type that
4292 needs special handling (below). */
4293 if (TREE_CODE (t) == POINTER_TYPE)
4296 /* Find bottom type under any nested POINTERs. */
4297 for (t2 = TREE_TYPE (t);
4298 TREE_CODE (t2) == POINTER_TYPE;
4299 t2 = TREE_TYPE (t2))
4301 if (TREE_CODE (t2) != RECORD_TYPE
4302 && TREE_CODE (t2) != ENUMERAL_TYPE
4303 && TREE_CODE (t2) != QUAL_UNION_TYPE
4304 && TREE_CODE (t2) != UNION_TYPE)
4306 if (TYPE_SIZE (t2) == 0)
4309 /* These are the only cases that need special handling. */
4310 if (TREE_CODE (t) != RECORD_TYPE
4311 && TREE_CODE (t) != ENUMERAL_TYPE
4312 && TREE_CODE (t) != QUAL_UNION_TYPE
4313 && TREE_CODE (t) != UNION_TYPE
4314 && TREE_CODE (t) != POINTER_TYPE)
4317 if (TYPE_SIZE (t) == 0)
4320 /* Look up t in hash table. Only one of the compatible types within each
4321 alias set is recorded in the table. */
4322 if (!type_hash_table)
4323 type_hash_table = htab_create_ggc (1021, c_type_hash,
4324 (htab_eq) lang_hooks.types_compatible_p,
4326 slot = htab_find_slot (type_hash_table, t, INSERT);
4329 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4330 return TYPE_ALIAS_SET ((tree)*slot);
4333 /* Our caller will assign and record (in t) a new alias set; all we need
4334 to do is remember t in the hash table. */
4340 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
4341 second parameter indicates which OPERATOR is being applied. The COMPLAIN
4342 flag controls whether we should diagnose possibly ill-formed
4343 constructs or not. */
4346 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
4348 const char *op_name;
4350 enum tree_code type_code = TREE_CODE (type);
4352 op_name = is_sizeof ? "sizeof" : "__alignof__";
4354 if (type_code == FUNCTION_TYPE)
4358 if (complain && (pedantic || warn_pointer_arith))
4359 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4360 "invalid application of %<sizeof%> to a function type");
4362 return error_mark_node;
4363 value = size_one_node;
4366 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4368 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4370 if (type_code == VOID_TYPE
4371 && complain && (pedantic || warn_pointer_arith))
4372 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4373 "invalid application of %qs to a void type", op_name);
4375 return error_mark_node;
4376 value = size_one_node;
4378 else if (!COMPLETE_TYPE_P (type))
4381 error ("invalid application of %qs to incomplete type %qT ",
4383 value = size_zero_node;
4388 /* Convert in case a char is more than one unit. */
4389 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4390 size_int (TYPE_PRECISION (char_type_node)
4393 value = size_int (TYPE_ALIGN_UNIT (type));
4396 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4397 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4398 never happen. However, this node should really have type
4399 `size_t', which is just a typedef for an ordinary integer type. */
4400 value = fold_convert (size_type_node, value);
4401 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
4406 /* Implement the __alignof keyword: Return the minimum required
4407 alignment of EXPR, measured in bytes. For VAR_DECLs,
4408 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4409 from an "aligned" __attribute__ specification). */
4412 c_alignof_expr (tree expr)
4416 if (VAR_OR_FUNCTION_DECL_P (expr))
4417 t = size_int (DECL_ALIGN_UNIT (expr));
4419 else if (TREE_CODE (expr) == COMPONENT_REF
4420 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4422 error ("%<__alignof%> applied to a bit-field");
4425 else if (TREE_CODE (expr) == COMPONENT_REF
4426 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
4427 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
4429 else if (TREE_CODE (expr) == INDIRECT_REF)
4431 tree t = TREE_OPERAND (expr, 0);
4433 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4435 while (CONVERT_EXPR_P (t)
4436 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
4440 t = TREE_OPERAND (t, 0);
4441 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4442 if (thisalign > bestalign)
4443 best = t, bestalign = thisalign;
4445 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
4448 return c_alignof (TREE_TYPE (expr));
4450 return fold_convert (size_type_node, t);
4453 /* Handle C and C++ default attributes. */
4455 enum built_in_attribute
4457 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4458 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4459 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4460 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4461 #include "builtin-attrs.def"
4462 #undef DEF_ATTR_NULL_TREE
4464 #undef DEF_ATTR_IDENT
4465 #undef DEF_ATTR_TREE_LIST
4469 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4471 static void c_init_attributes (void);
4475 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4476 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4477 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4478 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4479 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4480 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4481 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4482 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4483 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4484 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4485 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4486 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4487 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4488 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4489 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4491 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4492 #include "builtin-types.def"
4493 #undef DEF_PRIMITIVE_TYPE
4494 #undef DEF_FUNCTION_TYPE_0
4495 #undef DEF_FUNCTION_TYPE_1
4496 #undef DEF_FUNCTION_TYPE_2
4497 #undef DEF_FUNCTION_TYPE_3
4498 #undef DEF_FUNCTION_TYPE_4
4499 #undef DEF_FUNCTION_TYPE_5
4500 #undef DEF_FUNCTION_TYPE_6
4501 #undef DEF_FUNCTION_TYPE_7
4502 #undef DEF_FUNCTION_TYPE_VAR_0
4503 #undef DEF_FUNCTION_TYPE_VAR_1
4504 #undef DEF_FUNCTION_TYPE_VAR_2
4505 #undef DEF_FUNCTION_TYPE_VAR_3
4506 #undef DEF_FUNCTION_TYPE_VAR_4
4507 #undef DEF_FUNCTION_TYPE_VAR_5
4508 #undef DEF_POINTER_TYPE
4512 typedef enum c_builtin_type builtin_type;
4514 /* A temporary array for c_common_nodes_and_builtins. Used in
4515 communication with def_fn_type. */
4516 static tree builtin_types[(int) BT_LAST + 1];
4518 /* A helper function for c_common_nodes_and_builtins. Build function type
4519 for DEF with return type RET and N arguments. If VAR is true, then the
4520 function should be variadic after those N arguments.
4522 Takes special care not to ICE if any of the types involved are
4523 error_mark_node, which indicates that said type is not in fact available
4524 (see builtin_type_for_size). In which case the function type as a whole
4525 should be error_mark_node. */
4528 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4530 tree args = NULL, t;
4535 for (i = 0; i < n; ++i)
4537 builtin_type a = (builtin_type) va_arg (list, int);
4538 t = builtin_types[a];
4539 if (t == error_mark_node)
4541 args = tree_cons (NULL_TREE, t, args);
4545 args = nreverse (args);
4547 args = chainon (args, void_list_node);
4549 t = builtin_types[ret];
4550 if (t == error_mark_node)
4552 t = build_function_type (t, args);
4555 builtin_types[def] = t;
4558 /* Build builtin functions common to both C and C++ language
4562 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4564 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4565 builtin_types[ENUM] = VALUE;
4566 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4567 def_fn_type (ENUM, RETURN, 0, 0);
4568 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4569 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4570 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4571 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4572 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4573 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4574 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4575 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4576 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4577 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4578 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4580 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4581 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4583 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4584 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4585 def_fn_type (ENUM, RETURN, 1, 0);
4586 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4587 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4588 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4589 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4590 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4591 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4592 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4593 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4594 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4595 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4596 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4597 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4599 #include "builtin-types.def"
4601 #undef DEF_PRIMITIVE_TYPE
4602 #undef DEF_FUNCTION_TYPE_1
4603 #undef DEF_FUNCTION_TYPE_2
4604 #undef DEF_FUNCTION_TYPE_3
4605 #undef DEF_FUNCTION_TYPE_4
4606 #undef DEF_FUNCTION_TYPE_5
4607 #undef DEF_FUNCTION_TYPE_6
4608 #undef DEF_FUNCTION_TYPE_VAR_0
4609 #undef DEF_FUNCTION_TYPE_VAR_1
4610 #undef DEF_FUNCTION_TYPE_VAR_2
4611 #undef DEF_FUNCTION_TYPE_VAR_3
4612 #undef DEF_FUNCTION_TYPE_VAR_4
4613 #undef DEF_FUNCTION_TYPE_VAR_5
4614 #undef DEF_POINTER_TYPE
4615 builtin_types[(int) BT_LAST] = NULL_TREE;
4617 c_init_attributes ();
4619 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4620 NONANSI_P, ATTRS, IMPLICIT, COND) \
4622 def_builtin_1 (ENUM, NAME, CLASS, \
4623 builtin_types[(int) TYPE], \
4624 builtin_types[(int) LIBTYPE], \
4625 BOTH_P, FALLBACK_P, NONANSI_P, \
4626 built_in_attributes[(int) ATTRS], IMPLICIT);
4627 #include "builtins.def"
4630 targetm.init_builtins ();
4632 build_common_builtin_nodes ();
4638 /* Like get_identifier, but avoid warnings about null arguments when
4639 the argument may be NULL for targets where GCC lacks stdint.h type
4643 c_get_ident (const char *id)
4645 return get_identifier (id);
4648 /* Build tree nodes and builtin functions common to both C and C++ language
4652 c_common_nodes_and_builtins (void)
4654 int char16_type_size;
4655 int char32_type_size;
4656 int wchar_type_size;
4657 tree array_domain_type;
4658 tree va_list_ref_type_node;
4659 tree va_list_arg_type_node;
4661 /* Define `int' and `char' first so that dbx will output them first. */
4662 record_builtin_type (RID_INT, NULL, integer_type_node);
4663 record_builtin_type (RID_CHAR, "char", char_type_node);
4665 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4666 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4667 but not C. Are the conditionals here needed? */
4668 if (c_dialect_cxx ())
4669 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4670 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4671 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4672 record_builtin_type (RID_MAX, "long unsigned int",
4673 long_unsigned_type_node);
4674 if (c_dialect_cxx ())
4675 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4676 record_builtin_type (RID_MAX, "long long int",
4677 long_long_integer_type_node);
4678 record_builtin_type (RID_MAX, "long long unsigned int",
4679 long_long_unsigned_type_node);
4680 if (c_dialect_cxx ())
4681 record_builtin_type (RID_MAX, "long long unsigned",
4682 long_long_unsigned_type_node);
4683 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4684 record_builtin_type (RID_MAX, "short unsigned int",
4685 short_unsigned_type_node);
4686 if (c_dialect_cxx ())
4687 record_builtin_type (RID_MAX, "unsigned short",
4688 short_unsigned_type_node);
4690 /* Define both `signed char' and `unsigned char'. */
4691 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4692 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4694 /* These are types that c_common_type_for_size and
4695 c_common_type_for_mode use. */
4696 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4698 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4700 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4702 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4704 #if HOST_BITS_PER_WIDE_INT >= 64
4705 if (targetm.scalar_mode_supported_p (TImode))
4706 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4707 get_identifier ("__int128_t"),
4710 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4711 unsigned_intQI_type_node));
4712 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4713 unsigned_intHI_type_node));
4714 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4715 unsigned_intSI_type_node));
4716 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4717 unsigned_intDI_type_node));
4718 #if HOST_BITS_PER_WIDE_INT >= 64
4719 if (targetm.scalar_mode_supported_p (TImode))
4720 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4721 get_identifier ("__uint128_t"),
4722 unsigned_intTI_type_node));
4725 /* Create the widest literal types. */
4726 widest_integer_literal_type_node
4727 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4728 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4729 widest_integer_literal_type_node));
4731 widest_unsigned_literal_type_node
4732 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4733 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4734 widest_unsigned_literal_type_node));
4736 /* `unsigned long' is the standard type for sizeof.
4737 Note that stddef.h uses `unsigned long',
4738 and this must agree, even if long and int are the same size. */
4740 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4741 signed_size_type_node = c_common_signed_type (size_type_node);
4742 set_sizetype (size_type_node);
4745 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4747 build_common_tree_nodes_2 (flag_short_double);
4749 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4750 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4751 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4753 /* Only supported decimal floating point extension if the target
4754 actually supports underlying modes. */
4755 if (targetm.scalar_mode_supported_p (SDmode)
4756 && targetm.scalar_mode_supported_p (DDmode)
4757 && targetm.scalar_mode_supported_p (TDmode))
4759 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4760 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4761 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4764 if (targetm.fixed_point_supported_p ())
4766 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4767 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4768 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4769 record_builtin_type (RID_MAX, "long long _Fract",
4770 long_long_fract_type_node);
4771 record_builtin_type (RID_MAX, "unsigned short _Fract",
4772 unsigned_short_fract_type_node);
4773 record_builtin_type (RID_MAX, "unsigned _Fract",
4774 unsigned_fract_type_node);
4775 record_builtin_type (RID_MAX, "unsigned long _Fract",
4776 unsigned_long_fract_type_node);
4777 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4778 unsigned_long_long_fract_type_node);
4779 record_builtin_type (RID_MAX, "_Sat short _Fract",
4780 sat_short_fract_type_node);
4781 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4782 record_builtin_type (RID_MAX, "_Sat long _Fract",
4783 sat_long_fract_type_node);
4784 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4785 sat_long_long_fract_type_node);
4786 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4787 sat_unsigned_short_fract_type_node);
4788 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4789 sat_unsigned_fract_type_node);
4790 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4791 sat_unsigned_long_fract_type_node);
4792 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4793 sat_unsigned_long_long_fract_type_node);
4794 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4795 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4796 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4797 record_builtin_type (RID_MAX, "long long _Accum",
4798 long_long_accum_type_node);
4799 record_builtin_type (RID_MAX, "unsigned short _Accum",
4800 unsigned_short_accum_type_node);
4801 record_builtin_type (RID_MAX, "unsigned _Accum",
4802 unsigned_accum_type_node);
4803 record_builtin_type (RID_MAX, "unsigned long _Accum",
4804 unsigned_long_accum_type_node);
4805 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4806 unsigned_long_long_accum_type_node);
4807 record_builtin_type (RID_MAX, "_Sat short _Accum",
4808 sat_short_accum_type_node);
4809 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4810 record_builtin_type (RID_MAX, "_Sat long _Accum",
4811 sat_long_accum_type_node);
4812 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4813 sat_long_long_accum_type_node);
4814 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4815 sat_unsigned_short_accum_type_node);
4816 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4817 sat_unsigned_accum_type_node);
4818 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4819 sat_unsigned_long_accum_type_node);
4820 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4821 sat_unsigned_long_long_accum_type_node);
4825 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4826 get_identifier ("complex int"),
4827 complex_integer_type_node));
4828 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4829 get_identifier ("complex float"),
4830 complex_float_type_node));
4831 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4832 get_identifier ("complex double"),
4833 complex_double_type_node));
4834 lang_hooks.decls.pushdecl
4835 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4836 complex_long_double_type_node));
4838 if (c_dialect_cxx ())
4839 /* For C++, make fileptr_type_node a distinct void * type until
4840 FILE type is defined. */
4841 fileptr_type_node = build_variant_type_copy (ptr_type_node);
4843 record_builtin_type (RID_VOID, NULL, void_type_node);
4845 /* Set the TYPE_NAME for any variants that were built before
4846 record_builtin_type gave names to the built-in types. */
4848 tree void_name = TYPE_NAME (void_type_node);
4849 TYPE_NAME (void_type_node) = NULL_TREE;
4850 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4852 TYPE_NAME (void_type_node) = void_name;
4855 /* This node must not be shared. */
4856 void_zero_node = make_node (INTEGER_CST);
4857 TREE_TYPE (void_zero_node) = void_type_node;
4859 void_list_node = build_void_list_node ();
4861 /* Make a type to be the domain of a few array types
4862 whose domains don't really matter.
4863 200 is small enough that it always fits in size_t
4864 and large enough that it can hold most function names for the
4865 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4866 array_domain_type = build_index_type (size_int (200));
4868 /* Make a type for arrays of characters.
4869 With luck nothing will ever really depend on the length of this
4871 char_array_type_node
4872 = build_array_type (char_type_node, array_domain_type);
4874 /* Likewise for arrays of ints. */
4876 = build_array_type (integer_type_node, array_domain_type);
4878 string_type_node = build_pointer_type (char_type_node);
4879 const_string_type_node
4880 = build_pointer_type (build_qualified_type
4881 (char_type_node, TYPE_QUAL_CONST));
4883 /* This is special for C++ so functions can be overloaded. */
4884 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4885 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4886 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4887 underlying_wchar_type_node = wchar_type_node;
4888 if (c_dialect_cxx ())
4890 if (TYPE_UNSIGNED (wchar_type_node))
4891 wchar_type_node = make_unsigned_type (wchar_type_size);
4893 wchar_type_node = make_signed_type (wchar_type_size);
4894 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4897 /* This is for wide string constants. */
4898 wchar_array_type_node
4899 = build_array_type (wchar_type_node, array_domain_type);
4901 /* Define 'char16_t'. */
4902 char16_type_node = get_identifier (CHAR16_TYPE);
4903 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4904 char16_type_size = TYPE_PRECISION (char16_type_node);
4905 if (c_dialect_cxx ())
4907 char16_type_node = make_unsigned_type (char16_type_size);
4909 if (cxx_dialect == cxx0x)
4910 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4913 /* This is for UTF-16 string constants. */
4914 char16_array_type_node
4915 = build_array_type (char16_type_node, array_domain_type);
4917 /* Define 'char32_t'. */
4918 char32_type_node = get_identifier (CHAR32_TYPE);
4919 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4920 char32_type_size = TYPE_PRECISION (char32_type_node);
4921 if (c_dialect_cxx ())
4923 char32_type_node = make_unsigned_type (char32_type_size);
4925 if (cxx_dialect == cxx0x)
4926 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4929 /* This is for UTF-32 string constants. */
4930 char32_array_type_node
4931 = build_array_type (char32_type_node, array_domain_type);
4934 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4937 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4939 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4941 if (SIG_ATOMIC_TYPE)
4942 sig_atomic_type_node =
4943 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
4946 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
4949 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
4952 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
4955 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
4958 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
4961 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
4963 c_uint32_type_node =
4964 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
4966 c_uint64_type_node =
4967 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
4968 if (INT_LEAST8_TYPE)
4969 int_least8_type_node =
4970 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
4971 if (INT_LEAST16_TYPE)
4972 int_least16_type_node =
4973 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
4974 if (INT_LEAST32_TYPE)
4975 int_least32_type_node =
4976 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
4977 if (INT_LEAST64_TYPE)
4978 int_least64_type_node =
4979 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
4980 if (UINT_LEAST8_TYPE)
4981 uint_least8_type_node =
4982 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
4983 if (UINT_LEAST16_TYPE)
4984 uint_least16_type_node =
4985 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
4986 if (UINT_LEAST32_TYPE)
4987 uint_least32_type_node =
4988 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
4989 if (UINT_LEAST64_TYPE)
4990 uint_least64_type_node =
4991 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
4993 int_fast8_type_node =
4994 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
4995 if (INT_FAST16_TYPE)
4996 int_fast16_type_node =
4997 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
4998 if (INT_FAST32_TYPE)
4999 int_fast32_type_node =
5000 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
5001 if (INT_FAST64_TYPE)
5002 int_fast64_type_node =
5003 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
5004 if (UINT_FAST8_TYPE)
5005 uint_fast8_type_node =
5006 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
5007 if (UINT_FAST16_TYPE)
5008 uint_fast16_type_node =
5009 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
5010 if (UINT_FAST32_TYPE)
5011 uint_fast32_type_node =
5012 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
5013 if (UINT_FAST64_TYPE)
5014 uint_fast64_type_node =
5015 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
5018 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
5021 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
5023 default_function_type = build_function_type (integer_type_node, NULL_TREE);
5025 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
5026 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
5028 lang_hooks.decls.pushdecl
5029 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
5030 va_list_type_node));
5031 #ifdef TARGET_ENUM_VA_LIST
5036 for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
5038 lang_hooks.decls.pushdecl
5039 (build_decl (TYPE_DECL, get_identifier (pname),
5046 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
5048 va_list_arg_type_node = va_list_ref_type_node =
5049 build_pointer_type (TREE_TYPE (va_list_type_node));
5053 va_list_arg_type_node = va_list_type_node;
5054 va_list_ref_type_node = build_reference_type (va_list_type_node);
5057 if (!flag_preprocess_only)
5058 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
5060 main_identifier_node = get_identifier ("main");
5062 /* Create the built-in __null node. It is important that this is
5064 null_node = make_node (INTEGER_CST);
5065 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
5067 /* Since builtin_types isn't gc'ed, don't export these nodes. */
5068 memset (builtin_types, 0, sizeof (builtin_types));
5071 /* Look up the function in built_in_decls that corresponds to DECL
5072 and set ASMSPEC as its user assembler name. DECL must be a
5073 function decl that declares a builtin. */
5076 set_builtin_user_assembler_name (tree decl, const char *asmspec)
5079 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
5080 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
5083 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
5084 set_user_assembler_name (builtin, asmspec);
5085 switch (DECL_FUNCTION_CODE (decl))
5087 case BUILT_IN_MEMCPY:
5088 init_block_move_fn (asmspec);
5089 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
5091 case BUILT_IN_MEMSET:
5092 init_block_clear_fn (asmspec);
5093 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
5095 case BUILT_IN_MEMMOVE:
5096 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
5098 case BUILT_IN_MEMCMP:
5099 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
5101 case BUILT_IN_ABORT:
5102 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
5109 /* The number of named compound-literals generated thus far. */
5110 static GTY(()) int compound_literal_number;
5112 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
5115 set_compound_literal_name (tree decl)
5118 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
5119 compound_literal_number);
5120 compound_literal_number++;
5121 DECL_NAME (decl) = get_identifier (name);
5125 build_va_arg (tree expr, tree type)
5127 return build1 (VA_ARG_EXPR, type, expr);
5131 /* Linked list of disabled built-in functions. */
5133 typedef struct disabled_builtin
5136 struct disabled_builtin *next;
5138 static disabled_builtin *disabled_builtins = NULL;
5140 static bool builtin_function_disabled_p (const char *);
5142 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5143 begins with "__builtin_", give an error. */
5146 disable_builtin_function (const char *name)
5148 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
5149 error ("cannot disable built-in function %qs", name);
5152 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
5153 new_disabled_builtin->name = name;
5154 new_disabled_builtin->next = disabled_builtins;
5155 disabled_builtins = new_disabled_builtin;
5160 /* Return true if the built-in function NAME has been disabled, false
5164 builtin_function_disabled_p (const char *name)
5166 disabled_builtin *p;
5167 for (p = disabled_builtins; p != NULL; p = p->next)
5169 if (strcmp (name, p->name) == 0)
5176 /* Worker for DEF_BUILTIN.
5177 Possibly define a builtin function with one or two names.
5178 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5179 nonansi_p and flag_no_nonansi_builtin. */
5182 def_builtin_1 (enum built_in_function fncode,
5184 enum built_in_class fnclass,
5185 tree fntype, tree libtype,
5186 bool both_p, bool fallback_p, bool nonansi_p,
5187 tree fnattrs, bool implicit_p)
5190 const char *libname;
5192 if (fntype == error_mark_node)
5195 gcc_assert ((!both_p && !fallback_p)
5196 || !strncmp (name, "__builtin_",
5197 strlen ("__builtin_")));
5199 libname = name + strlen ("__builtin_");
5200 decl = add_builtin_function (name, fntype, fncode, fnclass,
5201 (fallback_p ? libname : NULL),
5204 && !flag_no_builtin && !builtin_function_disabled_p (libname)
5205 && !(nonansi_p && flag_no_nonansi_builtin))
5206 add_builtin_function (libname, libtype, fncode, fnclass,
5209 built_in_decls[(int) fncode] = decl;
5211 implicit_built_in_decls[(int) fncode] = decl;
5214 /* Nonzero if the type T promotes to int. This is (nearly) the
5215 integral promotions defined in ISO C99 6.3.1.1/2. */
5218 c_promoting_integer_type_p (const_tree t)
5220 switch (TREE_CODE (t))
5223 return (TYPE_MAIN_VARIANT (t) == char_type_node
5224 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5225 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5226 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
5227 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5228 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
5231 /* ??? Technically all enumerations not larger than an int
5232 promote to an int. But this is used along code paths
5233 that only want to notice a size change. */
5234 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5244 /* Return 1 if PARMS specifies a fixed number of parameters
5245 and none of their types is affected by default promotions. */
5248 self_promoting_args_p (const_tree parms)
5251 for (t = parms; t; t = TREE_CHAIN (t))
5253 tree type = TREE_VALUE (t);
5255 if (type == error_mark_node)
5258 if (TREE_CHAIN (t) == 0 && type != void_type_node)
5264 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5267 if (c_promoting_integer_type_p (type))
5273 /* Recursively remove any '*' or '&' operator from TYPE. */
5275 strip_pointer_operator (tree t)
5277 while (POINTER_TYPE_P (t))
5282 /* Recursively remove pointer or array type from TYPE. */
5284 strip_pointer_or_array_types (tree t)
5286 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5291 /* Used to compare case labels. K1 and K2 are actually tree nodes
5292 representing case labels, or NULL_TREE for a `default' label.
5293 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5294 K2, and 0 if K1 and K2 are equal. */
5297 case_compare (splay_tree_key k1, splay_tree_key k2)
5299 /* Consider a NULL key (such as arises with a `default' label) to be
5300 smaller than anything else. */
5306 return tree_int_cst_compare ((tree) k1, (tree) k2);
5309 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
5310 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
5311 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
5312 case label was declared using the usual C/C++ syntax, rather than
5313 the GNU case range extension. CASES is a tree containing all the
5314 case ranges processed so far; COND is the condition for the
5315 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
5316 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
5319 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
5320 tree low_value, tree high_value)
5325 splay_tree_node node;
5327 /* Create the LABEL_DECL itself. */
5328 label = create_artificial_label ();
5330 /* If there was an error processing the switch condition, bail now
5331 before we get more confused. */
5332 if (!cond || cond == error_mark_node)
5335 if ((low_value && TREE_TYPE (low_value)
5336 && POINTER_TYPE_P (TREE_TYPE (low_value)))
5337 || (high_value && TREE_TYPE (high_value)
5338 && POINTER_TYPE_P (TREE_TYPE (high_value))))
5340 error ("pointers are not permitted as case values");
5344 /* Case ranges are a GNU extension. */
5346 pedwarn (input_location, OPT_pedantic,
5347 "range expressions in switch statements are non-standard");
5349 type = TREE_TYPE (cond);
5352 low_value = check_case_value (low_value);
5353 low_value = convert_and_check (type, low_value);
5354 if (low_value == error_mark_node)
5359 high_value = check_case_value (high_value);
5360 high_value = convert_and_check (type, high_value);
5361 if (high_value == error_mark_node)
5365 if (low_value && high_value)
5367 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5368 really a case range, even though it was written that way.
5369 Remove the HIGH_VALUE to simplify later processing. */
5370 if (tree_int_cst_equal (low_value, high_value))
5371 high_value = NULL_TREE;
5372 else if (!tree_int_cst_lt (low_value, high_value))
5373 warning (0, "empty range specified");
5376 /* See if the case is in range of the type of the original testing
5377 expression. If both low_value and high_value are out of range,
5378 don't insert the case label and return NULL_TREE. */
5380 && !check_case_bounds (type, orig_type,
5381 &low_value, high_value ? &high_value : NULL))
5384 /* Look up the LOW_VALUE in the table of case labels we already
5386 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5387 /* If there was not an exact match, check for overlapping ranges.
5388 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5389 that's a `default' label and the only overlap is an exact match. */
5390 if (!node && (low_value || high_value))
5392 splay_tree_node low_bound;
5393 splay_tree_node high_bound;
5395 /* Even though there wasn't an exact match, there might be an
5396 overlap between this case range and another case range.
5397 Since we've (inductively) not allowed any overlapping case
5398 ranges, we simply need to find the greatest low case label
5399 that is smaller that LOW_VALUE, and the smallest low case
5400 label that is greater than LOW_VALUE. If there is an overlap
5401 it will occur in one of these two ranges. */
5402 low_bound = splay_tree_predecessor (cases,
5403 (splay_tree_key) low_value);
5404 high_bound = splay_tree_successor (cases,
5405 (splay_tree_key) low_value);
5407 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5408 the LOW_VALUE, so there is no need to check unless the
5409 LOW_BOUND is in fact itself a case range. */
5411 && CASE_HIGH ((tree) low_bound->value)
5412 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5415 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5416 range is bigger than the low end of the current range, so we
5417 are only interested if the current range is a real range, and
5418 not an ordinary case label. */
5421 && (tree_int_cst_compare ((tree) high_bound->key,
5426 /* If there was an overlap, issue an error. */
5429 tree duplicate = CASE_LABEL ((tree) node->value);
5433 error ("duplicate (or overlapping) case value");
5434 error ("%Jthis is the first entry overlapping that value", duplicate);
5438 error ("duplicate case value") ;
5439 error ("%Jpreviously used here", duplicate);
5443 error ("multiple default labels in one switch");
5444 error ("%Jthis is the first default label", duplicate);
5449 /* Add a CASE_LABEL to the statement-tree. */
5450 case_label = add_stmt (build_case_label (low_value, high_value, label));
5451 /* Register this case label in the splay tree. */
5452 splay_tree_insert (cases,
5453 (splay_tree_key) low_value,
5454 (splay_tree_value) case_label);
5459 /* Add a label so that the back-end doesn't think that the beginning of
5460 the switch is unreachable. Note that we do not add a case label, as
5461 that just leads to duplicates and thence to failure later on. */
5464 tree t = create_artificial_label ();
5465 add_stmt (build_stmt (LABEL_EXPR, t));
5467 return error_mark_node;
5470 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5471 Used to verify that case values match up with enumerator values. */
5474 match_case_to_enum_1 (tree key, tree type, tree label)
5476 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5478 /* ??? Not working too hard to print the double-word value.
5479 Should perhaps be done with %lwd in the diagnostic routines? */
5480 if (TREE_INT_CST_HIGH (key) == 0)
5481 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5482 TREE_INT_CST_LOW (key));
5483 else if (!TYPE_UNSIGNED (type)
5484 && TREE_INT_CST_HIGH (key) == -1
5485 && TREE_INT_CST_LOW (key) != 0)
5486 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5487 -TREE_INT_CST_LOW (key));
5489 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5490 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5491 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
5493 if (TYPE_NAME (type) == 0)
5494 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5495 "%Jcase value %qs not in enumerated type",
5496 CASE_LABEL (label), buf);
5498 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5499 "%Jcase value %qs not in enumerated type %qT",
5500 CASE_LABEL (label), buf, type);
5503 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5504 Used to verify that case values match up with enumerator values. */
5507 match_case_to_enum (splay_tree_node node, void *data)
5509 tree label = (tree) node->value;
5510 tree type = (tree) data;
5512 /* Skip default case. */
5513 if (!CASE_LOW (label))
5516 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5517 when we did our enum->case scan. Reset our scratch bit after. */
5518 if (!CASE_LOW_SEEN (label))
5519 match_case_to_enum_1 (CASE_LOW (label), type, label);
5521 CASE_LOW_SEEN (label) = 0;
5523 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5524 not set, that means that CASE_HIGH did not appear when we did our
5525 enum->case scan. Reset our scratch bit after. */
5526 if (CASE_HIGH (label))
5528 if (!CASE_HIGH_SEEN (label))
5529 match_case_to_enum_1 (CASE_HIGH (label), type, label);
5531 CASE_HIGH_SEEN (label) = 0;
5537 /* Handle -Wswitch*. Called from the front end after parsing the
5538 switch construct. */
5539 /* ??? Should probably be somewhere generic, since other languages
5540 besides C and C++ would want this. At the moment, however, C/C++
5541 are the only tree-ssa languages that support enumerations at all,
5542 so the point is moot. */
5545 c_do_switch_warnings (splay_tree cases, location_t switch_location,
5546 tree type, tree cond)
5548 splay_tree_node default_node;
5549 splay_tree_node node;
5551 int saved_warn_switch;
5553 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5556 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
5558 warning (OPT_Wswitch_default, "%Hswitch missing default case",
5561 /* From here on, we only care about about enumerated types. */
5562 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5565 /* If the switch expression was an enumerated type, check that
5566 exactly all enumeration literals are covered by the cases.
5567 The check is made when -Wswitch was specified and there is no
5568 default case, or when -Wswitch-enum was specified. */
5570 if (!warn_switch_enum
5571 && !(warn_switch && !default_node))
5574 /* Clearing COND if it is not an integer constant simplifies
5575 the tests inside the loop below. */
5576 if (TREE_CODE (cond) != INTEGER_CST)
5579 /* The time complexity here is O(N*lg(N)) worst case, but for the
5580 common case of monotonically increasing enumerators, it is
5581 O(N), since the nature of the splay tree will keep the next
5582 element adjacent to the root at all times. */
5584 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5586 tree value = TREE_VALUE (chain);
5587 if (TREE_CODE (value) == CONST_DECL)
5588 value = DECL_INITIAL (value);
5589 node = splay_tree_lookup (cases, (splay_tree_key) value);
5592 /* Mark the CASE_LOW part of the case entry as seen. */
5593 tree label = (tree) node->value;
5594 CASE_LOW_SEEN (label) = 1;
5598 /* Even though there wasn't an exact match, there might be a
5599 case range which includes the enumerator's value. */
5600 node = splay_tree_predecessor (cases, (splay_tree_key) value);
5601 if (node && CASE_HIGH ((tree) node->value))
5603 tree label = (tree) node->value;
5604 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5607 /* If we match the upper bound exactly, mark the CASE_HIGH
5608 part of the case entry as seen. */
5610 CASE_HIGH_SEEN (label) = 1;
5615 /* We've now determined that this enumerated literal isn't
5616 handled by the case labels of the switch statement. */
5618 /* If the switch expression is a constant, we only really care
5619 about whether that constant is handled by the switch. */
5620 if (cond && tree_int_cst_compare (cond, value))
5623 /* If there is a default_node, the only relevant option is
5624 Wswitch-enum. Otherwise, if both are enabled then we prefer
5625 to warn using -Wswitch because -Wswitch is enabled by -Wall
5626 while -Wswitch-enum is explicit. */
5627 warning ((default_node || !warn_switch)
5628 ? OPT_Wswitch_enum : OPT_Wswitch,
5629 "%Henumeration value %qE not handled in switch",
5630 &switch_location, TREE_PURPOSE (chain));
5633 /* Warn if there are case expressions that don't correspond to
5634 enumerators. This can occur since C and C++ don't enforce
5635 type-checking of assignments to enumeration variables.
5637 The time complexity here is now always O(N) worst case, since
5638 we should have marked both the lower bound and upper bound of
5639 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5640 above. This scan also resets those fields. */
5642 /* If there is a default_node, the only relevant option is
5643 Wswitch-enum. Otherwise, if both are enabled then we prefer
5644 to warn using -Wswitch because -Wswitch is enabled by -Wall
5645 while -Wswitch-enum is explicit. */
5646 saved_warn_switch = warn_switch;
5649 splay_tree_foreach (cases, match_case_to_enum, type);
5650 warn_switch = saved_warn_switch;
5654 /* Finish an expression taking the address of LABEL (an
5655 IDENTIFIER_NODE). Returns an expression for the address.
5657 LOC is the location for the expression returned. */
5660 finish_label_address_expr (tree label, location_t loc)
5664 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5666 if (label == error_mark_node)
5667 return error_mark_node;
5669 label = lookup_label (label);
5670 if (label == NULL_TREE)
5671 result = null_pointer_node;
5674 TREE_USED (label) = 1;
5675 result = build1 (ADDR_EXPR, ptr_type_node, label);
5676 /* The current function in not necessarily uninlinable.
5677 Computed gotos are incompatible with inlining, but the value
5678 here could be used only in a diagnostic, for example. */
5679 protected_set_expr_location (result, loc);
5686 /* Given a boolean expression ARG, return a tree representing an increment
5687 or decrement (as indicated by CODE) of ARG. The front end must check for
5688 invalid cases (e.g., decrement in C++). */
5690 boolean_increment (enum tree_code code, tree arg)
5693 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5695 arg = stabilize_reference (arg);
5698 case PREINCREMENT_EXPR:
5699 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5701 case POSTINCREMENT_EXPR:
5702 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5703 arg = save_expr (arg);
5704 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5705 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5707 case PREDECREMENT_EXPR:
5708 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5709 invert_truthvalue (arg));
5711 case POSTDECREMENT_EXPR:
5712 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5713 invert_truthvalue (arg));
5714 arg = save_expr (arg);
5715 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5716 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5721 TREE_SIDE_EFFECTS (val) = 1;
5725 /* Built-in macros for stddef.h and stdint.h, that require macros
5726 defined in this file. */
5728 c_stddef_cpp_builtins(void)
5730 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5731 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5732 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5733 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5734 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5735 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5736 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5737 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5738 if (SIG_ATOMIC_TYPE)
5739 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5741 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5743 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5745 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5747 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5749 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5751 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5753 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5755 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5756 if (INT_LEAST8_TYPE)
5757 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5758 if (INT_LEAST16_TYPE)
5759 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5760 if (INT_LEAST32_TYPE)
5761 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5762 if (INT_LEAST64_TYPE)
5763 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5764 if (UINT_LEAST8_TYPE)
5765 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5766 if (UINT_LEAST16_TYPE)
5767 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5768 if (UINT_LEAST32_TYPE)
5769 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5770 if (UINT_LEAST64_TYPE)
5771 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5773 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5774 if (INT_FAST16_TYPE)
5775 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5776 if (INT_FAST32_TYPE)
5777 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5778 if (INT_FAST64_TYPE)
5779 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5780 if (UINT_FAST8_TYPE)
5781 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5782 if (UINT_FAST16_TYPE)
5783 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5784 if (UINT_FAST32_TYPE)
5785 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5786 if (UINT_FAST64_TYPE)
5787 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5789 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5791 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
5795 c_init_attributes (void)
5797 /* Fill in the built_in_attributes array. */
5798 #define DEF_ATTR_NULL_TREE(ENUM) \
5799 built_in_attributes[(int) ENUM] = NULL_TREE;
5800 #define DEF_ATTR_INT(ENUM, VALUE) \
5801 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5802 #define DEF_ATTR_IDENT(ENUM, STRING) \
5803 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5804 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5805 built_in_attributes[(int) ENUM] \
5806 = tree_cons (built_in_attributes[(int) PURPOSE], \
5807 built_in_attributes[(int) VALUE], \
5808 built_in_attributes[(int) CHAIN]);
5809 #include "builtin-attrs.def"
5810 #undef DEF_ATTR_NULL_TREE
5812 #undef DEF_ATTR_IDENT
5813 #undef DEF_ATTR_TREE_LIST
5816 /* Attribute handlers common to C front ends. */
5818 /* Handle a "packed" attribute; arguments as in
5819 struct attribute_spec.handler. */
5822 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5823 int flags, bool *no_add_attrs)
5827 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5828 *node = build_variant_type_copy (*node);
5829 TYPE_PACKED (*node) = 1;
5831 else if (TREE_CODE (*node) == FIELD_DECL)
5833 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5834 /* Still pack bitfields. */
5835 && ! DECL_INITIAL (*node))
5836 warning (OPT_Wattributes,
5837 "%qE attribute ignored for field of type %qT",
5838 name, TREE_TYPE (*node));
5840 DECL_PACKED (*node) = 1;
5842 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5843 used for DECL_REGISTER. It wouldn't mean anything anyway.
5844 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5845 that changes what the typedef is typing. */
5848 warning (OPT_Wattributes, "%qE attribute ignored", name);
5849 *no_add_attrs = true;
5855 /* Handle a "nocommon" attribute; arguments as in
5856 struct attribute_spec.handler. */
5859 handle_nocommon_attribute (tree *node, tree name,
5860 tree ARG_UNUSED (args),
5861 int ARG_UNUSED (flags), bool *no_add_attrs)
5863 if (TREE_CODE (*node) == VAR_DECL)
5864 DECL_COMMON (*node) = 0;
5867 warning (OPT_Wattributes, "%qE attribute ignored", name);
5868 *no_add_attrs = true;
5874 /* Handle a "common" attribute; arguments as in
5875 struct attribute_spec.handler. */
5878 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5879 int ARG_UNUSED (flags), bool *no_add_attrs)
5881 if (TREE_CODE (*node) == VAR_DECL)
5882 DECL_COMMON (*node) = 1;
5885 warning (OPT_Wattributes, "%qE attribute ignored", name);
5886 *no_add_attrs = true;
5892 /* Handle a "noreturn" attribute; arguments as in
5893 struct attribute_spec.handler. */
5896 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5897 int ARG_UNUSED (flags), bool *no_add_attrs)
5899 tree type = TREE_TYPE (*node);
5901 /* See FIXME comment in c_common_attribute_table. */
5902 if (TREE_CODE (*node) == FUNCTION_DECL)
5903 TREE_THIS_VOLATILE (*node) = 1;
5904 else if (TREE_CODE (type) == POINTER_TYPE
5905 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5907 = build_pointer_type
5908 (build_type_variant (TREE_TYPE (type),
5909 TYPE_READONLY (TREE_TYPE (type)), 1));
5912 warning (OPT_Wattributes, "%qE attribute ignored", name);
5913 *no_add_attrs = true;
5919 /* Handle a "hot" and attribute; arguments as in
5920 struct attribute_spec.handler. */
5923 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5924 int ARG_UNUSED (flags), bool *no_add_attrs)
5926 if (TREE_CODE (*node) == FUNCTION_DECL)
5928 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5930 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5932 *no_add_attrs = true;
5934 /* Most of the rest of the hot processing is done later with
5935 lookup_attribute. */
5939 warning (OPT_Wattributes, "%qE attribute ignored", name);
5940 *no_add_attrs = true;
5945 /* Handle a "cold" and attribute; arguments as in
5946 struct attribute_spec.handler. */
5949 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5950 int ARG_UNUSED (flags), bool *no_add_attrs)
5952 if (TREE_CODE (*node) == FUNCTION_DECL)
5954 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5956 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5958 *no_add_attrs = true;
5960 /* Most of the rest of the cold processing is done later with
5961 lookup_attribute. */
5965 warning (OPT_Wattributes, "%qE attribute ignored", name);
5966 *no_add_attrs = true;
5972 /* Handle a "noinline" attribute; arguments as in
5973 struct attribute_spec.handler. */
5976 handle_noinline_attribute (tree *node, tree name,
5977 tree ARG_UNUSED (args),
5978 int ARG_UNUSED (flags), bool *no_add_attrs)
5980 if (TREE_CODE (*node) == FUNCTION_DECL)
5981 DECL_UNINLINABLE (*node) = 1;
5984 warning (OPT_Wattributes, "%qE attribute ignored", name);
5985 *no_add_attrs = true;
5991 /* Handle a "always_inline" attribute; arguments as in
5992 struct attribute_spec.handler. */
5995 handle_always_inline_attribute (tree *node, tree name,
5996 tree ARG_UNUSED (args),
5997 int ARG_UNUSED (flags),
6000 if (TREE_CODE (*node) == FUNCTION_DECL)
6002 /* Set the attribute and mark it for disregarding inline
6004 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
6008 warning (OPT_Wattributes, "%qE attribute ignored", name);
6009 *no_add_attrs = true;
6015 /* Handle a "gnu_inline" attribute; arguments as in
6016 struct attribute_spec.handler. */
6019 handle_gnu_inline_attribute (tree *node, tree name,
6020 tree ARG_UNUSED (args),
6021 int ARG_UNUSED (flags),
6024 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6026 /* Do nothing else, just set the attribute. We'll get at
6027 it later with lookup_attribute. */
6031 warning (OPT_Wattributes, "%qE attribute ignored", name);
6032 *no_add_attrs = true;
6038 /* Handle an "artificial" attribute; arguments as in
6039 struct attribute_spec.handler. */
6042 handle_artificial_attribute (tree *node, tree name,
6043 tree ARG_UNUSED (args),
6044 int ARG_UNUSED (flags),
6047 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6049 /* Do nothing else, just set the attribute. We'll get at
6050 it later with lookup_attribute. */
6054 warning (OPT_Wattributes, "%qE attribute ignored", name);
6055 *no_add_attrs = true;
6061 /* Handle a "flatten" attribute; arguments as in
6062 struct attribute_spec.handler. */
6065 handle_flatten_attribute (tree *node, tree name,
6066 tree args ATTRIBUTE_UNUSED,
6067 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
6069 if (TREE_CODE (*node) == FUNCTION_DECL)
6070 /* Do nothing else, just set the attribute. We'll get at
6071 it later with lookup_attribute. */
6075 warning (OPT_Wattributes, "%qE attribute ignored", name);
6076 *no_add_attrs = true;
6082 /* Handle a "warning" or "error" attribute; arguments as in
6083 struct attribute_spec.handler. */
6086 handle_error_attribute (tree *node, tree name, tree args,
6087 int ARG_UNUSED (flags), bool *no_add_attrs)
6089 if (TREE_CODE (*node) == FUNCTION_DECL
6090 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6091 /* Do nothing else, just set the attribute. We'll get at
6092 it later with lookup_attribute. */
6096 warning (OPT_Wattributes, "%qE attribute ignored", name);
6097 *no_add_attrs = true;
6103 /* Handle a "used" attribute; arguments as in
6104 struct attribute_spec.handler. */
6107 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6108 int ARG_UNUSED (flags), bool *no_add_attrs)
6112 if (TREE_CODE (node) == FUNCTION_DECL
6113 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
6115 TREE_USED (node) = 1;
6116 DECL_PRESERVE_P (node) = 1;
6120 warning (OPT_Wattributes, "%qE attribute ignored", name);
6121 *no_add_attrs = true;
6127 /* Handle a "unused" attribute; arguments as in
6128 struct attribute_spec.handler. */
6131 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6132 int flags, bool *no_add_attrs)
6138 if (TREE_CODE (decl) == PARM_DECL
6139 || TREE_CODE (decl) == VAR_DECL
6140 || TREE_CODE (decl) == FUNCTION_DECL
6141 || TREE_CODE (decl) == LABEL_DECL
6142 || TREE_CODE (decl) == TYPE_DECL)
6143 TREE_USED (decl) = 1;
6146 warning (OPT_Wattributes, "%qE attribute ignored", name);
6147 *no_add_attrs = true;
6152 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6153 *node = build_variant_type_copy (*node);
6154 TREE_USED (*node) = 1;
6160 /* Handle a "externally_visible" attribute; arguments as in
6161 struct attribute_spec.handler. */
6164 handle_externally_visible_attribute (tree *pnode, tree name,
6165 tree ARG_UNUSED (args),
6166 int ARG_UNUSED (flags),
6171 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
6173 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6174 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6176 warning (OPT_Wattributes,
6177 "%qE attribute have effect only on public objects", name);
6178 *no_add_attrs = true;
6183 warning (OPT_Wattributes, "%qE attribute ignored", name);
6184 *no_add_attrs = true;
6190 /* Handle a "const" attribute; arguments as in
6191 struct attribute_spec.handler. */
6194 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6195 int ARG_UNUSED (flags), bool *no_add_attrs)
6197 tree type = TREE_TYPE (*node);
6199 /* See FIXME comment on noreturn in c_common_attribute_table. */
6200 if (TREE_CODE (*node) == FUNCTION_DECL)
6201 TREE_READONLY (*node) = 1;
6202 else if (TREE_CODE (type) == POINTER_TYPE
6203 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6205 = build_pointer_type
6206 (build_type_variant (TREE_TYPE (type), 1,
6207 TREE_THIS_VOLATILE (TREE_TYPE (type))));
6210 warning (OPT_Wattributes, "%qE attribute ignored", name);
6211 *no_add_attrs = true;
6217 /* Handle a "transparent_union" attribute; arguments as in
6218 struct attribute_spec.handler. */
6221 handle_transparent_union_attribute (tree *node, tree name,
6222 tree ARG_UNUSED (args), int flags,
6227 *no_add_attrs = true;
6229 if (TREE_CODE (*node) == TYPE_DECL)
6230 node = &TREE_TYPE (*node);
6233 if (TREE_CODE (type) == UNION_TYPE)
6235 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6236 the code in finish_struct. */
6237 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6239 if (TYPE_FIELDS (type) == NULL_TREE
6240 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6243 /* A type variant isn't good enough, since we don't a cast
6244 to such a type removed as a no-op. */
6245 *node = type = build_duplicate_type (type);
6248 TYPE_TRANSPARENT_UNION (type) = 1;
6253 warning (OPT_Wattributes, "%qE attribute ignored", name);
6257 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6258 get the requested priority for a constructor or destructor,
6259 possibly issuing diagnostics for invalid or reserved
6262 static priority_type
6263 get_priority (tree args, bool is_destructor)
6269 return DEFAULT_INIT_PRIORITY;
6271 if (!SUPPORTS_INIT_PRIORITY)
6274 error ("destructor priorities are not supported");
6276 error ("constructor priorities are not supported");
6277 return DEFAULT_INIT_PRIORITY;
6280 arg = TREE_VALUE (args);
6281 if (!host_integerp (arg, /*pos=*/0)
6282 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
6285 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6286 if (pri < 0 || pri > MAX_INIT_PRIORITY)
6289 if (pri <= MAX_RESERVED_INIT_PRIORITY)
6293 "destructor priorities from 0 to %d are reserved "
6294 "for the implementation",
6295 MAX_RESERVED_INIT_PRIORITY);
6298 "constructor priorities from 0 to %d are reserved "
6299 "for the implementation",
6300 MAX_RESERVED_INIT_PRIORITY);
6306 error ("destructor priorities must be integers from 0 to %d inclusive",
6309 error ("constructor priorities must be integers from 0 to %d inclusive",
6311 return DEFAULT_INIT_PRIORITY;
6314 /* Handle a "constructor" attribute; arguments as in
6315 struct attribute_spec.handler. */
6318 handle_constructor_attribute (tree *node, tree name, tree args,
6319 int ARG_UNUSED (flags),
6323 tree type = TREE_TYPE (decl);
6325 if (TREE_CODE (decl) == FUNCTION_DECL
6326 && TREE_CODE (type) == FUNCTION_TYPE
6327 && decl_function_context (decl) == 0)
6329 priority_type priority;
6330 DECL_STATIC_CONSTRUCTOR (decl) = 1;
6331 priority = get_priority (args, /*is_destructor=*/false);
6332 SET_DECL_INIT_PRIORITY (decl, priority);
6333 TREE_USED (decl) = 1;
6337 warning (OPT_Wattributes, "%qE attribute ignored", name);
6338 *no_add_attrs = true;
6344 /* Handle a "destructor" attribute; arguments as in
6345 struct attribute_spec.handler. */
6348 handle_destructor_attribute (tree *node, tree name, tree args,
6349 int ARG_UNUSED (flags),
6353 tree type = TREE_TYPE (decl);
6355 if (TREE_CODE (decl) == FUNCTION_DECL
6356 && TREE_CODE (type) == FUNCTION_TYPE
6357 && decl_function_context (decl) == 0)
6359 priority_type priority;
6360 DECL_STATIC_DESTRUCTOR (decl) = 1;
6361 priority = get_priority (args, /*is_destructor=*/true);
6362 SET_DECL_FINI_PRIORITY (decl, priority);
6363 TREE_USED (decl) = 1;
6367 warning (OPT_Wattributes, "%qE attribute ignored", name);
6368 *no_add_attrs = true;
6374 /* Handle a "mode" attribute; arguments as in
6375 struct attribute_spec.handler. */
6378 handle_mode_attribute (tree *node, tree name, tree args,
6379 int ARG_UNUSED (flags), bool *no_add_attrs)
6382 tree ident = TREE_VALUE (args);
6384 *no_add_attrs = true;
6386 if (TREE_CODE (ident) != IDENTIFIER_NODE)
6387 warning (OPT_Wattributes, "%qE attribute ignored", name);
6391 const char *p = IDENTIFIER_POINTER (ident);
6392 int len = strlen (p);
6393 enum machine_mode mode = VOIDmode;
6397 if (len > 4 && p[0] == '_' && p[1] == '_'
6398 && p[len - 1] == '_' && p[len - 2] == '_')
6400 char *newp = (char *) alloca (len - 1);
6402 strcpy (newp, &p[2]);
6403 newp[len - 4] = '\0';
6407 /* Change this type to have a type with the specified mode.
6408 First check for the special modes. */
6409 if (!strcmp (p, "byte"))
6411 else if (!strcmp (p, "word"))
6413 else if (!strcmp (p, "pointer"))
6415 else if (!strcmp (p, "libgcc_cmp_return"))
6416 mode = targetm.libgcc_cmp_return_mode ();
6417 else if (!strcmp (p, "libgcc_shift_count"))
6418 mode = targetm.libgcc_shift_count_mode ();
6419 else if (!strcmp (p, "unwind_word"))
6420 mode = targetm.unwind_word_mode ();
6422 for (j = 0; j < NUM_MACHINE_MODES; j++)
6423 if (!strcmp (p, GET_MODE_NAME (j)))
6425 mode = (enum machine_mode) j;
6429 if (mode == VOIDmode)
6431 error ("unknown machine mode %qE", ident);
6436 switch (GET_MODE_CLASS (mode))
6439 case MODE_PARTIAL_INT:
6441 case MODE_DECIMAL_FLOAT:
6446 valid_mode = targetm.scalar_mode_supported_p (mode);
6449 case MODE_COMPLEX_INT:
6450 case MODE_COMPLEX_FLOAT:
6451 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6454 case MODE_VECTOR_INT:
6455 case MODE_VECTOR_FLOAT:
6456 case MODE_VECTOR_FRACT:
6457 case MODE_VECTOR_UFRACT:
6458 case MODE_VECTOR_ACCUM:
6459 case MODE_VECTOR_UACCUM:
6460 warning (OPT_Wattributes, "specifying vector types with "
6461 "__attribute__ ((mode)) is deprecated");
6462 warning (OPT_Wattributes,
6463 "use __attribute__ ((vector_size)) instead");
6464 valid_mode = vector_mode_valid_p (mode);
6472 error ("unable to emulate %qs", p);
6476 if (POINTER_TYPE_P (type))
6478 tree (*fn)(tree, enum machine_mode, bool);
6480 if (!targetm.valid_pointer_mode (mode))
6482 error ("invalid pointer mode %qs", p);
6486 if (TREE_CODE (type) == POINTER_TYPE)
6487 fn = build_pointer_type_for_mode;
6489 fn = build_reference_type_for_mode;
6490 typefm = fn (TREE_TYPE (type), mode, false);
6494 /* For fixed-point modes, we need to test if the signness of type
6495 and the machine mode are consistent. */
6496 if (ALL_FIXED_POINT_MODE_P (mode)
6497 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6499 error ("signness of type and machine mode %qs don't match", p);
6502 /* For fixed-point modes, we need to pass saturating info. */
6503 typefm = lang_hooks.types.type_for_mode (mode,
6504 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6505 : TYPE_UNSIGNED (type));
6508 if (typefm == NULL_TREE)
6510 error ("no data type for mode %qs", p);
6513 else if (TREE_CODE (type) == ENUMERAL_TYPE)
6515 /* For enumeral types, copy the precision from the integer
6516 type returned above. If not an INTEGER_TYPE, we can't use
6517 this mode for this type. */
6518 if (TREE_CODE (typefm) != INTEGER_TYPE)
6520 error ("cannot use mode %qs for enumeral types", p);
6524 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6526 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6531 /* We cannot build a type variant, as there's code that assumes
6532 that TYPE_MAIN_VARIANT has the same mode. This includes the
6533 debug generators. Instead, create a subrange type. This
6534 results in all of the enumeral values being emitted only once
6535 in the original, and the subtype gets them by reference. */
6536 if (TYPE_UNSIGNED (type))
6537 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6539 typefm = make_signed_type (TYPE_PRECISION (typefm));
6540 TREE_TYPE (typefm) = type;
6543 else if (VECTOR_MODE_P (mode)
6544 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6545 : TREE_CODE (type) != TREE_CODE (typefm))
6547 error ("mode %qs applied to inappropriate type", p);
6557 /* Handle a "section" attribute; arguments as in
6558 struct attribute_spec.handler. */
6561 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6562 int ARG_UNUSED (flags), bool *no_add_attrs)
6566 if (targetm.have_named_sections)
6568 user_defined_section_attribute = true;
6570 if ((TREE_CODE (decl) == FUNCTION_DECL
6571 || TREE_CODE (decl) == VAR_DECL)
6572 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6574 if (TREE_CODE (decl) == VAR_DECL
6575 && current_function_decl != NULL_TREE
6576 && !TREE_STATIC (decl))
6578 error ("%Jsection attribute cannot be specified for "
6579 "local variables", decl);
6580 *no_add_attrs = true;
6583 /* The decl may have already been given a section attribute
6584 from a previous declaration. Ensure they match. */
6585 else if (DECL_SECTION_NAME (decl) != NULL_TREE
6586 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6587 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6589 error ("section of %q+D conflicts with previous declaration",
6591 *no_add_attrs = true;
6593 else if (TREE_CODE (decl) == VAR_DECL
6594 && !targetm.have_tls && targetm.emutls.tmpl_section
6595 && DECL_THREAD_LOCAL_P (decl))
6597 error ("section of %q+D cannot be overridden", *node);
6598 *no_add_attrs = true;
6601 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6605 error ("section attribute not allowed for %q+D", *node);
6606 *no_add_attrs = true;
6611 error ("%Jsection attributes are not supported for this target", *node);
6612 *no_add_attrs = true;
6618 /* Handle a "aligned" attribute; arguments as in
6619 struct attribute_spec.handler. */
6622 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6623 int flags, bool *no_add_attrs)
6625 tree decl = NULL_TREE;
6628 tree align_expr = (args ? TREE_VALUE (args)
6629 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
6635 type = &TREE_TYPE (decl);
6636 is_type = TREE_CODE (*node) == TYPE_DECL;
6638 else if (TYPE_P (*node))
6639 type = node, is_type = 1;
6641 if (TREE_CODE (align_expr) != INTEGER_CST)
6643 error ("requested alignment is not a constant");
6644 *no_add_attrs = true;
6646 else if ((i = tree_log2 (align_expr)) == -1)
6648 error ("requested alignment is not a power of 2");
6649 *no_add_attrs = true;
6651 else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
6653 error ("requested alignment is too large");
6654 *no_add_attrs = true;
6658 /* If we have a TYPE_DECL, then copy the type, so that we
6659 don't accidentally modify a builtin type. See pushdecl. */
6660 if (decl && TREE_TYPE (decl) != error_mark_node
6661 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6663 tree tt = TREE_TYPE (decl);
6664 *type = build_variant_type_copy (*type);
6665 DECL_ORIGINAL_TYPE (decl) = tt;
6666 TYPE_NAME (*type) = decl;
6667 TREE_USED (*type) = TREE_USED (decl);
6668 TREE_TYPE (decl) = *type;
6670 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6671 *type = build_variant_type_copy (*type);
6673 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
6674 TYPE_USER_ALIGN (*type) = 1;
6676 else if (! VAR_OR_FUNCTION_DECL_P (decl)
6677 && TREE_CODE (decl) != FIELD_DECL)
6679 error ("alignment may not be specified for %q+D", decl);
6680 *no_add_attrs = true;
6682 else if (TREE_CODE (decl) == FUNCTION_DECL
6683 && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
6685 if (DECL_USER_ALIGN (decl))
6686 error ("alignment for %q+D was previously specified as %d "
6687 "and may not be decreased", decl,
6688 DECL_ALIGN (decl) / BITS_PER_UNIT);
6690 error ("alignment for %q+D must be at least %d", decl,
6691 DECL_ALIGN (decl) / BITS_PER_UNIT);
6692 *no_add_attrs = true;
6696 DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
6697 DECL_USER_ALIGN (decl) = 1;
6703 /* Handle a "weak" attribute; arguments as in
6704 struct attribute_spec.handler. */
6707 handle_weak_attribute (tree *node, tree name,
6708 tree ARG_UNUSED (args),
6709 int ARG_UNUSED (flags),
6710 bool * ARG_UNUSED (no_add_attrs))
6712 if (TREE_CODE (*node) == FUNCTION_DECL
6713 && DECL_DECLARED_INLINE_P (*node))
6715 error ("inline function %q+D cannot be declared weak", *node);
6716 *no_add_attrs = true;
6718 else if (TREE_CODE (*node) == FUNCTION_DECL
6719 || TREE_CODE (*node) == VAR_DECL)
6720 declare_weak (*node);
6722 warning (OPT_Wattributes, "%qE attribute ignored", name);
6727 /* Handle an "alias" attribute; arguments as in
6728 struct attribute_spec.handler. */
6731 handle_alias_attribute (tree *node, tree name, tree args,
6732 int ARG_UNUSED (flags), bool *no_add_attrs)
6736 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6738 warning (OPT_Wattributes, "%qE attribute ignored", name);
6739 *no_add_attrs = true;
6741 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6742 || (TREE_CODE (decl) != FUNCTION_DECL
6743 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6744 /* A static variable declaration is always a tentative definition,
6745 but the alias is a non-tentative definition which overrides. */
6746 || (TREE_CODE (decl) != FUNCTION_DECL
6747 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6749 error ("%q+D defined both normally and as an alias", decl);
6750 *no_add_attrs = true;
6753 /* Note that the very first time we process a nested declaration,
6754 decl_function_context will not be set. Indeed, *would* never
6755 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6756 we do below. After such frobbery, pushdecl would set the context.
6757 In any case, this is never what we want. */
6758 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6762 id = TREE_VALUE (args);
6763 if (TREE_CODE (id) != STRING_CST)
6765 error ("alias argument not a string");
6766 *no_add_attrs = true;
6769 id = get_identifier (TREE_STRING_POINTER (id));
6770 /* This counts as a use of the object pointed to. */
6773 if (TREE_CODE (decl) == FUNCTION_DECL)
6774 DECL_INITIAL (decl) = error_mark_node;
6777 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6778 DECL_EXTERNAL (decl) = 1;
6780 DECL_EXTERNAL (decl) = 0;
6781 TREE_STATIC (decl) = 1;
6786 warning (OPT_Wattributes, "%qE attribute ignored", name);
6787 *no_add_attrs = true;
6793 /* Handle a "weakref" attribute; arguments as in struct
6794 attribute_spec.handler. */
6797 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6798 int flags, bool *no_add_attrs)
6800 tree attr = NULL_TREE;
6802 /* We must ignore the attribute when it is associated with
6803 local-scoped decls, since attribute alias is ignored and many
6804 such symbols do not even have a DECL_WEAK field. */
6805 if (decl_function_context (*node)
6806 || current_function_decl
6807 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6809 warning (OPT_Wattributes, "%qE attribute ignored", name);
6810 *no_add_attrs = true;
6814 /* The idea here is that `weakref("name")' mutates into `weakref,
6815 alias("name")', and weakref without arguments, in turn,
6816 implicitly adds weak. */
6820 attr = tree_cons (get_identifier ("alias"), args, attr);
6821 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6823 *no_add_attrs = true;
6825 decl_attributes (node, attr, flags);
6829 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6830 error ("%Jweakref attribute must appear before alias attribute",
6833 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6834 and that isn't supported; and because it wants to add it to
6835 the list of weak decls, which isn't helpful. */
6836 DECL_WEAK (*node) = 1;
6842 /* Handle an "visibility" attribute; arguments as in
6843 struct attribute_spec.handler. */
6846 handle_visibility_attribute (tree *node, tree name, tree args,
6847 int ARG_UNUSED (flags),
6848 bool *ARG_UNUSED (no_add_attrs))
6851 tree id = TREE_VALUE (args);
6852 enum symbol_visibility vis;
6856 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6858 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6860 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6864 else if (TYPE_FIELDS (*node))
6866 error ("%qE attribute ignored because %qT is already defined",
6871 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6873 warning (OPT_Wattributes, "%qE attribute ignored", name);
6877 if (TREE_CODE (id) != STRING_CST)
6879 error ("visibility argument not a string");
6883 /* If this is a type, set the visibility on the type decl. */
6886 decl = TYPE_NAME (decl);
6889 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6891 warning (OPT_Wattributes, "%qE attribute ignored on types",
6897 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6898 vis = VISIBILITY_DEFAULT;
6899 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6900 vis = VISIBILITY_INTERNAL;
6901 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6902 vis = VISIBILITY_HIDDEN;
6903 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6904 vis = VISIBILITY_PROTECTED;
6907 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6908 vis = VISIBILITY_DEFAULT;
6911 if (DECL_VISIBILITY_SPECIFIED (decl)
6912 && vis != DECL_VISIBILITY (decl))
6914 tree attributes = (TYPE_P (*node)
6915 ? TYPE_ATTRIBUTES (*node)
6916 : DECL_ATTRIBUTES (decl));
6917 if (lookup_attribute ("visibility", attributes))
6918 error ("%qD redeclared with different visibility", decl);
6919 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6920 && lookup_attribute ("dllimport", attributes))
6921 error ("%qD was declared %qs which implies default visibility",
6923 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6924 && lookup_attribute ("dllexport", attributes))
6925 error ("%qD was declared %qs which implies default visibility",
6929 DECL_VISIBILITY (decl) = vis;
6930 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6932 /* Go ahead and attach the attribute to the node as well. This is needed
6933 so we can determine whether we have VISIBILITY_DEFAULT because the
6934 visibility was not specified, or because it was explicitly overridden
6935 from the containing scope. */
6940 /* Determine the ELF symbol visibility for DECL, which is either a
6941 variable or a function. It is an error to use this function if a
6942 definition of DECL is not available in this translation unit.
6943 Returns true if the final visibility has been determined by this
6944 function; false if the caller is free to make additional
6948 c_determine_visibility (tree decl)
6950 gcc_assert (TREE_CODE (decl) == VAR_DECL
6951 || TREE_CODE (decl) == FUNCTION_DECL);
6953 /* If the user explicitly specified the visibility with an
6954 attribute, honor that. DECL_VISIBILITY will have been set during
6955 the processing of the attribute. We check for an explicit
6956 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6957 to distinguish the use of an attribute from the use of a "#pragma
6958 GCC visibility push(...)"; in the latter case we still want other
6959 considerations to be able to overrule the #pragma. */
6960 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6961 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6962 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6963 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6966 /* Set default visibility to whatever the user supplied with
6967 visibility_specified depending on #pragma GCC visibility. */
6968 if (!DECL_VISIBILITY_SPECIFIED (decl))
6970 if (visibility_options.inpragma
6971 || DECL_VISIBILITY (decl) != default_visibility)
6973 DECL_VISIBILITY (decl) = default_visibility;
6974 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6975 /* If visibility changed and DECL already has DECL_RTL, ensure
6976 symbol flags are updated. */
6977 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6978 || TREE_CODE (decl) == FUNCTION_DECL)
6979 && DECL_RTL_SET_P (decl))
6980 make_decl_rtl (decl);
6986 /* Handle an "tls_model" attribute; arguments as in
6987 struct attribute_spec.handler. */
6990 handle_tls_model_attribute (tree *node, tree name, tree args,
6991 int ARG_UNUSED (flags), bool *no_add_attrs)
6995 enum tls_model kind;
6997 *no_add_attrs = true;
6999 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
7001 warning (OPT_Wattributes, "%qE attribute ignored", name);
7005 kind = DECL_TLS_MODEL (decl);
7006 id = TREE_VALUE (args);
7007 if (TREE_CODE (id) != STRING_CST)
7009 error ("tls_model argument not a string");
7013 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7014 kind = TLS_MODEL_LOCAL_EXEC;
7015 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7016 kind = TLS_MODEL_INITIAL_EXEC;
7017 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7018 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7019 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7020 kind = TLS_MODEL_GLOBAL_DYNAMIC;
7022 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7024 DECL_TLS_MODEL (decl) = kind;
7028 /* Handle a "no_instrument_function" attribute; arguments as in
7029 struct attribute_spec.handler. */
7032 handle_no_instrument_function_attribute (tree *node, tree name,
7033 tree ARG_UNUSED (args),
7034 int ARG_UNUSED (flags),
7039 if (TREE_CODE (decl) != FUNCTION_DECL)
7041 error ("%J%qE attribute applies only to functions", decl, name);
7042 *no_add_attrs = true;
7044 else if (DECL_INITIAL (decl))
7046 error ("%Jcan%'t set %qE attribute after definition", decl, name);
7047 *no_add_attrs = true;
7050 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7055 /* Handle a "malloc" attribute; arguments as in
7056 struct attribute_spec.handler. */
7059 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7060 int ARG_UNUSED (flags), bool *no_add_attrs)
7062 if (TREE_CODE (*node) == FUNCTION_DECL
7063 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
7064 DECL_IS_MALLOC (*node) = 1;
7067 warning (OPT_Wattributes, "%qE attribute ignored", name);
7068 *no_add_attrs = true;
7074 /* Handle a "alloc_size" attribute; arguments as in
7075 struct attribute_spec.handler. */
7078 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7079 int ARG_UNUSED (flags), bool *no_add_attrs)
7081 unsigned arg_count = type_num_arguments (*node);
7082 for (; args; args = TREE_CHAIN (args))
7084 tree position = TREE_VALUE (args);
7086 if (TREE_CODE (position) != INTEGER_CST
7087 || TREE_INT_CST_HIGH (position)
7088 || TREE_INT_CST_LOW (position) < 1
7089 || TREE_INT_CST_LOW (position) > arg_count )
7091 warning (OPT_Wattributes,
7092 "alloc_size parameter outside range");
7093 *no_add_attrs = true;
7100 /* Handle a "returns_twice" attribute; arguments as in
7101 struct attribute_spec.handler. */
7104 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7105 int ARG_UNUSED (flags), bool *no_add_attrs)
7107 if (TREE_CODE (*node) == FUNCTION_DECL)
7108 DECL_IS_RETURNS_TWICE (*node) = 1;
7111 warning (OPT_Wattributes, "%qE attribute ignored", name);
7112 *no_add_attrs = true;
7118 /* Handle a "no_limit_stack" attribute; arguments as in
7119 struct attribute_spec.handler. */
7122 handle_no_limit_stack_attribute (tree *node, tree name,
7123 tree ARG_UNUSED (args),
7124 int ARG_UNUSED (flags),
7129 if (TREE_CODE (decl) != FUNCTION_DECL)
7131 error ("%J%qE attribute applies only to functions", decl, name);
7132 *no_add_attrs = true;
7134 else if (DECL_INITIAL (decl))
7136 error ("%Jcan%'t set %qE attribute after definition", decl, name);
7137 *no_add_attrs = true;
7140 DECL_NO_LIMIT_STACK (decl) = 1;
7145 /* Handle a "pure" attribute; arguments as in
7146 struct attribute_spec.handler. */
7149 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7150 int ARG_UNUSED (flags), bool *no_add_attrs)
7152 if (TREE_CODE (*node) == FUNCTION_DECL)
7153 DECL_PURE_P (*node) = 1;
7154 /* ??? TODO: Support types. */
7157 warning (OPT_Wattributes, "%qE attribute ignored", name);
7158 *no_add_attrs = true;
7164 /* Handle a "no vops" attribute; arguments as in
7165 struct attribute_spec.handler. */
7168 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7169 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7170 bool *ARG_UNUSED (no_add_attrs))
7172 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7173 DECL_IS_NOVOPS (*node) = 1;
7177 /* Handle a "deprecated" attribute; arguments as in
7178 struct attribute_spec.handler. */
7181 handle_deprecated_attribute (tree *node, tree name,
7182 tree args, int flags,
7185 tree type = NULL_TREE;
7187 tree what = NULL_TREE;
7190 *no_add_attrs = true;
7191 else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
7193 error ("deprecated message is not a string");
7194 *no_add_attrs = true;
7200 type = TREE_TYPE (decl);
7202 if (TREE_CODE (decl) == TYPE_DECL
7203 || TREE_CODE (decl) == PARM_DECL
7204 || TREE_CODE (decl) == VAR_DECL
7205 || TREE_CODE (decl) == FUNCTION_DECL
7206 || TREE_CODE (decl) == FIELD_DECL)
7207 TREE_DEPRECATED (decl) = 1;
7211 else if (TYPE_P (*node))
7213 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
7214 *node = build_variant_type_copy (*node);
7215 TREE_DEPRECATED (*node) = 1;
7223 *no_add_attrs = true;
7224 if (type && TYPE_NAME (type))
7226 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7227 what = TYPE_NAME (*node);
7228 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7229 && DECL_NAME (TYPE_NAME (type)))
7230 what = DECL_NAME (TYPE_NAME (type));
7233 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
7235 warning (OPT_Wattributes, "%qE attribute ignored", name);
7241 /* Handle a "vector_size" attribute; arguments as in
7242 struct attribute_spec.handler. */
7245 handle_vector_size_attribute (tree *node, tree name, tree args,
7246 int ARG_UNUSED (flags),
7249 unsigned HOST_WIDE_INT vecsize, nunits;
7250 enum machine_mode orig_mode;
7251 tree type = *node, new_type, size;
7253 *no_add_attrs = true;
7255 size = TREE_VALUE (args);
7257 if (!host_integerp (size, 1))
7259 warning (OPT_Wattributes, "%qE attribute ignored", name);
7263 /* Get the vector size (in bytes). */
7264 vecsize = tree_low_cst (size, 1);
7266 /* We need to provide for vector pointers, vector arrays, and
7267 functions returning vectors. For example:
7269 __attribute__((vector_size(16))) short *foo;
7271 In this case, the mode is SI, but the type being modified is
7272 HI, so we need to look further. */
7274 while (POINTER_TYPE_P (type)
7275 || TREE_CODE (type) == FUNCTION_TYPE
7276 || TREE_CODE (type) == METHOD_TYPE
7277 || TREE_CODE (type) == ARRAY_TYPE
7278 || TREE_CODE (type) == OFFSET_TYPE)
7279 type = TREE_TYPE (type);
7281 /* Get the mode of the type being modified. */
7282 orig_mode = TYPE_MODE (type);
7284 if ((!INTEGRAL_TYPE_P (type)
7285 && !SCALAR_FLOAT_TYPE_P (type)
7286 && !FIXED_POINT_TYPE_P (type))
7287 || (!SCALAR_FLOAT_MODE_P (orig_mode)
7288 && GET_MODE_CLASS (orig_mode) != MODE_INT
7289 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7290 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7291 || TREE_CODE (type) == BOOLEAN_TYPE)
7293 error ("invalid vector type for attribute %qE", name);
7297 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7299 error ("vector size not an integral multiple of component size");
7305 error ("zero vector size");
7309 /* Calculate how many units fit in the vector. */
7310 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7311 if (nunits & (nunits - 1))
7313 error ("number of components of the vector not a power of two");
7317 new_type = build_vector_type (type, nunits);
7319 /* Build back pointers if needed. */
7320 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
7325 /* Handle the "nonnull" attribute. */
7327 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7328 tree args, int ARG_UNUSED (flags),
7332 unsigned HOST_WIDE_INT attr_arg_num;
7334 /* If no arguments are specified, all pointer arguments should be
7335 non-null. Verify a full prototype is given so that the arguments
7336 will have the correct types when we actually check them later. */
7339 if (!TYPE_ARG_TYPES (type))
7341 error ("nonnull attribute without arguments on a non-prototype");
7342 *no_add_attrs = true;
7347 /* Argument list specified. Verify that each argument number references
7348 a pointer argument. */
7349 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7352 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
7354 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
7356 error ("nonnull argument has invalid operand number (argument %lu)",
7357 (unsigned long) attr_arg_num);
7358 *no_add_attrs = true;
7362 argument = TYPE_ARG_TYPES (type);
7365 for (ck_num = 1; ; ck_num++)
7367 if (!argument || ck_num == arg_num)
7369 argument = TREE_CHAIN (argument);
7373 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7375 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7376 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7377 *no_add_attrs = true;
7381 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
7383 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7384 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7385 *no_add_attrs = true;
7394 /* Check the argument list of a function call for null in argument slots
7395 that are marked as requiring a non-null pointer argument. The NARGS
7396 arguments are passed in the array ARGARRAY.
7400 check_function_nonnull (tree attrs, int nargs, tree *argarray)
7405 for (a = attrs; a; a = TREE_CHAIN (a))
7407 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7409 args = TREE_VALUE (a);
7411 /* Walk the argument list. If we encounter an argument number we
7412 should check for non-null, do it. If the attribute has no args,
7413 then every pointer argument is checked (in which case the check
7414 for pointer type is done in check_nonnull_arg). */
7415 for (i = 0; i < nargs; i++)
7417 if (!args || nonnull_check_p (args, i + 1))
7418 check_function_arguments_recurse (check_nonnull_arg, NULL,
7426 /* Check that the Nth argument of a function call (counting backwards
7427 from the end) is a (pointer)0. The NARGS arguments are passed in the
7431 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
7433 tree attr = lookup_attribute ("sentinel", attrs);
7441 /* Skip over the named arguments. */
7442 while (typelist && len < nargs)
7444 typelist = TREE_CHAIN (typelist);
7448 if (TREE_VALUE (attr))
7450 tree p = TREE_VALUE (TREE_VALUE (attr));
7451 pos = TREE_INT_CST_LOW (p);
7454 /* The sentinel must be one of the varargs, i.e.
7455 in position >= the number of fixed arguments. */
7456 if ((nargs - 1 - pos) < len)
7458 warning (OPT_Wformat,
7459 "not enough variable arguments to fit a sentinel");
7463 /* Validate the sentinel. */
7464 sentinel = argarray[nargs - 1 - pos];
7465 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7466 || !integer_zerop (sentinel))
7467 /* Although __null (in C++) is only an integer we allow it
7468 nevertheless, as we are guaranteed that it's exactly
7469 as wide as a pointer, and we don't want to force
7470 users to cast the NULL they have written there.
7471 We warn with -Wstrict-null-sentinel, though. */
7472 && (warn_strict_null_sentinel || null_node != sentinel))
7473 warning (OPT_Wformat, "missing sentinel in function call");
7477 /* Helper for check_function_nonnull; given a list of operands which
7478 must be non-null in ARGS, determine if operand PARAM_NUM should be
7482 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
7484 unsigned HOST_WIDE_INT arg_num = 0;
7486 for (; args; args = TREE_CHAIN (args))
7488 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7492 if (arg_num == param_num)
7498 /* Check that the function argument PARAM (which is operand number
7499 PARAM_NUM) is non-null. This is called by check_function_nonnull
7500 via check_function_arguments_recurse. */
7503 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
7504 unsigned HOST_WIDE_INT param_num)
7506 /* Just skip checking the argument if it's not a pointer. This can
7507 happen if the "nonnull" attribute was given without an operand
7508 list (which means to check every pointer argument). */
7510 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7513 if (integer_zerop (param))
7514 warning (OPT_Wnonnull, "null argument where non-null required "
7515 "(argument %lu)", (unsigned long) param_num);
7518 /* Helper for nonnull attribute handling; fetch the operand number
7519 from the attribute argument list. */
7522 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
7524 /* Verify the arg number is a constant. */
7525 if (TREE_CODE (arg_num_expr) != INTEGER_CST
7526 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7529 *valp = TREE_INT_CST_LOW (arg_num_expr);
7533 /* Handle a "nothrow" attribute; arguments as in
7534 struct attribute_spec.handler. */
7537 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7538 int ARG_UNUSED (flags), bool *no_add_attrs)
7540 if (TREE_CODE (*node) == FUNCTION_DECL)
7541 TREE_NOTHROW (*node) = 1;
7542 /* ??? TODO: Support types. */
7545 warning (OPT_Wattributes, "%qE attribute ignored", name);
7546 *no_add_attrs = true;
7552 /* Handle a "cleanup" attribute; arguments as in
7553 struct attribute_spec.handler. */
7556 handle_cleanup_attribute (tree *node, tree name, tree args,
7557 int ARG_UNUSED (flags), bool *no_add_attrs)
7560 tree cleanup_id, cleanup_decl;
7562 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7563 for global destructors in C++. This requires infrastructure that
7564 we don't have generically at the moment. It's also not a feature
7565 we'd be missing too much, since we do have attribute constructor. */
7566 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7568 warning (OPT_Wattributes, "%qE attribute ignored", name);
7569 *no_add_attrs = true;
7573 /* Verify that the argument is a function in scope. */
7574 /* ??? We could support pointers to functions here as well, if
7575 that was considered desirable. */
7576 cleanup_id = TREE_VALUE (args);
7577 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7579 error ("cleanup argument not an identifier");
7580 *no_add_attrs = true;
7583 cleanup_decl = lookup_name (cleanup_id);
7584 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7586 error ("cleanup argument not a function");
7587 *no_add_attrs = true;
7591 /* That the function has proper type is checked with the
7592 eventual call to build_function_call. */
7597 /* Handle a "warn_unused_result" attribute. No special handling. */
7600 handle_warn_unused_result_attribute (tree *node, tree name,
7601 tree ARG_UNUSED (args),
7602 int ARG_UNUSED (flags), bool *no_add_attrs)
7604 /* Ignore the attribute for functions not returning any value. */
7605 if (VOID_TYPE_P (TREE_TYPE (*node)))
7607 warning (OPT_Wattributes, "%qE attribute ignored", name);
7608 *no_add_attrs = true;
7614 /* Handle a "sentinel" attribute. */
7617 handle_sentinel_attribute (tree *node, tree name, tree args,
7618 int ARG_UNUSED (flags), bool *no_add_attrs)
7620 tree params = TYPE_ARG_TYPES (*node);
7624 warning (OPT_Wattributes,
7625 "%qE attribute requires prototypes with named arguments", name);
7626 *no_add_attrs = true;
7630 while (TREE_CHAIN (params))
7631 params = TREE_CHAIN (params);
7633 if (VOID_TYPE_P (TREE_VALUE (params)))
7635 warning (OPT_Wattributes,
7636 "%qE attribute only applies to variadic functions", name);
7637 *no_add_attrs = true;
7643 tree position = TREE_VALUE (args);
7645 if (TREE_CODE (position) != INTEGER_CST)
7647 warning (OPT_Wattributes,
7648 "requested position is not an integer constant");
7649 *no_add_attrs = true;
7653 if (tree_int_cst_lt (position, integer_zero_node))
7655 warning (OPT_Wattributes,
7656 "requested position is less than zero");
7657 *no_add_attrs = true;
7665 /* Handle a "type_generic" attribute. */
7668 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7669 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7670 bool * ARG_UNUSED (no_add_attrs))
7674 /* Ensure we have a function type. */
7675 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
7677 params = TYPE_ARG_TYPES (*node);
7678 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7679 params = TREE_CHAIN (params);
7681 /* Ensure we have a variadic function. */
7682 gcc_assert (!params);
7687 /* Handle a "target" attribute. */
7690 handle_target_attribute (tree *node, tree name, tree args, int flags,
7693 /* Ensure we have a function type. */
7694 if (TREE_CODE (*node) != FUNCTION_DECL)
7696 warning (OPT_Wattributes, "%qE attribute ignored", name);
7697 *no_add_attrs = true;
7699 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7701 *no_add_attrs = true;
7706 /* Arguments being collected for optimization. */
7707 typedef const char *const_char_p; /* For DEF_VEC_P. */
7708 DEF_VEC_P(const_char_p);
7709 DEF_VEC_ALLOC_P(const_char_p, gc);
7710 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7713 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7714 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7715 false for #pragma GCC optimize. */
7718 parse_optimize_options (tree args, bool attr_p)
7723 int saved_flag_strict_aliasing;
7724 const char **opt_argv;
7727 /* Build up argv vector. Just in case the string is stored away, use garbage
7728 collected strings. */
7729 VEC_truncate (const_char_p, optimize_args, 0);
7730 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7732 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7734 tree value = TREE_VALUE (ap);
7736 if (TREE_CODE (value) == INTEGER_CST)
7739 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7740 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7743 else if (TREE_CODE (value) == STRING_CST)
7745 /* Split string into multiple substrings. */
7746 size_t len = TREE_STRING_LENGTH (value);
7747 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7748 char *end = p + len;
7752 while (next_p != NULL)
7758 comma = strchr (p, ',');
7771 r = q = (char *) ggc_alloc (len2 + 3);
7773 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7775 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7779 warning (OPT_Wattributes,
7780 "Bad option %s to optimize attribute.", p);
7782 warning (OPT_Wpragmas,
7783 "Bad option %s to pragma attribute", p);
7791 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7792 itself is -Os, and any other switch begins with a -f. */
7793 if ((*p >= '0' && *p <= '9')
7794 || (p[0] == 's' && p[1] == '\0'))
7800 memcpy (r, p, len2);
7802 VEC_safe_push (const_char_p, gc, optimize_args, q);
7808 opt_argc = VEC_length (const_char_p, optimize_args);
7809 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7811 for (i = 1; i < opt_argc; i++)
7812 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7814 saved_flag_strict_aliasing = flag_strict_aliasing;
7816 /* Now parse the options. */
7817 decode_options (opt_argc, opt_argv);
7819 /* Don't allow changing -fstrict-aliasing. */
7820 flag_strict_aliasing = saved_flag_strict_aliasing;
7822 VEC_truncate (const_char_p, optimize_args, 0);
7826 /* For handling "optimize" attribute. arguments as in
7827 struct attribute_spec.handler. */
7830 handle_optimize_attribute (tree *node, tree name, tree args,
7831 int ARG_UNUSED (flags), bool *no_add_attrs)
7833 /* Ensure we have a function type. */
7834 if (TREE_CODE (*node) != FUNCTION_DECL)
7836 warning (OPT_Wattributes, "%qE attribute ignored", name);
7837 *no_add_attrs = true;
7841 struct cl_optimization cur_opts;
7842 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7844 /* Save current options. */
7845 cl_optimization_save (&cur_opts);
7847 /* If we previously had some optimization options, use them as the
7850 cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7852 /* Parse options, and update the vector. */
7853 parse_optimize_options (args, true);
7854 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7855 = build_optimization_node ();
7857 /* Restore current options. */
7858 cl_optimization_restore (&cur_opts);
7864 /* Check for valid arguments being passed to a function.
7865 ATTRS is a list of attributes. There are NARGS arguments in the array
7866 ARGARRAY. TYPELIST is the list of argument types for the function.
7869 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7871 /* Check for null being passed in a pointer argument that must be
7872 non-null. We also need to do this if format checking is enabled. */
7875 check_function_nonnull (attrs, nargs, argarray);
7877 /* Check for errors in format strings. */
7879 if (warn_format || warn_missing_format_attribute)
7880 check_function_format (attrs, nargs, argarray);
7883 check_function_sentinel (attrs, nargs, argarray, typelist);
7886 /* Generic argument checking recursion routine. PARAM is the argument to
7887 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7888 once the argument is resolved. CTX is context for the callback. */
7890 check_function_arguments_recurse (void (*callback)
7891 (void *, tree, unsigned HOST_WIDE_INT),
7892 void *ctx, tree param,
7893 unsigned HOST_WIDE_INT param_num)
7895 if (CONVERT_EXPR_P (param)
7896 && (TYPE_PRECISION (TREE_TYPE (param))
7897 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7899 /* Strip coercion. */
7900 check_function_arguments_recurse (callback, ctx,
7901 TREE_OPERAND (param, 0), param_num);
7905 if (TREE_CODE (param) == CALL_EXPR)
7907 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7909 bool found_format_arg = false;
7911 /* See if this is a call to a known internationalization function
7912 that modifies a format arg. Such a function may have multiple
7913 format_arg attributes (for example, ngettext). */
7915 for (attrs = TYPE_ATTRIBUTES (type);
7917 attrs = TREE_CHAIN (attrs))
7918 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7921 tree format_num_expr;
7924 call_expr_arg_iterator iter;
7926 /* Extract the argument number, which was previously checked
7928 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7930 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7931 && !TREE_INT_CST_HIGH (format_num_expr));
7933 format_num = TREE_INT_CST_LOW (format_num_expr);
7935 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7937 inner_arg = next_call_expr_arg (&iter), i++)
7938 if (i == format_num)
7940 check_function_arguments_recurse (callback, ctx,
7941 inner_arg, param_num);
7942 found_format_arg = true;
7947 /* If we found a format_arg attribute and did a recursive check,
7948 we are done with checking this argument. Otherwise, we continue
7949 and this will be considered a non-literal. */
7950 if (found_format_arg)
7954 if (TREE_CODE (param) == COND_EXPR)
7956 /* Check both halves of the conditional expression. */
7957 check_function_arguments_recurse (callback, ctx,
7958 TREE_OPERAND (param, 1), param_num);
7959 check_function_arguments_recurse (callback, ctx,
7960 TREE_OPERAND (param, 2), param_num);
7964 (*callback) (ctx, param, param_num);
7967 /* Checks the number of arguments NARGS against the required number
7968 REQUIRED and issues an error if there is a mismatch. Returns true
7969 if the number of arguments is correct, otherwise false. */
7972 validate_nargs (tree fndecl, int nargs, int required)
7974 if (nargs < required)
7976 error ("not enough arguments to function %qE", fndecl);
7979 else if (nargs > required)
7981 error ("too many arguments to function %qE", fndecl);
7987 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7988 Returns false if there was an error, otherwise true. */
7991 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
7993 if (!DECL_BUILT_IN (fndecl)
7994 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
7997 switch (DECL_FUNCTION_CODE (fndecl))
7999 case BUILT_IN_CONSTANT_P:
8000 return validate_nargs (fndecl, nargs, 1);
8002 case BUILT_IN_ISFINITE:
8003 case BUILT_IN_ISINF:
8004 case BUILT_IN_ISINF_SIGN:
8005 case BUILT_IN_ISNAN:
8006 case BUILT_IN_ISNORMAL:
8007 if (validate_nargs (fndecl, nargs, 1))
8009 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8011 error ("non-floating-point argument in call to "
8012 "function %qE", fndecl);
8019 case BUILT_IN_ISGREATER:
8020 case BUILT_IN_ISGREATEREQUAL:
8021 case BUILT_IN_ISLESS:
8022 case BUILT_IN_ISLESSEQUAL:
8023 case BUILT_IN_ISLESSGREATER:
8024 case BUILT_IN_ISUNORDERED:
8025 if (validate_nargs (fndecl, nargs, 2))
8027 enum tree_code code0, code1;
8028 code0 = TREE_CODE (TREE_TYPE (args[0]));
8029 code1 = TREE_CODE (TREE_TYPE (args[1]));
8030 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8031 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8032 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8034 error ("non-floating-point arguments in call to "
8035 "function %qE", fndecl);
8042 case BUILT_IN_FPCLASSIFY:
8043 if (validate_nargs (fndecl, nargs, 6))
8048 if (TREE_CODE (args[i]) != INTEGER_CST)
8050 error ("non-const integer argument %u in call to function %qE",
8055 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8057 error ("non-floating-point argument in call to function %qE",
8070 /* Function to help qsort sort FIELD_DECLs by name order. */
8073 field_decl_cmp (const void *x_p, const void *y_p)
8075 const tree *const x = (const tree *const) x_p;
8076 const tree *const y = (const tree *const) y_p;
8078 if (DECL_NAME (*x) == DECL_NAME (*y))
8079 /* A nontype is "greater" than a type. */
8080 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8081 if (DECL_NAME (*x) == NULL_TREE)
8083 if (DECL_NAME (*y) == NULL_TREE)
8085 if (DECL_NAME (*x) < DECL_NAME (*y))
8091 gt_pointer_operator new_value;
8095 /* This routine compares two fields like field_decl_cmp but using the
8096 pointer operator in resort_data. */
8099 resort_field_decl_cmp (const void *x_p, const void *y_p)
8101 const tree *const x = (const tree *const) x_p;
8102 const tree *const y = (const tree *const) y_p;
8104 if (DECL_NAME (*x) == DECL_NAME (*y))
8105 /* A nontype is "greater" than a type. */
8106 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8107 if (DECL_NAME (*x) == NULL_TREE)
8109 if (DECL_NAME (*y) == NULL_TREE)
8112 tree d1 = DECL_NAME (*x);
8113 tree d2 = DECL_NAME (*y);
8114 resort_data.new_value (&d1, resort_data.cookie);
8115 resort_data.new_value (&d2, resort_data.cookie);
8122 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8125 resort_sorted_fields (void *obj,
8126 void * ARG_UNUSED (orig_obj),
8127 gt_pointer_operator new_value,
8130 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
8131 resort_data.new_value = new_value;
8132 resort_data.cookie = cookie;
8133 qsort (&sf->elts[0], sf->len, sizeof (tree),
8134 resort_field_decl_cmp);
8137 /* Subroutine of c_parse_error.
8138 Return the result of concatenating LHS and RHS. RHS is really
8139 a string literal, its first character is indicated by RHS_START and
8140 RHS_SIZE is its length (including the terminating NUL character).
8142 The caller is responsible for deleting the returned pointer. */
8145 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8147 const int lhs_size = strlen (lhs);
8148 char *result = XNEWVEC (char, lhs_size + rhs_size);
8149 strncpy (result, lhs, lhs_size);
8150 strncpy (result + lhs_size, rhs_start, rhs_size);
8154 /* Issue the error given by GMSGID, indicating that it occurred before
8155 TOKEN, which had the associated VALUE. */
8158 c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
8159 tree value, unsigned char token_flags)
8161 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8163 char *message = NULL;
8165 if (token_type == CPP_EOF)
8166 message = catenate_messages (gmsgid, " at end of input");
8167 else if (token_type == CPP_CHAR
8168 || token_type == CPP_WCHAR
8169 || token_type == CPP_CHAR16
8170 || token_type == CPP_CHAR32)
8172 unsigned int val = TREE_INT_CST_LOW (value);
8191 if (val <= UCHAR_MAX && ISGRAPH (val))
8192 message = catenate_messages (gmsgid, " before %s'%c'");
8194 message = catenate_messages (gmsgid, " before %s'\\x%x'");
8196 error (message, prefix, val);
8200 else if (token_type == CPP_STRING
8201 || token_type == CPP_WSTRING
8202 || token_type == CPP_STRING16
8203 || token_type == CPP_STRING32)
8204 message = catenate_messages (gmsgid, " before string constant");
8205 else if (token_type == CPP_NUMBER)
8206 message = catenate_messages (gmsgid, " before numeric constant");
8207 else if (token_type == CPP_NAME)
8209 message = catenate_messages (gmsgid, " before %qE");
8210 error (message, value);
8214 else if (token_type == CPP_PRAGMA)
8215 message = catenate_messages (gmsgid, " before %<#pragma%>");
8216 else if (token_type == CPP_PRAGMA_EOL)
8217 message = catenate_messages (gmsgid, " before end of line");
8218 else if (token_type < N_TTYPES)
8220 message = catenate_messages (gmsgid, " before %qs token");
8221 error (message, cpp_type2name (token_type, token_flags));
8233 #undef catenate_messages
8236 /* Callback from cpp_error for PFILE to print diagnostics from the
8237 preprocessor. The diagnostic is of type LEVEL, at location
8238 LOCATION unless this is after lexing and the compiler's location
8239 should be used instead, with column number possibly overridden by
8240 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8241 the arguments. Returns true if a diagnostic was emitted, false
8245 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
8246 location_t location, unsigned int column_override,
8247 const char *msg, va_list *ap)
8249 diagnostic_info diagnostic;
8250 diagnostic_t dlevel;
8251 int save_warn_system_headers = warn_system_headers;
8256 case CPP_DL_WARNING_SYSHDR:
8259 warn_system_headers = 1;
8261 case CPP_DL_WARNING:
8264 dlevel = DK_WARNING;
8266 case CPP_DL_PEDWARN:
8267 if (flag_no_output && !flag_pedantic_errors)
8269 dlevel = DK_PEDWARN;
8287 location = input_location;
8288 diagnostic_set_info_translated (&diagnostic, msg, ap,
8290 if (column_override)
8291 diagnostic_override_column (&diagnostic, column_override);
8292 ret = report_diagnostic (&diagnostic);
8293 if (level == CPP_DL_WARNING_SYSHDR)
8294 warn_system_headers = save_warn_system_headers;
8298 /* Walk a gimplified function and warn for functions whose return value is
8299 ignored and attribute((warn_unused_result)) is set. This is done before
8300 inlining, so we don't have to worry about that. */
8303 c_warn_unused_result (gimple_seq seq)
8306 gimple_stmt_iterator i;
8308 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
8310 gimple g = gsi_stmt (i);
8312 switch (gimple_code (g))
8315 c_warn_unused_result (gimple_bind_body (g));
8318 c_warn_unused_result (gimple_try_eval (g));
8319 c_warn_unused_result (gimple_try_cleanup (g));
8322 c_warn_unused_result (gimple_catch_handler (g));
8324 case GIMPLE_EH_FILTER:
8325 c_warn_unused_result (gimple_eh_filter_failure (g));
8329 if (gimple_call_lhs (g))
8332 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8333 LHS. All calls whose value is ignored should be
8334 represented like this. Look for the attribute. */
8335 fdecl = gimple_call_fndecl (g);
8336 ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
8338 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
8340 location_t loc = gimple_location (g);
8343 warning (0, "%Hignoring return value of %qD, "
8344 "declared with attribute warn_unused_result",
8347 warning (0, "%Hignoring return value of function "
8348 "declared with attribute warn_unused_result",
8354 /* Not a container, not a call, or a call whose value is used. */
8360 /* Convert a character from the host to the target execution character
8361 set. cpplib handles this, mostly. */
8364 c_common_to_target_charset (HOST_WIDE_INT c)
8366 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8367 zero-extended under -fno-signed-char. cpplib insists that characters
8368 and character constants are always unsigned. Hence we must convert
8370 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8372 uc = cpp_host_to_exec_charset (parse_in, uc);
8374 if (flag_signed_char)
8375 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8376 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8381 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8382 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8383 NULL, at the bottom; much like the traditional rendering of offsetof as a
8384 macro. Returns the folded and properly cast result. */
8387 fold_offsetof_1 (tree expr, tree stop_ref)
8389 enum tree_code code = PLUS_EXPR;
8392 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8393 return size_zero_node;
8395 switch (TREE_CODE (expr))
8401 error ("cannot apply %<offsetof%> to static data member %qD", expr);
8402 return error_mark_node;
8406 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8407 return error_mark_node;
8410 gcc_assert (integer_zerop (expr));
8411 return size_zero_node;
8415 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8416 gcc_assert (base == error_mark_node || base == size_zero_node);
8420 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8421 if (base == error_mark_node)
8424 t = TREE_OPERAND (expr, 1);
8425 if (DECL_C_BIT_FIELD (t))
8427 error ("attempt to take address of bit-field structure "
8429 return error_mark_node;
8431 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
8432 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
8437 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8438 if (base == error_mark_node)
8441 t = TREE_OPERAND (expr, 1);
8442 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8445 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
8447 t = convert (sizetype, t);
8448 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8452 /* Handle static members of volatile structs. */
8453 t = TREE_OPERAND (expr, 1);
8454 gcc_assert (TREE_CODE (t) == VAR_DECL);
8455 return fold_offsetof_1 (t, stop_ref);
8461 return size_binop (code, base, off);
8465 fold_offsetof (tree expr, tree stop_ref)
8467 /* Convert back from the internal sizetype to size_t. */
8468 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
8471 /* Print an error message for an invalid lvalue. USE says
8472 how the lvalue is being used and so selects the error message. */
8475 lvalue_error (enum lvalue_use use)
8480 error ("lvalue required as left operand of assignment");
8483 error ("lvalue required as increment operand");
8486 error ("lvalue required as decrement operand");
8489 error ("lvalue required as unary %<&%> operand");
8492 error ("lvalue required in asm statement");
8499 /* *PTYPE is an incomplete array. Complete it with a domain based on
8500 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8501 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8502 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8505 complete_array_type (tree *ptype, tree initial_value, bool do_default)
8507 tree maxindex, type, main_type, elt, unqual_elt;
8508 int failure = 0, quals;
8509 hashval_t hashcode = 0;
8511 maxindex = size_zero_node;
8514 if (TREE_CODE (initial_value) == STRING_CST)
8517 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8518 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8520 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8522 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
8524 if (VEC_empty (constructor_elt, v))
8528 maxindex = integer_minus_one_node;
8533 unsigned HOST_WIDE_INT cnt;
8534 constructor_elt *ce;
8535 bool fold_p = false;
8537 if (VEC_index (constructor_elt, v, 0)->index)
8538 maxindex = fold_convert (sizetype,
8539 VEC_index (constructor_elt,
8541 curindex = maxindex;
8544 VEC_iterate (constructor_elt, v, cnt, ce);
8547 bool curfold_p = false;
8549 curindex = ce->index, curfold_p = true;
8553 curindex = fold_convert (sizetype, curindex);
8554 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
8556 if (tree_int_cst_lt (maxindex, curindex))
8557 maxindex = curindex, fold_p = curfold_p;
8560 maxindex = fold_convert (sizetype, maxindex);
8565 /* Make an error message unless that happened already. */
8566 if (initial_value != error_mark_node)
8578 elt = TREE_TYPE (type);
8579 quals = TYPE_QUALS (strip_array_types (elt));
8583 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
8585 /* Using build_distinct_type_copy and modifying things afterward instead
8586 of using build_array_type to create a new type preserves all of the
8587 TYPE_LANG_FLAG_? bits that the front end may have set. */
8588 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8589 TREE_TYPE (main_type) = unqual_elt;
8590 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8591 layout_type (main_type);
8593 /* Make sure we have the canonical MAIN_TYPE. */
8594 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
8595 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
8597 main_type = type_hash_canon (hashcode, main_type);
8599 /* Fix the canonical type. */
8600 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8601 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8602 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8603 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8604 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8605 != TYPE_DOMAIN (main_type)))
8606 TYPE_CANONICAL (main_type)
8607 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8608 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8610 TYPE_CANONICAL (main_type) = main_type;
8615 type = c_build_qualified_type (main_type, quals);
8617 if (COMPLETE_TYPE_P (type)
8618 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8619 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8621 error ("size of array is too large");
8622 /* If we proceed with the array type as it is, we'll eventually
8623 crash in tree_low_cst(). */
8624 type = error_mark_node;
8632 /* Used to help initialize the builtin-types.def table. When a type of
8633 the correct size doesn't exist, use error_mark_node instead of NULL.
8634 The later results in segfaults even when a decl using the type doesn't
8638 builtin_type_for_size (int size, bool unsignedp)
8640 tree type = lang_hooks.types.type_for_size (size, unsignedp);
8641 return type ? type : error_mark_node;
8644 /* A helper function for resolve_overloaded_builtin in resolving the
8645 overloaded __sync_ builtins. Returns a positive power of 2 if the
8646 first operand of PARAMS is a pointer to a supported data type.
8647 Returns 0 if an error is encountered. */
8650 sync_resolve_size (tree function, VEC(tree,gc) *params)
8655 if (VEC_empty (tree, params))
8657 error ("too few arguments to function %qE", function);
8661 type = TREE_TYPE (VEC_index (tree, params, 0));
8662 if (TREE_CODE (type) != POINTER_TYPE)
8665 type = TREE_TYPE (type);
8666 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8669 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
8670 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
8674 error ("incompatible type for argument %d of %qE", 1, function);
8678 /* A helper function for resolve_overloaded_builtin. Adds casts to
8679 PARAMS to make arguments match up with those of FUNCTION. Drops
8680 the variadic arguments at the end. Returns false if some error
8681 was encountered; true on success. */
8684 sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
8686 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8689 unsigned int parmnum;
8691 /* We've declared the implementation functions to use "volatile void *"
8692 as the pointer parameter, so we shouldn't get any complaints from the
8693 call to check_function_arguments what ever type the user used. */
8694 arg_types = TREE_CHAIN (arg_types);
8695 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
8698 /* For the rest of the values, we need to cast these to FTYPE, so that we
8699 don't get warnings for passing pointer types, etc. */
8701 while (arg_types != void_list_node)
8706 if (VEC_length (tree, params) <= parmnum)
8708 error ("too few arguments to function %qE", orig_function);
8712 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8713 so that we get warnings for anything that doesn't match the pointer
8714 type. This isn't portable across the C and C++ front ends atm. */
8715 val = VEC_index (tree, params, parmnum);
8716 val = convert (ptype, val);
8717 val = convert (TREE_VALUE (arg_types), val);
8718 VEC_replace (tree, params, parmnum, val);
8720 arg_types = TREE_CHAIN (arg_types);
8724 /* The definition of these primitives is variadic, with the remaining
8725 being "an optional list of variables protected by the memory barrier".
8726 No clue what that's supposed to mean, precisely, but we consider all
8727 call-clobbered variables to be protected so we're safe. */
8728 VEC_truncate (tree, params, parmnum + 1);
8733 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8734 RESULT to make it match the type of the first pointer argument in
8738 sync_resolve_return (tree first_param, tree result)
8740 tree ptype = TREE_TYPE (TREE_TYPE (first_param));
8741 ptype = TYPE_MAIN_VARIANT (ptype);
8742 return convert (ptype, result);
8745 /* Some builtin functions are placeholders for other expressions. This
8746 function should be called immediately after parsing the call expression
8747 before surrounding code has committed to the type of the expression.
8749 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8750 PARAMS is the argument list for the call. The return value is non-null
8751 when expansion is complete, and null if normal processing should
8755 resolve_overloaded_builtin (tree function, VEC(tree,gc) *params)
8757 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8758 switch (DECL_BUILT_IN_CLASS (function))
8760 case BUILT_IN_NORMAL:
8763 if (targetm.resolve_overloaded_builtin)
8764 return targetm.resolve_overloaded_builtin (function, params);
8771 /* Handle BUILT_IN_NORMAL here. */
8774 case BUILT_IN_FETCH_AND_ADD_N:
8775 case BUILT_IN_FETCH_AND_SUB_N:
8776 case BUILT_IN_FETCH_AND_OR_N:
8777 case BUILT_IN_FETCH_AND_AND_N:
8778 case BUILT_IN_FETCH_AND_XOR_N:
8779 case BUILT_IN_FETCH_AND_NAND_N:
8780 case BUILT_IN_ADD_AND_FETCH_N:
8781 case BUILT_IN_SUB_AND_FETCH_N:
8782 case BUILT_IN_OR_AND_FETCH_N:
8783 case BUILT_IN_AND_AND_FETCH_N:
8784 case BUILT_IN_XOR_AND_FETCH_N:
8785 case BUILT_IN_NAND_AND_FETCH_N:
8786 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8787 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8788 case BUILT_IN_LOCK_TEST_AND_SET_N:
8789 case BUILT_IN_LOCK_RELEASE_N:
8791 int n = sync_resolve_size (function, params);
8792 tree new_function, first_param, result;
8795 return error_mark_node;
8797 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8798 if (!sync_resolve_params (function, new_function, params))
8799 return error_mark_node;
8801 first_param = VEC_index (tree, params, 0);
8802 result = build_function_call_vec (new_function, params, NULL);
8803 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8804 && orig_code != BUILT_IN_LOCK_RELEASE_N)
8805 result = sync_resolve_return (first_param, result);
8815 /* Ignoring their sign, return true if two scalar types are the same. */
8817 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8819 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8821 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8822 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8823 || c2 == FIXED_POINT_TYPE));
8825 /* Equality works here because c_common_signed_type uses
8826 TYPE_MAIN_VARIANT. */
8827 return c_common_signed_type (t1)
8828 == c_common_signed_type (t2);
8831 /* Check for missing format attributes on function pointers. LTYPE is
8832 the new type or left-hand side type. RTYPE is the old type or
8833 right-hand side type. Returns TRUE if LTYPE is missing the desired
8837 check_missing_format_attribute (tree ltype, tree rtype)
8839 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8842 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8843 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8848 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8849 if (is_attribute_p ("format", TREE_PURPOSE (la)))
8857 /* Subscripting with type char is likely to lose on a machine where
8858 chars are signed. So warn on any machine, but optionally. Don't
8859 warn for unsigned char since that type is safe. Don't warn for
8860 signed char because anyone who uses that must have done so
8861 deliberately. Furthermore, we reduce the false positive load by
8862 warning only for non-constant value of type char. */
8865 warn_array_subscript_with_type_char (tree index)
8867 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8868 && TREE_CODE (index) != INTEGER_CST)
8869 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8872 /* Implement -Wparentheses for the unexpected C precedence rules, to
8873 cover cases like x + y << z which readers are likely to
8874 misinterpret. We have seen an expression in which CODE is a binary
8875 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8876 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8877 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8878 expression was not formed using a binary or unary operator, or it
8879 was enclosed in parentheses. */
8882 warn_about_parentheses (enum tree_code code,
8883 enum tree_code code_left, tree arg_left,
8884 enum tree_code code_right, tree arg_right)
8886 if (!warn_parentheses)
8889 /* This macro tests that the expression ARG with original tree code
8890 CODE appears to be a boolean expression. or the result of folding a
8891 boolean expression. */
8892 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8893 (truth_value_p (TREE_CODE (ARG)) \
8894 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8895 /* Folding may create 0 or 1 integers from other expressions. */ \
8896 || ((CODE) != INTEGER_CST \
8897 && (integer_onep (ARG) || integer_zerop (ARG))))
8902 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8903 warning (OPT_Wparentheses,
8904 "suggest parentheses around %<+%> inside %<<<%>");
8905 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8906 warning (OPT_Wparentheses,
8907 "suggest parentheses around %<-%> inside %<<<%>");
8911 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8912 warning (OPT_Wparentheses,
8913 "suggest parentheses around %<+%> inside %<>>%>");
8914 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8915 warning (OPT_Wparentheses,
8916 "suggest parentheses around %<-%> inside %<>>%>");
8919 case TRUTH_ORIF_EXPR:
8920 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8921 warning (OPT_Wparentheses,
8922 "suggest parentheses around %<&&%> within %<||%>");
8926 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8927 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8928 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8929 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8930 warning (OPT_Wparentheses,
8931 "suggest parentheses around arithmetic in operand of %<|%>");
8932 /* Check cases like x|y==z */
8933 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8934 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8935 warning (OPT_Wparentheses,
8936 "suggest parentheses around comparison in operand of %<|%>");
8937 /* Check cases like !x | y */
8938 else if (code_left == TRUTH_NOT_EXPR
8939 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8940 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8941 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8945 if (code_left == BIT_AND_EXPR
8946 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8947 || code_right == BIT_AND_EXPR
8948 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8949 warning (OPT_Wparentheses,
8950 "suggest parentheses around arithmetic in operand of %<^%>");
8951 /* Check cases like x^y==z */
8952 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8953 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8954 warning (OPT_Wparentheses,
8955 "suggest parentheses around comparison in operand of %<^%>");
8959 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8960 warning (OPT_Wparentheses,
8961 "suggest parentheses around %<+%> in operand of %<&%>");
8962 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8963 warning (OPT_Wparentheses,
8964 "suggest parentheses around %<-%> in operand of %<&%>");
8965 /* Check cases like x&y==z */
8966 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8967 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8968 warning (OPT_Wparentheses,
8969 "suggest parentheses around comparison in operand of %<&%>");
8970 /* Check cases like !x & y */
8971 else if (code_left == TRUTH_NOT_EXPR
8972 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8973 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8974 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8978 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8979 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8980 warning (OPT_Wparentheses,
8981 "suggest parentheses around comparison in operand of %<==%>");
8984 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8985 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8986 warning (OPT_Wparentheses,
8987 "suggest parentheses around comparison in operand of %<!=%>");
8991 if (TREE_CODE_CLASS (code) == tcc_comparison
8992 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
8993 && code_left != NE_EXPR && code_left != EQ_EXPR
8994 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
8995 || (TREE_CODE_CLASS (code_right) == tcc_comparison
8996 && code_right != NE_EXPR && code_right != EQ_EXPR
8997 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
8998 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
8999 "have their mathematical meaning");
9002 #undef NOT_A_BOOLEAN_EXPR_P
9005 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
9008 warn_for_unused_label (tree label)
9010 if (!TREE_USED (label))
9012 if (DECL_INITIAL (label))
9013 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9015 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9019 #ifndef TARGET_HAS_TARGETCM
9020 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
9023 /* Warn for division by zero according to the value of DIVISOR. LOC
9024 is the location of the division operator. */
9027 warn_for_div_by_zero (location_t loc, tree divisor)
9029 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9030 about division by zero. Do not issue a warning if DIVISOR has a
9031 floating-point type, since we consider 0.0/0.0 a valid way of
9032 generating a NaN. */
9033 if (skip_evaluation == 0
9034 && (integer_zerop (divisor) || fixed_zerop (divisor)))
9035 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
9038 /* Subroutine of build_binary_op. Give warnings for comparisons
9039 between signed and unsigned quantities that may fail. Do the
9040 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9041 so that casts will be considered, but default promotions won't
9044 LOCATION is the location of the comparison operator.
9046 The arguments of this function map directly to local variables
9047 of build_binary_op. */
9050 warn_for_sign_compare (location_t location,
9051 tree orig_op0, tree orig_op1,
9053 tree result_type, enum tree_code resultcode)
9055 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9056 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9057 int unsignedp0, unsignedp1;
9059 /* In C++, check for comparison of different enum types. */
9061 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9062 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9063 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
9064 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
9066 warning_at (location,
9067 OPT_Wsign_compare, "comparison between types %qT and %qT",
9068 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
9071 /* Do not warn if the comparison is being done in a signed type,
9072 since the signed type will only be chosen if it can represent
9073 all the values of the unsigned type. */
9074 if (!TYPE_UNSIGNED (result_type))
9076 /* Do not warn if both operands are unsigned. */
9077 else if (op0_signed == op1_signed)
9081 tree sop, uop, base_type;
9085 sop = orig_op0, uop = orig_op1;
9087 sop = orig_op1, uop = orig_op0;
9089 STRIP_TYPE_NOPS (sop);
9090 STRIP_TYPE_NOPS (uop);
9091 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9092 ? TREE_TYPE (result_type) : result_type);
9094 /* Do not warn if the signed quantity is an unsuffixed integer
9095 literal (or some static constant expression involving such
9096 literals or a conditional expression involving such literals)
9097 and it is non-negative. */
9098 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9100 /* Do not warn if the comparison is an equality operation, the
9101 unsigned quantity is an integral constant, and it would fit
9102 in the result if the result were signed. */
9103 else if (TREE_CODE (uop) == INTEGER_CST
9104 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
9105 && int_fits_type_p (uop, c_common_signed_type (base_type)))
9107 /* In C, do not warn if the unsigned quantity is an enumeration
9108 constant and its maximum value would fit in the result if the
9109 result were signed. */
9110 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9111 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9112 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
9113 c_common_signed_type (base_type)))
9116 warning_at (location,
9118 "comparison between signed and unsigned integer expressions");
9121 /* Warn if two unsigned values are being compared in a size larger
9122 than their original size, and one (and only one) is the result of
9123 a `~' operator. This comparison will always fail.
9125 Also warn if one operand is a constant, and the constant does not
9126 have all bits set that are set in the ~ operand when it is
9129 op0 = get_narrower (op0, &unsignedp0);
9130 op1 = get_narrower (op1, &unsignedp1);
9132 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9133 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9135 if (TREE_CODE (op0) == BIT_NOT_EXPR)
9136 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9137 if (TREE_CODE (op1) == BIT_NOT_EXPR)
9138 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9140 if (host_integerp (op0, 0) || host_integerp (op1, 0))
9143 HOST_WIDE_INT constant, mask;
9147 if (host_integerp (op0, 0))
9150 unsignedp = unsignedp1;
9151 constant = tree_low_cst (op0, 0);
9156 unsignedp = unsignedp0;
9157 constant = tree_low_cst (op1, 0);
9160 bits = TYPE_PRECISION (TREE_TYPE (primop));
9161 if (bits < TYPE_PRECISION (result_type)
9162 && bits < HOST_BITS_PER_LONG && unsignedp)
9164 mask = (~ (HOST_WIDE_INT) 0) << bits;
9165 if ((mask & constant) != mask)
9168 warning (OPT_Wsign_compare,
9169 "promoted ~unsigned is always non-zero");
9171 warning_at (location, OPT_Wsign_compare,
9172 "comparison of promoted ~unsigned with constant");
9176 else if (unsignedp0 && unsignedp1
9177 && (TYPE_PRECISION (TREE_TYPE (op0))
9178 < TYPE_PRECISION (result_type))
9179 && (TYPE_PRECISION (TREE_TYPE (op1))
9180 < TYPE_PRECISION (result_type)))
9181 warning_at (location, OPT_Wsign_compare,
9182 "comparison of promoted ~unsigned with unsigned");
9186 /* Setup a TYPE_DECL node as a typedef representation.
9188 X is a TYPE_DECL for a typedef statement. Create a brand new
9189 ..._TYPE node (which will be just a variant of the existing
9190 ..._TYPE node with identical properties) and then install X
9191 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9193 The whole point here is to end up with a situation where each
9194 and every ..._TYPE node the compiler creates will be uniquely
9195 associated with AT MOST one node representing a typedef name.
9196 This way, even though the compiler substitutes corresponding
9197 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9198 early on, later parts of the compiler can always do the reverse
9199 translation and get back the corresponding typedef name. For
9202 typedef struct S MY_TYPE;
9205 Later parts of the compiler might only know that `object' was of
9206 type `struct S' if it were not for code just below. With this
9207 code however, later parts of the compiler see something like:
9209 struct S' == struct S
9210 typedef struct S' MY_TYPE;
9213 And they can then deduce (from the node for type struct S') that
9214 the original object declaration was:
9218 Being able to do this is important for proper support of protoize,
9219 and also for generating precise symbolic debugging information
9220 which takes full account of the programmer's (typedef) vocabulary.
9222 Obviously, we don't want to generate a duplicate ..._TYPE node if
9223 the TYPE_DECL node that we are now processing really represents a
9224 standard built-in type. */
9227 set_underlying_type (tree x)
9229 if (x == error_mark_node)
9231 if (DECL_IS_BUILTIN (x))
9233 if (TYPE_NAME (TREE_TYPE (x)) == 0)
9234 TYPE_NAME (TREE_TYPE (x)) = x;
9236 else if (TREE_TYPE (x) != error_mark_node
9237 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9239 tree tt = TREE_TYPE (x);
9240 DECL_ORIGINAL_TYPE (x) = tt;
9241 tt = build_variant_type_copy (tt);
9242 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9244 TREE_USED (tt) = TREE_USED (x);
9249 /* Returns true if X is a typedef decl. */
9252 is_typedef_decl (tree x)
9254 return (x && TREE_CODE (x) == TYPE_DECL
9255 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
9258 #include "gt-c-common.h"