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 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
734 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
735 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
736 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
737 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
738 { "_Sat", RID_SAT, D_CONLY | D_EXT },
739 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
740 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
741 { "__alignof", RID_ALIGNOF, 0 },
742 { "__alignof__", RID_ALIGNOF, 0 },
743 { "__asm", RID_ASM, 0 },
744 { "__asm__", RID_ASM, 0 },
745 { "__attribute", RID_ATTRIBUTE, 0 },
746 { "__attribute__", RID_ATTRIBUTE, 0 },
747 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
748 { "__builtin_offsetof", RID_OFFSETOF, 0 },
749 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
750 { "__builtin_va_arg", RID_VA_ARG, 0 },
751 { "__complex", RID_COMPLEX, 0 },
752 { "__complex__", RID_COMPLEX, 0 },
753 { "__const", RID_CONST, 0 },
754 { "__const__", RID_CONST, 0 },
755 { "__decltype", RID_DECLTYPE, D_CXXONLY },
756 { "__extension__", RID_EXTENSION, 0 },
757 { "__func__", RID_C99_FUNCTION_NAME, 0 },
758 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
759 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
760 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
761 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
762 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
763 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
764 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
765 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
766 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
767 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
768 { "__is_class", RID_IS_CLASS, D_CXXONLY },
769 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
770 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
771 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
772 { "__is_pod", RID_IS_POD, D_CXXONLY },
773 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
774 { "__is_union", RID_IS_UNION, D_CXXONLY },
775 { "__imag", RID_IMAGPART, 0 },
776 { "__imag__", RID_IMAGPART, 0 },
777 { "__inline", RID_INLINE, 0 },
778 { "__inline__", RID_INLINE, 0 },
779 { "__label__", RID_LABEL, 0 },
780 { "__null", RID_NULL, 0 },
781 { "__real", RID_REALPART, 0 },
782 { "__real__", RID_REALPART, 0 },
783 { "__restrict", RID_RESTRICT, 0 },
784 { "__restrict__", RID_RESTRICT, 0 },
785 { "__signed", RID_SIGNED, 0 },
786 { "__signed__", RID_SIGNED, 0 },
787 { "__thread", RID_THREAD, 0 },
788 { "__typeof", RID_TYPEOF, 0 },
789 { "__typeof__", RID_TYPEOF, 0 },
790 { "__volatile", RID_VOLATILE, 0 },
791 { "__volatile__", RID_VOLATILE, 0 },
792 { "asm", RID_ASM, D_ASM },
793 { "auto", RID_AUTO, 0 },
794 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
795 { "break", RID_BREAK, 0 },
796 { "case", RID_CASE, 0 },
797 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
798 { "char", RID_CHAR, 0 },
799 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
800 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
801 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
802 { "const", RID_CONST, 0 },
803 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
804 { "continue", RID_CONTINUE, 0 },
805 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
806 { "default", RID_DEFAULT, 0 },
807 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
809 { "double", RID_DOUBLE, 0 },
810 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
811 { "else", RID_ELSE, 0 },
812 { "enum", RID_ENUM, 0 },
813 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
814 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
815 { "extern", RID_EXTERN, 0 },
816 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
817 { "float", RID_FLOAT, 0 },
818 { "for", RID_FOR, 0 },
819 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
820 { "goto", RID_GOTO, 0 },
822 { "inline", RID_INLINE, D_EXT89 },
823 { "int", RID_INT, 0 },
824 { "long", RID_LONG, 0 },
825 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
826 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
827 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
828 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
829 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
830 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
831 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
832 { "register", RID_REGISTER, 0 },
833 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
834 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
835 { "return", RID_RETURN, 0 },
836 { "short", RID_SHORT, 0 },
837 { "signed", RID_SIGNED, 0 },
838 { "sizeof", RID_SIZEOF, 0 },
839 { "static", RID_STATIC, 0 },
840 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
841 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
842 { "struct", RID_STRUCT, 0 },
843 { "switch", RID_SWITCH, 0 },
844 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
845 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
846 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
847 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
848 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
849 { "typedef", RID_TYPEDEF, 0 },
850 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
851 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
852 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
853 { "union", RID_UNION, 0 },
854 { "unsigned", RID_UNSIGNED, 0 },
855 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
856 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
857 { "void", RID_VOID, 0 },
858 { "volatile", RID_VOLATILE, 0 },
859 { "wchar_t", RID_WCHAR, D_CXXONLY },
860 { "while", RID_WHILE, 0 },
861 /* These Objective-C keywords are recognized only immediately after
863 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
864 { "defs", RID_AT_DEFS, D_OBJC },
865 { "encode", RID_AT_ENCODE, D_OBJC },
866 { "end", RID_AT_END, D_OBJC },
867 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
868 { "interface", RID_AT_INTERFACE, D_OBJC },
869 { "protocol", RID_AT_PROTOCOL, D_OBJC },
870 { "selector", RID_AT_SELECTOR, D_OBJC },
871 { "finally", RID_AT_FINALLY, D_OBJC },
872 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
873 /* These are recognized only in protocol-qualifier context
875 { "bycopy", RID_BYCOPY, D_OBJC },
876 { "byref", RID_BYREF, D_OBJC },
877 { "in", RID_IN, D_OBJC },
878 { "inout", RID_INOUT, D_OBJC },
879 { "oneway", RID_ONEWAY, D_OBJC },
880 { "out", RID_OUT, D_OBJC },
883 const unsigned int num_c_common_reswords =
884 sizeof c_common_reswords / sizeof (struct c_common_resword);
886 /* Table of machine-independent attributes common to all C-like languages. */
887 const struct attribute_spec c_common_attribute_table[] =
889 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
890 { "packed", 0, 0, false, false, false,
891 handle_packed_attribute },
892 { "nocommon", 0, 0, true, false, false,
893 handle_nocommon_attribute },
894 { "common", 0, 0, true, false, false,
895 handle_common_attribute },
896 /* FIXME: logically, noreturn attributes should be listed as
897 "false, true, true" and apply to function types. But implementing this
898 would require all the places in the compiler that use TREE_THIS_VOLATILE
899 on a decl to identify non-returning functions to be located and fixed
900 to check the function type instead. */
901 { "noreturn", 0, 0, true, false, false,
902 handle_noreturn_attribute },
903 { "volatile", 0, 0, true, false, false,
904 handle_noreturn_attribute },
905 { "noinline", 0, 0, true, false, false,
906 handle_noinline_attribute },
907 { "always_inline", 0, 0, true, false, false,
908 handle_always_inline_attribute },
909 { "gnu_inline", 0, 0, true, false, false,
910 handle_gnu_inline_attribute },
911 { "artificial", 0, 0, true, false, false,
912 handle_artificial_attribute },
913 { "flatten", 0, 0, true, false, false,
914 handle_flatten_attribute },
915 { "used", 0, 0, true, false, false,
916 handle_used_attribute },
917 { "unused", 0, 0, false, false, false,
918 handle_unused_attribute },
919 { "externally_visible", 0, 0, true, false, false,
920 handle_externally_visible_attribute },
921 /* The same comments as for noreturn attributes apply to const ones. */
922 { "const", 0, 0, true, false, false,
923 handle_const_attribute },
924 { "transparent_union", 0, 0, false, false, false,
925 handle_transparent_union_attribute },
926 { "constructor", 0, 1, true, false, false,
927 handle_constructor_attribute },
928 { "destructor", 0, 1, true, false, false,
929 handle_destructor_attribute },
930 { "mode", 1, 1, false, true, false,
931 handle_mode_attribute },
932 { "section", 1, 1, true, false, false,
933 handle_section_attribute },
934 { "aligned", 0, 1, false, false, false,
935 handle_aligned_attribute },
936 { "weak", 0, 0, true, false, false,
937 handle_weak_attribute },
938 { "alias", 1, 1, true, false, false,
939 handle_alias_attribute },
940 { "weakref", 0, 1, true, false, false,
941 handle_weakref_attribute },
942 { "no_instrument_function", 0, 0, true, false, false,
943 handle_no_instrument_function_attribute },
944 { "malloc", 0, 0, true, false, false,
945 handle_malloc_attribute },
946 { "returns_twice", 0, 0, true, false, false,
947 handle_returns_twice_attribute },
948 { "no_stack_limit", 0, 0, true, false, false,
949 handle_no_limit_stack_attribute },
950 { "pure", 0, 0, true, false, false,
951 handle_pure_attribute },
952 /* For internal use (marking of builtins) only. The name contains space
953 to prevent its usage in source code. */
954 { "no vops", 0, 0, true, false, false,
955 handle_novops_attribute },
956 { "deprecated", 0, 0, false, false, false,
957 handle_deprecated_attribute },
958 { "vector_size", 1, 1, false, true, false,
959 handle_vector_size_attribute },
960 { "visibility", 1, 1, false, false, false,
961 handle_visibility_attribute },
962 { "tls_model", 1, 1, true, false, false,
963 handle_tls_model_attribute },
964 { "nonnull", 0, -1, false, true, true,
965 handle_nonnull_attribute },
966 { "nothrow", 0, 0, true, false, false,
967 handle_nothrow_attribute },
968 { "may_alias", 0, 0, false, true, false, NULL },
969 { "cleanup", 1, 1, true, false, false,
970 handle_cleanup_attribute },
971 { "warn_unused_result", 0, 0, false, true, true,
972 handle_warn_unused_result_attribute },
973 { "sentinel", 0, 1, false, true, true,
974 handle_sentinel_attribute },
975 /* For internal use (marking of builtins) only. The name contains space
976 to prevent its usage in source code. */
977 { "type generic", 0, 0, false, true, true,
978 handle_type_generic_attribute },
979 { "alloc_size", 1, 2, false, true, true,
980 handle_alloc_size_attribute },
981 { "cold", 0, 0, true, false, false,
982 handle_cold_attribute },
983 { "hot", 0, 0, true, false, false,
984 handle_hot_attribute },
985 { "warning", 1, 1, true, false, false,
986 handle_error_attribute },
987 { "error", 1, 1, true, false, false,
988 handle_error_attribute },
989 { "target", 1, -1, true, false, false,
990 handle_target_attribute },
991 { "optimize", 1, -1, true, false, false,
992 handle_optimize_attribute },
993 { NULL, 0, 0, false, false, false, NULL }
996 /* Give the specifications for the format attributes, used by C and all
999 const struct attribute_spec c_common_format_attribute_table[] =
1001 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1002 { "format", 3, 3, false, true, true,
1003 handle_format_attribute },
1004 { "format_arg", 1, 1, false, true, true,
1005 handle_format_arg_attribute },
1006 { NULL, 0, 0, false, false, false, NULL }
1009 /* Push current bindings for the function name VAR_DECLS. */
1012 start_fname_decls (void)
1015 tree saved = NULL_TREE;
1017 for (ix = 0; fname_vars[ix].decl; ix++)
1019 tree decl = *fname_vars[ix].decl;
1023 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
1024 *fname_vars[ix].decl = NULL_TREE;
1027 if (saved || saved_function_name_decls)
1028 /* Normally they'll have been NULL, so only push if we've got a
1029 stack, or they are non-NULL. */
1030 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1031 saved_function_name_decls);
1034 /* Finish up the current bindings, adding them into the current function's
1035 statement tree. This must be done _before_ finish_stmt_tree is called.
1036 If there is no current function, we must be at file scope and no statements
1037 are involved. Pop the previous bindings. */
1040 finish_fname_decls (void)
1043 tree stmts = NULL_TREE;
1044 tree stack = saved_function_name_decls;
1046 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1047 append_to_statement_list (TREE_VALUE (stack), &stmts);
1051 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
1053 if (TREE_CODE (*bodyp) == BIND_EXPR)
1054 bodyp = &BIND_EXPR_BODY (*bodyp);
1056 append_to_statement_list_force (*bodyp, &stmts);
1060 for (ix = 0; fname_vars[ix].decl; ix++)
1061 *fname_vars[ix].decl = NULL_TREE;
1065 /* We had saved values, restore them. */
1068 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
1070 tree decl = TREE_PURPOSE (saved);
1071 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1073 *fname_vars[ix].decl = decl;
1075 stack = TREE_CHAIN (stack);
1077 saved_function_name_decls = stack;
1080 /* Return the text name of the current function, suitably prettified
1081 by PRETTY_P. Return string must be freed by caller. */
1084 fname_as_string (int pretty_p)
1086 const char *name = "top level";
1089 cpp_string cstr = { 0, 0 }, strname;
1097 if (current_function_decl)
1098 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
1100 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
1102 namep = XNEWVEC (char, len);
1103 snprintf (namep, len, "\"%s\"", name);
1104 strname.text = (unsigned char *) namep;
1105 strname.len = len - 1;
1107 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
1110 return (const char *) cstr.text;
1116 /* Return the VAR_DECL for a const char array naming the current
1117 function. If the VAR_DECL has not yet been created, create it
1118 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1119 ID is its name (unfortunately C and C++ hold the RID values of
1120 keywords in different places, so we can't derive RID from ID in
1121 this language independent code. LOC is the location of the
1125 fname_decl (location_t loc, unsigned int rid, tree id)
1128 tree decl = NULL_TREE;
1130 for (ix = 0; fname_vars[ix].decl; ix++)
1131 if (fname_vars[ix].rid == rid)
1134 decl = *fname_vars[ix].decl;
1137 /* If a tree is built here, it would normally have the lineno of
1138 the current statement. Later this tree will be moved to the
1139 beginning of the function and this line number will be wrong.
1140 To avoid this problem set the lineno to 0 here; that prevents
1141 it from appearing in the RTL. */
1143 location_t saved_location = input_location;
1144 input_location = UNKNOWN_LOCATION;
1146 stmts = push_stmt_list ();
1147 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1148 stmts = pop_stmt_list (stmts);
1149 if (!IS_EMPTY_STMT (stmts))
1150 saved_function_name_decls
1151 = tree_cons (decl, stmts, saved_function_name_decls);
1152 *fname_vars[ix].decl = decl;
1153 input_location = saved_location;
1155 if (!ix && !current_function_decl)
1156 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1161 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1164 fix_string_type (tree value)
1166 int length = TREE_STRING_LENGTH (value);
1168 tree e_type, i_type, a_type;
1170 /* Compute the number of elements, for the array type. */
1171 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1174 e_type = char_type_node;
1176 else if (TREE_TYPE (value) == char16_array_type_node)
1178 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1179 e_type = char16_type_node;
1181 else if (TREE_TYPE (value) == char32_array_type_node)
1183 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1184 e_type = char32_type_node;
1188 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1189 e_type = wchar_type_node;
1192 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1193 limit in C++98 Annex B is very large (65536) and is not normative,
1194 so we do not diagnose it (warn_overlength_strings is forced off
1195 in c_common_post_options). */
1196 if (warn_overlength_strings)
1198 const int nchars_max = flag_isoc99 ? 4095 : 509;
1199 const int relevant_std = flag_isoc99 ? 99 : 90;
1200 if (nchars - 1 > nchars_max)
1201 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1202 separate the %d from the 'C'. 'ISO' should not be
1203 translated, but it may be moved after 'C%d' in languages
1204 where modifiers follow nouns. */
1205 pedwarn (input_location, OPT_Woverlength_strings,
1206 "string length %qd is greater than the length %qd "
1207 "ISO C%d compilers are required to support",
1208 nchars - 1, nchars_max, relevant_std);
1211 /* Create the array type for the string constant. The ISO C++
1212 standard says that a string literal has type `const char[N]' or
1213 `const wchar_t[N]'. We use the same logic when invoked as a C
1214 front-end with -Wwrite-strings.
1215 ??? We should change the type of an expression depending on the
1216 state of a warning flag. We should just be warning -- see how
1217 this is handled in the C++ front-end for the deprecated implicit
1218 conversion from string literals to `char*' or `wchar_t*'.
1220 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1221 array type being the unqualified version of that type.
1222 Therefore, if we are constructing an array of const char, we must
1223 construct the matching unqualified array type first. The C front
1224 end does not require this, but it does no harm, so we do it
1226 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1227 a_type = build_array_type (e_type, i_type);
1228 if (c_dialect_cxx() || warn_write_strings)
1229 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1231 TREE_TYPE (value) = a_type;
1232 TREE_CONSTANT (value) = 1;
1233 TREE_READONLY (value) = 1;
1234 TREE_STATIC (value) = 1;
1238 /* Fully fold EXPR, an expression that was not folded (beyond integer
1239 constant expressions and null pointer constants) when being built
1240 up. If IN_INIT, this is in a static initializer and certain
1241 changes are made to the folding done. Clear *MAYBE_CONST if
1242 MAYBE_CONST is not NULL and EXPR is definitely not a constant
1243 expression because it contains an evaluated operator (in C99) or an
1244 operator outside of sizeof returning an integer constant (in C90)
1245 not permitted in constant expressions, or because it contains an
1246 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
1247 set to true by callers before calling this function.) Return the
1248 folded expression. Function arguments have already been folded
1249 before calling this function, as have the contents of SAVE_EXPR,
1250 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1251 C_MAYBE_CONST_EXPR. */
1254 c_fully_fold (tree expr, bool in_init, bool *maybe_const)
1257 tree eptype = NULL_TREE;
1259 bool maybe_const_itself = true;
1261 /* This function is not relevant to C++ because C++ folds while
1262 parsing, and may need changes to be correct for C++ when C++
1263 stops folding while parsing. */
1264 if (c_dialect_cxx ())
1268 maybe_const = &dummy;
1269 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
1271 eptype = TREE_TYPE (expr);
1272 expr = TREE_OPERAND (expr, 0);
1274 ret = c_fully_fold_internal (expr, in_init, maybe_const,
1275 &maybe_const_itself);
1277 ret = fold_convert (eptype, ret);
1278 *maybe_const &= maybe_const_itself;
1282 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1283 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1284 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1285 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1286 both evaluated and unevaluated subexpressions while
1287 *MAYBE_CONST_ITSELF is carried from only evaluated
1291 c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1292 bool *maybe_const_itself)
1295 enum tree_code code = TREE_CODE (expr);
1296 enum tree_code_class kind = TREE_CODE_CLASS (code);
1297 location_t loc = EXPR_LOCATION (expr);
1298 tree op0, op1, op2, op3;
1299 tree orig_op0, orig_op1, orig_op2;
1300 bool op0_const = true, op1_const = true, op2_const = true;
1301 bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1302 bool nowarning = TREE_NO_WARNING (expr);
1304 /* This function is not relevant to C++ because C++ folds while
1305 parsing, and may need changes to be correct for C++ when C++
1306 stops folding while parsing. */
1307 if (c_dialect_cxx ())
1310 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1311 anything else not counted as an expression cannot usefully be
1312 folded further at this point. */
1313 if (!IS_EXPR_CODE_CLASS (kind)
1314 || kind == tcc_statement
1315 || code == SAVE_EXPR)
1318 /* Operands of variable-length expressions (function calls) have
1319 already been folded, as have __builtin_* function calls, and such
1320 expressions cannot occur in constant expressions. */
1321 if (kind == tcc_vl_exp)
1323 *maybe_const_operands = false;
1328 if (code == C_MAYBE_CONST_EXPR)
1330 tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1331 tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1332 if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1333 *maybe_const_operands = false;
1334 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1335 *maybe_const_itself = false;
1336 if (pre && !in_init)
1337 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1343 /* Assignment, increment, decrement, function call and comma
1344 operators, and statement expressions, cannot occur in constant
1345 expressions if evaluated / outside of sizeof. (Function calls
1346 were handled above, though VA_ARG_EXPR is treated like a function
1347 call here, and statement expressions are handled through
1348 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1352 case PREDECREMENT_EXPR:
1353 case PREINCREMENT_EXPR:
1354 case POSTDECREMENT_EXPR:
1355 case POSTINCREMENT_EXPR:
1357 *maybe_const_operands = false;
1364 *maybe_const_operands = false;
1372 /* Fold individual tree codes as appropriate. */
1375 case COMPOUND_LITERAL_EXPR:
1376 /* Any non-constancy will have been marked in a containing
1377 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1381 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1382 op1 = TREE_OPERAND (expr, 1);
1383 op2 = TREE_OPERAND (expr, 2);
1384 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1385 maybe_const_itself);
1386 if (op0 != orig_op0)
1387 ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1390 TREE_READONLY (ret) = TREE_READONLY (expr);
1391 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1396 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1397 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1398 op2 = TREE_OPERAND (expr, 2);
1399 op3 = TREE_OPERAND (expr, 3);
1400 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1401 maybe_const_itself);
1402 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1403 maybe_const_itself);
1404 op1 = decl_constant_value_for_optimization (op1);
1405 if (op0 != orig_op0 || op1 != orig_op1)
1406 ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1409 TREE_READONLY (ret) = TREE_READONLY (expr);
1410 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1411 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1418 case PREDECREMENT_EXPR:
1419 case PREINCREMENT_EXPR:
1420 case POSTDECREMENT_EXPR:
1421 case POSTINCREMENT_EXPR:
1425 case POINTER_PLUS_EXPR:
1426 case TRUNC_DIV_EXPR:
1428 case FLOOR_DIV_EXPR:
1429 case TRUNC_MOD_EXPR:
1431 case EXACT_DIV_EXPR:
1444 case TRUTH_AND_EXPR:
1446 case TRUTH_XOR_EXPR:
1447 case UNORDERED_EXPR:
1454 /* Binary operations evaluating both arguments (increment and
1455 decrement are binary internally in GCC). */
1456 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1457 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1458 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1459 maybe_const_itself);
1460 if (code != MODIFY_EXPR
1461 && code != PREDECREMENT_EXPR
1462 && code != PREINCREMENT_EXPR
1463 && code != POSTDECREMENT_EXPR
1464 && code != POSTINCREMENT_EXPR)
1465 op0 = decl_constant_value_for_optimization (op0);
1466 /* The RHS of a MODIFY_EXPR was fully folded when building that
1467 expression for the sake of conversion warnings. */
1468 if (code != MODIFY_EXPR)
1469 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1470 maybe_const_itself);
1471 op1 = decl_constant_value_for_optimization (op1);
1472 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1474 ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
1475 : fold_build2 (code, TREE_TYPE (expr), op0, op1);
1481 case FIX_TRUNC_EXPR:
1484 case NON_LVALUE_EXPR:
1487 case TRUTH_NOT_EXPR:
1492 /* Unary operations. */
1493 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1494 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1495 maybe_const_itself);
1496 if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1497 op0 = decl_constant_value_for_optimization (op0);
1498 if (op0 != orig_op0 || in_init)
1500 ? fold_build1_initializer (code, TREE_TYPE (expr), op0)
1501 : fold_build1 (code, TREE_TYPE (expr), op0);
1504 if (code == INDIRECT_REF
1506 && TREE_CODE (ret) == INDIRECT_REF)
1508 TREE_READONLY (ret) = TREE_READONLY (expr);
1509 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1510 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1514 case TRUTH_ANDIF_EXPR:
1515 case TRUTH_ORIF_EXPR:
1516 /* Binary operations not necessarily evaluating both
1518 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1519 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1520 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1521 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1522 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1524 ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
1525 : fold_build2 (code, TREE_TYPE (expr), op0, op1);
1528 *maybe_const_operands &= op0_const;
1529 *maybe_const_itself &= op0_const_self;
1533 && (code == TRUTH_ANDIF_EXPR
1534 ? op0 == truthvalue_false_node
1535 : op0 == truthvalue_true_node)))
1536 *maybe_const_operands &= op1_const;
1539 && (code == TRUTH_ANDIF_EXPR
1540 ? op0 == truthvalue_false_node
1541 : op0 == truthvalue_true_node)))
1542 *maybe_const_itself &= op1_const_self;
1546 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1547 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1548 orig_op2 = op2 = TREE_OPERAND (expr, 2);
1549 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1550 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1551 op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
1552 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
1553 ret = fold_build3 (code, TREE_TYPE (expr), op0, op1, op2);
1556 *maybe_const_operands &= op0_const;
1557 *maybe_const_itself &= op0_const_self;
1561 && op0 == truthvalue_false_node))
1562 *maybe_const_operands &= op1_const;
1565 && op0 == truthvalue_false_node))
1566 *maybe_const_itself &= op1_const_self;
1570 && op0 == truthvalue_true_node))
1571 *maybe_const_operands &= op2_const;
1574 && op0 == truthvalue_true_node))
1575 *maybe_const_itself &= op2_const_self;
1578 case EXCESS_PRECISION_EXPR:
1579 /* Each case where an operand with excess precision may be
1580 encountered must remove the EXCESS_PRECISION_EXPR around
1581 inner operands and possibly put one around the whole
1582 expression or possibly convert to the semantic type (which
1583 c_fully_fold does); we cannot tell at this stage which is
1584 appropriate in any particular case. */
1588 /* Various codes may appear through folding built-in functions
1589 and their arguments. */
1594 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1595 have been done by this point, so remove them again. */
1596 nowarning |= TREE_NO_WARNING (ret);
1597 STRIP_TYPE_NOPS (ret);
1598 if (nowarning && !TREE_NO_WARNING (ret))
1600 if (!CAN_HAVE_LOCATION_P (ret))
1601 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1602 TREE_NO_WARNING (ret) = 1;
1605 protected_set_expr_location (ret, loc);
1609 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1610 return EXP. Otherwise, return either EXP or its known constant
1611 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1612 Is the BLKmode test appropriate? */
1615 decl_constant_value_for_optimization (tree exp)
1619 /* This function is only used by C, for c_fully_fold and other
1620 optimization, and may not be correct for C++. */
1621 if (c_dialect_cxx ())
1625 || TREE_CODE (exp) != VAR_DECL
1626 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1627 || DECL_MODE (exp) == BLKmode)
1630 ret = decl_constant_value (exp);
1631 /* Avoid unwanted tree sharing between the initializer and current
1632 function's body where the tree can be modified e.g. by the
1634 if (ret != exp && TREE_STATIC (exp))
1635 ret = unshare_expr (ret);
1639 /* Print a warning if a constant expression had overflow in folding.
1640 Invoke this function on every expression that the language
1641 requires to be a constant expression.
1642 Note the ANSI C standard says it is erroneous for a
1643 constant expression to overflow. */
1646 constant_expression_warning (tree value)
1648 if (warn_overflow && pedantic
1649 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1650 || TREE_CODE (value) == FIXED_CST
1651 || TREE_CODE (value) == VECTOR_CST
1652 || TREE_CODE (value) == COMPLEX_CST)
1653 && TREE_OVERFLOW (value))
1654 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1657 /* The same as above but print an unconditional error. */
1659 constant_expression_error (tree value)
1661 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1662 || TREE_CODE (value) == FIXED_CST
1663 || TREE_CODE (value) == VECTOR_CST
1664 || TREE_CODE (value) == COMPLEX_CST)
1665 && TREE_OVERFLOW (value))
1666 error ("overflow in constant expression");
1669 /* Print a warning if an expression had overflow in folding and its
1672 Invoke this function on every expression that
1673 (1) appears in the source code, and
1674 (2) is a constant expression that overflowed, and
1675 (3) is not already checked by convert_and_check;
1676 however, do not invoke this function on operands of explicit casts
1677 or when the expression is the result of an operator and any operand
1678 already overflowed. */
1681 overflow_warning (tree value)
1683 if (skip_evaluation) return;
1685 switch (TREE_CODE (value))
1688 warning (OPT_Woverflow, "integer overflow in expression");
1692 warning (OPT_Woverflow, "floating point overflow in expression");
1696 warning (OPT_Woverflow, "fixed-point overflow in expression");
1700 warning (OPT_Woverflow, "vector overflow in expression");
1704 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1705 warning (OPT_Woverflow, "complex integer overflow in expression");
1706 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1707 warning (OPT_Woverflow, "complex floating point overflow in expression");
1715 /* Warn about uses of logical || / && operator in a context where it
1716 is likely that the bitwise equivalent was intended by the
1717 programmer. We have seen an expression in which CODE is a binary
1718 operator used to combine expressions OP_LEFT and OP_RIGHT, which
1719 before folding had CODE_LEFT and CODE_RIGHT. */
1722 warn_logical_operator (location_t location, enum tree_code code,
1723 enum tree_code code_left, tree op_left,
1724 enum tree_code ARG_UNUSED (code_right), tree op_right)
1726 if (code != TRUTH_ANDIF_EXPR
1727 && code != TRUTH_AND_EXPR
1728 && code != TRUTH_ORIF_EXPR
1729 && code != TRUTH_OR_EXPR)
1732 /* Warn if &&/|| are being used in a context where it is
1733 likely that the bitwise equivalent was intended by the
1734 programmer. That is, an expression such as op && MASK
1735 where op should not be any boolean expression, nor a
1736 constant, and mask seems to be a non-boolean integer constant. */
1737 if (!truth_value_p (code_left)
1738 && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1739 && !CONSTANT_CLASS_P (op_left)
1740 && !TREE_NO_WARNING (op_left)
1741 && TREE_CODE (op_right) == INTEGER_CST
1742 && !integer_zerop (op_right)
1743 && !integer_onep (op_right))
1745 if (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR)
1746 warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1747 " applied to non-boolean constant");
1749 warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1750 " applied to non-boolean constant");
1751 TREE_NO_WARNING (op_left) = true;
1756 /* Print a warning about casts that might indicate violation
1757 of strict aliasing rules if -Wstrict-aliasing is used and
1758 strict aliasing mode is in effect. OTYPE is the original
1759 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1762 strict_aliasing_warning (tree otype, tree type, tree expr)
1764 if (!(flag_strict_aliasing
1765 && POINTER_TYPE_P (type)
1766 && POINTER_TYPE_P (otype)
1767 && !VOID_TYPE_P (TREE_TYPE (type)))
1768 /* If the type we are casting to is a ref-all pointer
1769 dereferencing it is always valid. */
1770 || TYPE_REF_CAN_ALIAS_ALL (type))
1773 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1774 && (DECL_P (TREE_OPERAND (expr, 0))
1775 || handled_component_p (TREE_OPERAND (expr, 0))))
1777 /* Casting the address of an object to non void pointer. Warn
1778 if the cast breaks type based aliasing. */
1779 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1781 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1782 "might break strict-aliasing rules");
1787 /* warn_strict_aliasing >= 3. This includes the default (3).
1788 Only warn if the cast is dereferenced immediately. */
1789 alias_set_type set1 =
1790 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1791 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1793 if (set1 != set2 && set2 != 0
1794 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1796 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1797 "pointer will break strict-aliasing rules");
1800 else if (warn_strict_aliasing == 2
1801 && !alias_sets_must_conflict_p (set1, set2))
1803 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1804 "pointer might break strict-aliasing rules");
1810 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1812 /* At this level, warn for any conversions, even if an address is
1813 not taken in the same statement. This will likely produce many
1814 false positives, but could be useful to pinpoint problems that
1815 are not revealed at higher levels. */
1816 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1817 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1818 if (!COMPLETE_TYPE_P (type)
1819 || !alias_sets_must_conflict_p (set1, set2))
1821 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1822 "pointer might break strict-aliasing rules");
1830 /* Warn for unlikely, improbable, or stupid DECL declarations
1834 check_main_parameter_types (tree decl)
1839 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1840 args = TREE_CHAIN (args))
1842 tree type = args ? TREE_VALUE (args) : 0;
1844 if (type == void_type_node || type == error_mark_node )
1851 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1852 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1857 if (TREE_CODE (type) != POINTER_TYPE
1858 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1859 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1861 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1866 if (TREE_CODE (type) != POINTER_TYPE
1867 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1868 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1870 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1871 "%<char **%>", decl);
1876 /* It is intentional that this message does not mention the third
1877 argument because it's only mentioned in an appendix of the
1879 if (argct > 0 && (argct < 2 || argct > 3))
1880 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1883 /* True if pointers to distinct types T1 and T2 can be converted to
1884 each other without an explicit cast. Only returns true for opaque
1887 vector_targets_convertible_p (const_tree t1, const_tree t2)
1889 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1890 && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1891 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1897 /* True if vector types T1 and T2 can be converted to each other
1898 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1899 can only be converted with -flax-vector-conversions yet that is not
1900 in effect, emit a note telling the user about that option if such
1901 a note has not previously been emitted. */
1903 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1905 static bool emitted_lax_note = false;
1906 bool convertible_lax;
1908 if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1909 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1913 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1914 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1915 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1916 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1917 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1919 if (!convertible_lax || flag_lax_vector_conversions)
1920 return convertible_lax;
1922 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1923 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1926 if (emit_lax_note && !emitted_lax_note)
1928 emitted_lax_note = true;
1929 inform (input_location, "use -flax-vector-conversions to permit "
1930 "conversions between vectors with differing "
1931 "element types or numbers of subparts");
1937 /* This is a helper function of build_binary_op.
1939 For certain operations if both args were extended from the same
1940 smaller type, do the arithmetic in that type and then extend.
1942 BITWISE indicates a bitwise operation.
1943 For them, this optimization is safe only if
1944 both args are zero-extended or both are sign-extended.
1945 Otherwise, we might change the result.
1946 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1947 but calculated in (unsigned short) it would be (unsigned short)-1.
1949 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1951 int unsigned0, unsigned1;
1956 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1957 excessive narrowing when we call get_narrower below. For
1958 example, suppose that OP0 is of unsigned int extended
1959 from signed char and that RESULT_TYPE is long long int.
1960 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1963 (long long int) (unsigned int) signed_char
1965 which get_narrower would narrow down to
1967 (unsigned int) signed char
1969 If we do not cast OP0 first, get_narrower would return
1970 signed_char, which is inconsistent with the case of the
1972 op0 = convert (result_type, op0);
1973 op1 = convert (result_type, op1);
1975 arg0 = get_narrower (op0, &unsigned0);
1976 arg1 = get_narrower (op1, &unsigned1);
1978 /* UNS is 1 if the operation to be done is an unsigned one. */
1979 uns = TYPE_UNSIGNED (result_type);
1981 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1982 but it *requires* conversion to FINAL_TYPE. */
1984 if ((TYPE_PRECISION (TREE_TYPE (op0))
1985 == TYPE_PRECISION (TREE_TYPE (arg0)))
1986 && TREE_TYPE (op0) != result_type)
1987 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1988 if ((TYPE_PRECISION (TREE_TYPE (op1))
1989 == TYPE_PRECISION (TREE_TYPE (arg1)))
1990 && TREE_TYPE (op1) != result_type)
1991 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1993 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1995 /* For bitwise operations, signedness of nominal type
1996 does not matter. Consider only how operands were extended. */
2000 /* Note that in all three cases below we refrain from optimizing
2001 an unsigned operation on sign-extended args.
2002 That would not be valid. */
2004 /* Both args variable: if both extended in same way
2005 from same width, do it in that width.
2006 Do it unsigned if args were zero-extended. */
2007 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2008 < TYPE_PRECISION (result_type))
2009 && (TYPE_PRECISION (TREE_TYPE (arg1))
2010 == TYPE_PRECISION (TREE_TYPE (arg0)))
2011 && unsigned0 == unsigned1
2012 && (unsigned0 || !uns))
2013 return c_common_signed_or_unsigned_type
2014 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2016 else if (TREE_CODE (arg0) == INTEGER_CST
2017 && (unsigned1 || !uns)
2018 && (TYPE_PRECISION (TREE_TYPE (arg1))
2019 < TYPE_PRECISION (result_type))
2021 = c_common_signed_or_unsigned_type (unsigned1,
2023 && !POINTER_TYPE_P (type)
2024 && int_fits_type_p (arg0, type))
2027 else if (TREE_CODE (arg1) == INTEGER_CST
2028 && (unsigned0 || !uns)
2029 && (TYPE_PRECISION (TREE_TYPE (arg0))
2030 < TYPE_PRECISION (result_type))
2032 = c_common_signed_or_unsigned_type (unsigned0,
2034 && !POINTER_TYPE_P (type)
2035 && int_fits_type_p (arg1, type))
2041 /* Warns if the conversion of EXPR to TYPE may alter a value.
2042 This is a helper function for warnings_for_convert_and_check. */
2045 conversion_warning (tree type, tree expr)
2047 bool give_warning = false;
2050 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
2051 tree expr_type = TREE_TYPE (expr);
2053 if (!warn_conversion && !warn_sign_conversion)
2056 /* If any operand is artificial, then this expression was generated
2057 by the compiler and we do not warn. */
2058 for (i = 0; i < expr_num_operands; i++)
2060 tree op = TREE_OPERAND (expr, i);
2061 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
2065 switch (TREE_CODE (expr))
2073 case TRUTH_ANDIF_EXPR:
2074 case TRUTH_ORIF_EXPR:
2075 case TRUTH_AND_EXPR:
2077 case TRUTH_XOR_EXPR:
2078 case TRUTH_NOT_EXPR:
2079 /* Conversion from boolean to a signed:1 bit-field (which only
2080 can hold the values 0 and -1) doesn't lose information - but
2081 it does change the value. */
2082 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
2083 warning (OPT_Wconversion,
2084 "conversion to %qT from boolean expression", type);
2090 /* Warn for real constant that is not an exact integer converted
2092 if (TREE_CODE (expr_type) == REAL_TYPE
2093 && TREE_CODE (type) == INTEGER_TYPE)
2095 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
2096 give_warning = true;
2098 /* Warn for an integer constant that does not fit into integer type. */
2099 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2100 && TREE_CODE (type) == INTEGER_TYPE
2101 && !int_fits_type_p (expr, type))
2103 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
2104 && tree_int_cst_sgn (expr) < 0)
2105 warning (OPT_Wsign_conversion,
2106 "negative integer implicitly converted to unsigned type");
2107 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
2108 warning (OPT_Wsign_conversion, "conversion of unsigned constant "
2109 "value to negative integer");
2111 give_warning = true;
2113 else if (TREE_CODE (type) == REAL_TYPE)
2115 /* Warn for an integer constant that does not fit into real type. */
2116 if (TREE_CODE (expr_type) == INTEGER_TYPE)
2118 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
2119 if (!exact_real_truncate (TYPE_MODE (type), &a))
2120 give_warning = true;
2122 /* Warn for a real constant that does not fit into a smaller
2124 else if (TREE_CODE (expr_type) == REAL_TYPE
2125 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2127 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
2128 if (!exact_real_truncate (TYPE_MODE (type), &a))
2129 give_warning = true;
2134 warning (OPT_Wconversion,
2135 "conversion to %qT alters %qT constant value",
2142 /* In case of COND_EXPR, if both operands are constants or
2143 COND_EXPR, then we do not care about the type of COND_EXPR,
2144 only about the conversion of each operand. */
2145 tree op1 = TREE_OPERAND (expr, 1);
2146 tree op2 = TREE_OPERAND (expr, 2);
2148 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
2149 || TREE_CODE (op1) == COND_EXPR)
2150 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
2151 || TREE_CODE (op2) == COND_EXPR))
2153 conversion_warning (type, op1);
2154 conversion_warning (type, op2);
2160 default: /* 'expr' is not a constant. */
2162 /* Warn for real types converted to integer types. */
2163 if (TREE_CODE (expr_type) == REAL_TYPE
2164 && TREE_CODE (type) == INTEGER_TYPE)
2165 give_warning = true;
2167 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2168 && TREE_CODE (type) == INTEGER_TYPE)
2170 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2171 expr = get_unwidened (expr, 0);
2172 expr_type = TREE_TYPE (expr);
2174 /* Don't warn for short y; short x = ((int)y & 0xff); */
2175 if (TREE_CODE (expr) == BIT_AND_EXPR
2176 || TREE_CODE (expr) == BIT_IOR_EXPR
2177 || TREE_CODE (expr) == BIT_XOR_EXPR)
2179 /* If both args were extended from a shortest type,
2180 use that type if that is safe. */
2181 expr_type = shorten_binary_op (expr_type,
2182 TREE_OPERAND (expr, 0),
2183 TREE_OPERAND (expr, 1),
2186 if (TREE_CODE (expr) == BIT_AND_EXPR)
2188 tree op0 = TREE_OPERAND (expr, 0);
2189 tree op1 = TREE_OPERAND (expr, 1);
2190 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2191 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2193 /* If one of the operands is a non-negative constant
2194 that fits in the target type, then the type of the
2195 other operand does not matter. */
2196 if ((TREE_CODE (op0) == INTEGER_CST
2197 && int_fits_type_p (op0, c_common_signed_type (type))
2198 && int_fits_type_p (op0, c_common_unsigned_type (type)))
2199 || (TREE_CODE (op1) == INTEGER_CST
2200 && int_fits_type_p (op1, c_common_signed_type (type))
2201 && int_fits_type_p (op1,
2202 c_common_unsigned_type (type))))
2204 /* If constant is unsigned and fits in the target
2205 type, then the result will also fit. */
2206 else if ((TREE_CODE (op0) == INTEGER_CST
2208 && int_fits_type_p (op0, type))
2209 || (TREE_CODE (op1) == INTEGER_CST
2211 && int_fits_type_p (op1, type)))
2215 /* Warn for integer types converted to smaller integer types. */
2216 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2217 give_warning = true;
2219 /* When they are the same width but different signedness,
2220 then the value may change. */
2221 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2222 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
2223 /* Even when converted to a bigger type, if the type is
2224 unsigned but expr is signed, then negative values
2226 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
2227 warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
2228 "may change the sign of the result",
2232 /* Warn for integer types converted to real types if and only if
2233 all the range of values of the integer type cannot be
2234 represented by the real type. */
2235 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2236 && TREE_CODE (type) == REAL_TYPE)
2238 tree type_low_bound = TYPE_MIN_VALUE (expr_type);
2239 tree type_high_bound = TYPE_MAX_VALUE (expr_type);
2240 REAL_VALUE_TYPE real_low_bound
2241 = real_value_from_int_cst (0, type_low_bound);
2242 REAL_VALUE_TYPE real_high_bound
2243 = real_value_from_int_cst (0, type_high_bound);
2245 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2246 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2247 give_warning = true;
2250 /* Warn for real types converted to smaller real types. */
2251 else if (TREE_CODE (expr_type) == REAL_TYPE
2252 && TREE_CODE (type) == REAL_TYPE
2253 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2254 give_warning = true;
2258 warning (OPT_Wconversion,
2259 "conversion to %qT from %qT may alter its value",
2264 /* Produce warnings after a conversion. RESULT is the result of
2265 converting EXPR to TYPE. This is a helper function for
2266 convert_and_check and cp_convert_and_check. */
2269 warnings_for_convert_and_check (tree type, tree expr, tree result)
2271 if (TREE_CODE (expr) == INTEGER_CST
2272 && (TREE_CODE (type) == INTEGER_TYPE
2273 || TREE_CODE (type) == ENUMERAL_TYPE)
2274 && !int_fits_type_p (expr, type))
2276 /* Do not diagnose overflow in a constant expression merely
2277 because a conversion overflowed. */
2278 if (TREE_OVERFLOW (result))
2279 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2281 if (TYPE_UNSIGNED (type))
2283 /* This detects cases like converting -129 or 256 to
2285 if (!int_fits_type_p (expr, c_common_signed_type (type)))
2286 warning (OPT_Woverflow,
2287 "large integer implicitly truncated to unsigned type");
2289 conversion_warning (type, expr);
2291 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
2292 warning (OPT_Woverflow,
2293 "overflow in implicit constant conversion");
2294 /* No warning for converting 0x80000000 to int. */
2296 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2297 || TYPE_PRECISION (TREE_TYPE (expr))
2298 != TYPE_PRECISION (type)))
2299 warning (OPT_Woverflow,
2300 "overflow in implicit constant conversion");
2303 conversion_warning (type, expr);
2305 else if ((TREE_CODE (result) == INTEGER_CST
2306 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
2307 warning (OPT_Woverflow,
2308 "overflow in implicit constant conversion");
2310 conversion_warning (type, expr);
2314 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2315 Invoke this function on every expression that is converted implicitly,
2316 i.e. because of language rules and not because of an explicit cast. */
2319 convert_and_check (tree type, tree expr)
2322 tree expr_for_warning;
2324 /* Convert from a value with possible excess precision rather than
2325 via the semantic type, but do not warn about values not fitting
2326 exactly in the semantic type. */
2327 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2329 tree orig_type = TREE_TYPE (expr);
2330 expr = TREE_OPERAND (expr, 0);
2331 expr_for_warning = convert (orig_type, expr);
2332 if (orig_type == type)
2333 return expr_for_warning;
2336 expr_for_warning = expr;
2338 if (TREE_TYPE (expr) == type)
2341 result = convert (type, expr);
2343 if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
2344 warnings_for_convert_and_check (type, expr_for_warning, result);
2349 /* A node in a list that describes references to variables (EXPR), which are
2350 either read accesses if WRITER is zero, or write accesses, in which case
2351 WRITER is the parent of EXPR. */
2358 /* Used to implement a cache the results of a call to verify_tree. We only
2359 use this for SAVE_EXPRs. */
2362 struct tlist_cache *next;
2363 struct tlist *cache_before_sp;
2364 struct tlist *cache_after_sp;
2368 /* Obstack to use when allocating tlist structures, and corresponding
2370 static struct obstack tlist_obstack;
2371 static char *tlist_firstobj = 0;
2373 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2375 static struct tlist *warned_ids;
2376 /* SAVE_EXPRs need special treatment. We process them only once and then
2377 cache the results. */
2378 static struct tlist_cache *save_expr_cache;
2380 static void add_tlist (struct tlist **, struct tlist *, tree, int);
2381 static void merge_tlist (struct tlist **, struct tlist *, int);
2382 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2383 static int warning_candidate_p (tree);
2384 static void warn_for_collisions (struct tlist *);
2385 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2386 static struct tlist *new_tlist (struct tlist *, tree, tree);
2388 /* Create a new struct tlist and fill in its fields. */
2389 static struct tlist *
2390 new_tlist (struct tlist *next, tree t, tree writer)
2393 l = XOBNEW (&tlist_obstack, struct tlist);
2400 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2401 is nonnull, we ignore any node we find which has a writer equal to it. */
2404 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
2408 struct tlist *next = add->next;
2411 if (!exclude_writer || add->writer != exclude_writer)
2412 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2417 /* Merge the nodes of ADD into TO. This merging process is done so that for
2418 each variable that already exists in TO, no new node is added; however if
2419 there is a write access recorded in ADD, and an occurrence on TO is only
2420 a read access, then the occurrence in TO will be modified to record the
2424 merge_tlist (struct tlist **to, struct tlist *add, int copy)
2426 struct tlist **end = to;
2429 end = &(*end)->next;
2435 struct tlist *next = add->next;
2437 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
2438 if (tmp2->expr == add->expr)
2442 tmp2->writer = add->writer;
2446 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2447 end = &(*end)->next;
2454 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2455 references in list LIST conflict with it, excluding reads if ONLY writers
2459 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2464 /* Avoid duplicate warnings. */
2465 for (tmp = warned_ids; tmp; tmp = tmp->next)
2466 if (tmp->expr == written)
2471 if (list->expr == written
2472 && list->writer != writer
2473 && (!only_writes || list->writer)
2474 && DECL_NAME (list->expr))
2476 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
2477 warning_at (EXPR_HAS_LOCATION (writer)
2478 ? EXPR_LOCATION (writer) : input_location,
2479 OPT_Wsequence_point, "operation on %qE may be undefined",
2486 /* Given a list LIST of references to variables, find whether any of these
2487 can cause conflicts due to missing sequence points. */
2490 warn_for_collisions (struct tlist *list)
2494 for (tmp = list; tmp; tmp = tmp->next)
2497 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2501 /* Return nonzero if X is a tree that can be verified by the sequence point
2504 warning_candidate_p (tree x)
2506 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
2509 /* Walk the tree X, and record accesses to variables. If X is written by the
2510 parent tree, WRITER is the parent.
2511 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2512 expression or its only operand forces a sequence point, then everything up
2513 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2515 Once we return, we will have emitted warnings if any subexpression before
2516 such a sequence point could be undefined. On a higher level, however, the
2517 sequence point may not be relevant, and we'll merge the two lists.
2519 Example: (b++, a) + b;
2520 The call that processes the COMPOUND_EXPR will store the increment of B
2521 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2522 processes the PLUS_EXPR will need to merge the two lists so that
2523 eventually, all accesses end up on the same list (and we'll warn about the
2524 unordered subexpressions b++ and b.
2526 A note on merging. If we modify the former example so that our expression
2529 care must be taken not simply to add all three expressions into the final
2530 PNO_SP list. The function merge_tlist takes care of that by merging the
2531 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2532 way, so that no more than one access to B is recorded. */
2535 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2538 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2539 enum tree_code code;
2540 enum tree_code_class cl;
2542 /* X may be NULL if it is the operand of an empty statement expression
2548 code = TREE_CODE (x);
2549 cl = TREE_CODE_CLASS (code);
2551 if (warning_candidate_p (x))
2553 *pno_sp = new_tlist (*pno_sp, x, writer);
2563 case TRUTH_ANDIF_EXPR:
2564 case TRUTH_ORIF_EXPR:
2565 tmp_before = tmp_nosp = tmp_list3 = 0;
2566 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2567 warn_for_collisions (tmp_nosp);
2568 merge_tlist (pbefore_sp, tmp_before, 0);
2569 merge_tlist (pbefore_sp, tmp_nosp, 0);
2570 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2571 merge_tlist (pbefore_sp, tmp_list3, 0);
2575 tmp_before = tmp_list2 = 0;
2576 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2577 warn_for_collisions (tmp_list2);
2578 merge_tlist (pbefore_sp, tmp_before, 0);
2579 merge_tlist (pbefore_sp, tmp_list2, 1);
2581 tmp_list3 = tmp_nosp = 0;
2582 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2583 warn_for_collisions (tmp_nosp);
2584 merge_tlist (pbefore_sp, tmp_list3, 0);
2586 tmp_list3 = tmp_list2 = 0;
2587 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2588 warn_for_collisions (tmp_list2);
2589 merge_tlist (pbefore_sp, tmp_list3, 0);
2590 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2591 two first, to avoid warning for (a ? b++ : b++). */
2592 merge_tlist (&tmp_nosp, tmp_list2, 0);
2593 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2596 case PREDECREMENT_EXPR:
2597 case PREINCREMENT_EXPR:
2598 case POSTDECREMENT_EXPR:
2599 case POSTINCREMENT_EXPR:
2600 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2604 tmp_before = tmp_nosp = tmp_list3 = 0;
2605 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2606 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2607 /* Expressions inside the LHS are not ordered wrt. the sequence points
2608 in the RHS. Example:
2610 Despite the fact that the modification of "a" is in the before_sp
2611 list (tmp_before), it conflicts with the use of "a" in the LHS.
2612 We can handle this by adding the contents of tmp_list3
2613 to those of tmp_before, and redoing the collision warnings for that
2615 add_tlist (&tmp_before, tmp_list3, x, 1);
2616 warn_for_collisions (tmp_before);
2617 /* Exclude the LHS itself here; we first have to merge it into the
2618 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2619 didn't exclude the LHS, we'd get it twice, once as a read and once
2621 add_tlist (pno_sp, tmp_list3, x, 0);
2622 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2624 merge_tlist (pbefore_sp, tmp_before, 0);
2625 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2626 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2627 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2631 /* We need to warn about conflicts among arguments and conflicts between
2632 args and the function address. Side effects of the function address,
2633 however, are not ordered by the sequence point of the call. */
2635 call_expr_arg_iterator iter;
2637 tmp_before = tmp_nosp = 0;
2638 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2639 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2641 tmp_list2 = tmp_list3 = 0;
2642 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2643 merge_tlist (&tmp_list3, tmp_list2, 0);
2644 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2646 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2647 warn_for_collisions (tmp_before);
2648 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2653 /* Scan all the list, e.g. indices of multi dimensional array. */
2656 tmp_before = tmp_nosp = 0;
2657 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2658 merge_tlist (&tmp_nosp, tmp_before, 0);
2659 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2666 struct tlist_cache *t;
2667 for (t = save_expr_cache; t; t = t->next)
2673 t = XOBNEW (&tlist_obstack, struct tlist_cache);
2674 t->next = save_expr_cache;
2676 save_expr_cache = t;
2678 tmp_before = tmp_nosp = 0;
2679 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2680 warn_for_collisions (tmp_nosp);
2685 struct tlist *t = tmp_nosp;
2687 merge_tlist (&tmp_list3, t, 0);
2689 t->cache_before_sp = tmp_before;
2690 t->cache_after_sp = tmp_list3;
2692 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2693 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2698 x = TREE_OPERAND (x, 0);
2705 /* For other expressions, simply recurse on their operands.
2706 Manual tail recursion for unary expressions.
2707 Other non-expressions need not be processed. */
2708 if (cl == tcc_unary)
2710 x = TREE_OPERAND (x, 0);
2714 else if (IS_EXPR_CODE_CLASS (cl))
2717 int max = TREE_OPERAND_LENGTH (x);
2718 for (lp = 0; lp < max; lp++)
2720 tmp_before = tmp_nosp = 0;
2721 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2722 merge_tlist (&tmp_nosp, tmp_before, 0);
2723 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2730 /* Try to warn for undefined behavior in EXPR due to missing sequence
2734 verify_sequence_points (tree expr)
2736 struct tlist *before_sp = 0, *after_sp = 0;
2739 save_expr_cache = 0;
2740 if (tlist_firstobj == 0)
2742 gcc_obstack_init (&tlist_obstack);
2743 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2746 verify_tree (expr, &before_sp, &after_sp, 0);
2747 warn_for_collisions (after_sp);
2748 obstack_free (&tlist_obstack, tlist_firstobj);
2751 /* Validate the expression after `case' and apply default promotions. */
2754 check_case_value (tree value)
2756 if (value == NULL_TREE)
2759 /* ??? Can we ever get nops here for a valid case value? We
2761 STRIP_TYPE_NOPS (value);
2762 /* In C++, the following is allowed:
2765 switch (...) { case i: ... }
2767 So, we try to reduce the VALUE to a constant that way. */
2768 if (c_dialect_cxx ())
2770 value = decl_constant_value (value);
2771 STRIP_TYPE_NOPS (value);
2772 value = fold (value);
2775 if (TREE_CODE (value) == INTEGER_CST)
2776 /* Promote char or short to int. */
2777 value = perform_integral_promotions (value);
2778 else if (value != error_mark_node)
2780 error ("case label does not reduce to an integer constant");
2781 value = error_mark_node;
2784 constant_expression_warning (value);
2789 /* See if the case values LOW and HIGH are in the range of the original
2790 type (i.e. before the default conversion to int) of the switch testing
2792 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2793 the type before promoting it. CASE_LOW_P is a pointer to the lower
2794 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2795 if the case is not a case range.
2796 The caller has to make sure that we are not called with NULL for
2797 CASE_LOW_P (i.e. the default case).
2798 Returns true if the case label is in range of ORIG_TYPE (saturated or
2799 untouched) or false if the label is out of range. */
2802 check_case_bounds (tree type, tree orig_type,
2803 tree *case_low_p, tree *case_high_p)
2805 tree min_value, max_value;
2806 tree case_low = *case_low_p;
2807 tree case_high = case_high_p ? *case_high_p : case_low;
2809 /* If there was a problem with the original type, do nothing. */
2810 if (orig_type == error_mark_node)
2813 min_value = TYPE_MIN_VALUE (orig_type);
2814 max_value = TYPE_MAX_VALUE (orig_type);
2816 /* Case label is less than minimum for type. */
2817 if (tree_int_cst_compare (case_low, min_value) < 0
2818 && tree_int_cst_compare (case_high, min_value) < 0)
2820 warning (0, "case label value is less than minimum value for type");
2824 /* Case value is greater than maximum for type. */
2825 if (tree_int_cst_compare (case_low, max_value) > 0
2826 && tree_int_cst_compare (case_high, max_value) > 0)
2828 warning (0, "case label value exceeds maximum value for type");
2832 /* Saturate lower case label value to minimum. */
2833 if (tree_int_cst_compare (case_high, min_value) >= 0
2834 && tree_int_cst_compare (case_low, min_value) < 0)
2836 warning (0, "lower value in case label range"
2837 " less than minimum value for type");
2838 case_low = min_value;
2841 /* Saturate upper case label value to maximum. */
2842 if (tree_int_cst_compare (case_low, max_value) <= 0
2843 && tree_int_cst_compare (case_high, max_value) > 0)
2845 warning (0, "upper value in case label range"
2846 " exceeds maximum value for type");
2847 case_high = max_value;
2850 if (*case_low_p != case_low)
2851 *case_low_p = convert (type, case_low);
2852 if (case_high_p && *case_high_p != case_high)
2853 *case_high_p = convert (type, case_high);
2858 /* Return an integer type with BITS bits of precision,
2859 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2862 c_common_type_for_size (unsigned int bits, int unsignedp)
2864 if (bits == TYPE_PRECISION (integer_type_node))
2865 return unsignedp ? unsigned_type_node : integer_type_node;
2867 if (bits == TYPE_PRECISION (signed_char_type_node))
2868 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2870 if (bits == TYPE_PRECISION (short_integer_type_node))
2871 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2873 if (bits == TYPE_PRECISION (long_integer_type_node))
2874 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2876 if (bits == TYPE_PRECISION (long_long_integer_type_node))
2877 return (unsignedp ? long_long_unsigned_type_node
2878 : long_long_integer_type_node);
2880 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2881 return (unsignedp ? widest_unsigned_literal_type_node
2882 : widest_integer_literal_type_node);
2884 if (bits <= TYPE_PRECISION (intQI_type_node))
2885 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2887 if (bits <= TYPE_PRECISION (intHI_type_node))
2888 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2890 if (bits <= TYPE_PRECISION (intSI_type_node))
2891 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2893 if (bits <= TYPE_PRECISION (intDI_type_node))
2894 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2899 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2900 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2901 and saturating if SATP is nonzero, otherwise not saturating. */
2904 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2905 int unsignedp, int satp)
2907 enum machine_mode mode;
2909 mode = unsignedp ? UQQmode : QQmode;
2911 mode = unsignedp ? UHAmode : HAmode;
2913 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2914 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2917 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2919 sorry ("GCC cannot support operators with integer types and "
2920 "fixed-point types that have too many integral and "
2921 "fractional bits together");
2925 return c_common_type_for_mode (mode, satp);
2928 /* Used for communication between c_common_type_for_mode and
2929 c_register_builtin_type. */
2930 static GTY(()) tree registered_builtin_types;
2932 /* Return a data type that has machine mode MODE.
2933 If the mode is an integer,
2934 then UNSIGNEDP selects between signed and unsigned types.
2935 If the mode is a fixed-point mode,
2936 then UNSIGNEDP selects between saturating and nonsaturating types. */
2939 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2943 if (mode == TYPE_MODE (integer_type_node))
2944 return unsignedp ? unsigned_type_node : integer_type_node;
2946 if (mode == TYPE_MODE (signed_char_type_node))
2947 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2949 if (mode == TYPE_MODE (short_integer_type_node))
2950 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2952 if (mode == TYPE_MODE (long_integer_type_node))
2953 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2955 if (mode == TYPE_MODE (long_long_integer_type_node))
2956 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2958 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2959 return unsignedp ? widest_unsigned_literal_type_node
2960 : widest_integer_literal_type_node;
2963 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2966 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2969 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2972 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2974 #if HOST_BITS_PER_WIDE_INT >= 64
2975 if (mode == TYPE_MODE (intTI_type_node))
2976 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2979 if (mode == TYPE_MODE (float_type_node))
2980 return float_type_node;
2982 if (mode == TYPE_MODE (double_type_node))
2983 return double_type_node;
2985 if (mode == TYPE_MODE (long_double_type_node))
2986 return long_double_type_node;
2988 if (mode == TYPE_MODE (void_type_node))
2989 return void_type_node;
2991 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2993 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2994 : make_signed_type (GET_MODE_PRECISION (mode)));
2996 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2998 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2999 : make_signed_type (GET_MODE_PRECISION (mode)));
3001 if (COMPLEX_MODE_P (mode))
3003 enum machine_mode inner_mode;
3006 if (mode == TYPE_MODE (complex_float_type_node))
3007 return complex_float_type_node;
3008 if (mode == TYPE_MODE (complex_double_type_node))
3009 return complex_double_type_node;
3010 if (mode == TYPE_MODE (complex_long_double_type_node))
3011 return complex_long_double_type_node;
3013 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
3014 return complex_integer_type_node;
3016 inner_mode = GET_MODE_INNER (mode);
3017 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
3018 if (inner_type != NULL_TREE)
3019 return build_complex_type (inner_type);
3021 else if (VECTOR_MODE_P (mode))
3023 enum machine_mode inner_mode = GET_MODE_INNER (mode);
3024 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
3025 if (inner_type != NULL_TREE)
3026 return build_vector_type_for_mode (inner_type, mode);
3029 if (mode == TYPE_MODE (dfloat32_type_node))
3030 return dfloat32_type_node;
3031 if (mode == TYPE_MODE (dfloat64_type_node))
3032 return dfloat64_type_node;
3033 if (mode == TYPE_MODE (dfloat128_type_node))
3034 return dfloat128_type_node;
3036 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
3038 if (mode == TYPE_MODE (short_fract_type_node))
3039 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
3040 if (mode == TYPE_MODE (fract_type_node))
3041 return unsignedp ? sat_fract_type_node : fract_type_node;
3042 if (mode == TYPE_MODE (long_fract_type_node))
3043 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
3044 if (mode == TYPE_MODE (long_long_fract_type_node))
3045 return unsignedp ? sat_long_long_fract_type_node
3046 : long_long_fract_type_node;
3048 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
3049 return unsignedp ? sat_unsigned_short_fract_type_node
3050 : unsigned_short_fract_type_node;
3051 if (mode == TYPE_MODE (unsigned_fract_type_node))
3052 return unsignedp ? sat_unsigned_fract_type_node
3053 : unsigned_fract_type_node;
3054 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
3055 return unsignedp ? sat_unsigned_long_fract_type_node
3056 : unsigned_long_fract_type_node;
3057 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
3058 return unsignedp ? sat_unsigned_long_long_fract_type_node
3059 : unsigned_long_long_fract_type_node;
3061 if (mode == TYPE_MODE (short_accum_type_node))
3062 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
3063 if (mode == TYPE_MODE (accum_type_node))
3064 return unsignedp ? sat_accum_type_node : accum_type_node;
3065 if (mode == TYPE_MODE (long_accum_type_node))
3066 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
3067 if (mode == TYPE_MODE (long_long_accum_type_node))
3068 return unsignedp ? sat_long_long_accum_type_node
3069 : long_long_accum_type_node;
3071 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
3072 return unsignedp ? sat_unsigned_short_accum_type_node
3073 : unsigned_short_accum_type_node;
3074 if (mode == TYPE_MODE (unsigned_accum_type_node))
3075 return unsignedp ? sat_unsigned_accum_type_node
3076 : unsigned_accum_type_node;
3077 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
3078 return unsignedp ? sat_unsigned_long_accum_type_node
3079 : unsigned_long_accum_type_node;
3080 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
3081 return unsignedp ? sat_unsigned_long_long_accum_type_node
3082 : unsigned_long_long_accum_type_node;
3085 return unsignedp ? sat_qq_type_node : qq_type_node;
3087 return unsignedp ? sat_hq_type_node : hq_type_node;
3089 return unsignedp ? sat_sq_type_node : sq_type_node;
3091 return unsignedp ? sat_dq_type_node : dq_type_node;
3093 return unsignedp ? sat_tq_type_node : tq_type_node;
3095 if (mode == UQQmode)
3096 return unsignedp ? sat_uqq_type_node : uqq_type_node;
3097 if (mode == UHQmode)
3098 return unsignedp ? sat_uhq_type_node : uhq_type_node;
3099 if (mode == USQmode)
3100 return unsignedp ? sat_usq_type_node : usq_type_node;
3101 if (mode == UDQmode)
3102 return unsignedp ? sat_udq_type_node : udq_type_node;
3103 if (mode == UTQmode)
3104 return unsignedp ? sat_utq_type_node : utq_type_node;
3107 return unsignedp ? sat_ha_type_node : ha_type_node;
3109 return unsignedp ? sat_sa_type_node : sa_type_node;
3111 return unsignedp ? sat_da_type_node : da_type_node;
3113 return unsignedp ? sat_ta_type_node : ta_type_node;
3115 if (mode == UHAmode)
3116 return unsignedp ? sat_uha_type_node : uha_type_node;
3117 if (mode == USAmode)
3118 return unsignedp ? sat_usa_type_node : usa_type_node;
3119 if (mode == UDAmode)
3120 return unsignedp ? sat_uda_type_node : uda_type_node;
3121 if (mode == UTAmode)
3122 return unsignedp ? sat_uta_type_node : uta_type_node;
3125 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
3126 if (TYPE_MODE (TREE_VALUE (t)) == mode)
3127 return TREE_VALUE (t);
3133 c_common_unsigned_type (tree type)
3135 return c_common_signed_or_unsigned_type (1, type);
3138 /* Return a signed type the same as TYPE in other respects. */
3141 c_common_signed_type (tree type)
3143 return c_common_signed_or_unsigned_type (0, type);
3146 /* Return a type the same as TYPE except unsigned or
3147 signed according to UNSIGNEDP. */
3150 c_common_signed_or_unsigned_type (int unsignedp, tree type)
3154 /* This block of code emulates the behavior of the old
3155 c_common_unsigned_type. In particular, it returns
3156 long_unsigned_type_node if passed a long, even when a int would
3157 have the same size. This is necessary for warnings to work
3158 correctly in archs where sizeof(int) == sizeof(long) */
3160 type1 = TYPE_MAIN_VARIANT (type);
3161 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3162 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3163 if (type1 == integer_type_node || type1 == unsigned_type_node)
3164 return unsignedp ? unsigned_type_node : integer_type_node;
3165 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3166 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3167 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3168 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3169 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3170 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3171 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3172 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3173 #if HOST_BITS_PER_WIDE_INT >= 64
3174 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3175 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3177 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3178 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3179 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3180 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3181 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3182 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3183 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3184 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3186 #define C_COMMON_FIXED_TYPES(NAME) \
3187 if (type1 == short_ ## NAME ## _type_node \
3188 || type1 == unsigned_short_ ## NAME ## _type_node) \
3189 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3190 : short_ ## NAME ## _type_node; \
3191 if (type1 == NAME ## _type_node \
3192 || type1 == unsigned_ ## NAME ## _type_node) \
3193 return unsignedp ? unsigned_ ## NAME ## _type_node \
3194 : NAME ## _type_node; \
3195 if (type1 == long_ ## NAME ## _type_node \
3196 || type1 == unsigned_long_ ## NAME ## _type_node) \
3197 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3198 : long_ ## NAME ## _type_node; \
3199 if (type1 == long_long_ ## NAME ## _type_node \
3200 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3201 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3202 : long_long_ ## NAME ## _type_node;
3204 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3205 if (type1 == NAME ## _type_node \
3206 || type1 == u ## NAME ## _type_node) \
3207 return unsignedp ? u ## NAME ## _type_node \
3208 : NAME ## _type_node;
3210 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3211 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3212 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3213 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3214 : sat_ ## short_ ## NAME ## _type_node; \
3215 if (type1 == sat_ ## NAME ## _type_node \
3216 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3217 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3218 : sat_ ## NAME ## _type_node; \
3219 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3220 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3221 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3222 : sat_ ## long_ ## NAME ## _type_node; \
3223 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3224 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3225 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3226 : sat_ ## long_long_ ## NAME ## _type_node;
3228 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3229 if (type1 == sat_ ## NAME ## _type_node \
3230 || type1 == sat_ ## u ## NAME ## _type_node) \
3231 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3232 : sat_ ## NAME ## _type_node;
3234 C_COMMON_FIXED_TYPES (fract);
3235 C_COMMON_FIXED_TYPES_SAT (fract);
3236 C_COMMON_FIXED_TYPES (accum);
3237 C_COMMON_FIXED_TYPES_SAT (accum);
3239 C_COMMON_FIXED_MODE_TYPES (qq);
3240 C_COMMON_FIXED_MODE_TYPES (hq);
3241 C_COMMON_FIXED_MODE_TYPES (sq);
3242 C_COMMON_FIXED_MODE_TYPES (dq);
3243 C_COMMON_FIXED_MODE_TYPES (tq);
3244 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3245 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3246 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3247 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3248 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3249 C_COMMON_FIXED_MODE_TYPES (ha);
3250 C_COMMON_FIXED_MODE_TYPES (sa);
3251 C_COMMON_FIXED_MODE_TYPES (da);
3252 C_COMMON_FIXED_MODE_TYPES (ta);
3253 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3254 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3255 C_COMMON_FIXED_MODE_TYPES_SAT (da);
3256 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3258 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3259 the precision; they have precision set to match their range, but
3260 may use a wider mode to match an ABI. If we change modes, we may
3261 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3262 the precision as well, so as to yield correct results for
3263 bit-field types. C++ does not have these separate bit-field
3264 types, and producing a signed or unsigned variant of an
3265 ENUMERAL_TYPE may cause other problems as well. */
3267 if (!INTEGRAL_TYPE_P (type)
3268 || TYPE_UNSIGNED (type) == unsignedp)
3271 #define TYPE_OK(node) \
3272 (TYPE_MODE (type) == TYPE_MODE (node) \
3273 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3274 if (TYPE_OK (signed_char_type_node))
3275 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3276 if (TYPE_OK (integer_type_node))
3277 return unsignedp ? unsigned_type_node : integer_type_node;
3278 if (TYPE_OK (short_integer_type_node))
3279 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3280 if (TYPE_OK (long_integer_type_node))
3281 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3282 if (TYPE_OK (long_long_integer_type_node))
3283 return (unsignedp ? long_long_unsigned_type_node
3284 : long_long_integer_type_node);
3285 if (TYPE_OK (widest_integer_literal_type_node))
3286 return (unsignedp ? widest_unsigned_literal_type_node
3287 : widest_integer_literal_type_node);
3289 #if HOST_BITS_PER_WIDE_INT >= 64
3290 if (TYPE_OK (intTI_type_node))
3291 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3293 if (TYPE_OK (intDI_type_node))
3294 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3295 if (TYPE_OK (intSI_type_node))
3296 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3297 if (TYPE_OK (intHI_type_node))
3298 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3299 if (TYPE_OK (intQI_type_node))
3300 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3303 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3306 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3309 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3311 /* Extended integer types of the same width as a standard type have
3312 lesser rank, so those of the same width as int promote to int or
3313 unsigned int and are valid for printf formats expecting int or
3314 unsigned int. To avoid such special cases, avoid creating
3315 extended integer types for bit-fields if a standard integer type
3317 if (width == TYPE_PRECISION (integer_type_node))
3318 return unsignedp ? unsigned_type_node : integer_type_node;
3319 if (width == TYPE_PRECISION (signed_char_type_node))
3320 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3321 if (width == TYPE_PRECISION (short_integer_type_node))
3322 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3323 if (width == TYPE_PRECISION (long_integer_type_node))
3324 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3325 if (width == TYPE_PRECISION (long_long_integer_type_node))
3326 return (unsignedp ? long_long_unsigned_type_node
3327 : long_long_integer_type_node);
3328 return build_nonstandard_integer_type (width, unsignedp);
3331 /* The C version of the register_builtin_type langhook. */
3334 c_register_builtin_type (tree type, const char* name)
3338 decl = build_decl (TYPE_DECL, get_identifier (name), type);
3339 DECL_ARTIFICIAL (decl) = 1;
3340 if (!TYPE_NAME (type))
3341 TYPE_NAME (type) = decl;
3344 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3347 /* Print an error message for invalid operands to arith operation
3348 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3349 LOCATION is the location of the message. */
3352 binary_op_error (location_t location, enum tree_code code,
3353 tree type0, tree type1)
3360 opname = "+"; break;
3362 opname = "-"; break;
3364 opname = "*"; break;
3366 opname = "max"; break;
3368 opname = "min"; break;
3370 opname = "=="; break;
3372 opname = "!="; break;
3374 opname = "<="; break;
3376 opname = ">="; break;
3378 opname = "<"; break;
3380 opname = ">"; break;
3382 opname = "<<"; break;
3384 opname = ">>"; break;
3385 case TRUNC_MOD_EXPR:
3386 case FLOOR_MOD_EXPR:
3387 opname = "%"; break;
3388 case TRUNC_DIV_EXPR:
3389 case FLOOR_DIV_EXPR:
3390 opname = "/"; break;
3392 opname = "&"; break;
3394 opname = "|"; break;
3395 case TRUTH_ANDIF_EXPR:
3396 opname = "&&"; break;
3397 case TRUTH_ORIF_EXPR:
3398 opname = "||"; break;
3400 opname = "^"; break;
3405 "invalid operands to binary %s (have %qT and %qT)", opname,
3409 /* Subroutine of build_binary_op, used for comparison operations.
3410 See if the operands have both been converted from subword integer types
3411 and, if so, perhaps change them both back to their original type.
3412 This function is also responsible for converting the two operands
3413 to the proper common type for comparison.
3415 The arguments of this function are all pointers to local variables
3416 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3417 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3419 If this function returns nonzero, it means that the comparison has
3420 a constant value. What this function returns is an expression for
3424 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3425 enum tree_code *rescode_ptr)
3428 tree op0 = *op0_ptr;
3429 tree op1 = *op1_ptr;
3430 int unsignedp0, unsignedp1;
3432 tree primop0, primop1;
3433 enum tree_code code = *rescode_ptr;
3435 /* Throw away any conversions to wider types
3436 already present in the operands. */
3438 primop0 = get_narrower (op0, &unsignedp0);
3439 primop1 = get_narrower (op1, &unsignedp1);
3441 /* Handle the case that OP0 does not *contain* a conversion
3442 but it *requires* conversion to FINAL_TYPE. */
3444 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3445 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3446 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3447 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3449 /* If one of the operands must be floated, we cannot optimize. */
3450 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3451 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3453 /* If first arg is constant, swap the args (changing operation
3454 so value is preserved), for canonicalization. Don't do this if
3455 the second arg is 0. */
3457 if (TREE_CONSTANT (primop0)
3458 && !integer_zerop (primop1) && !real_zerop (primop1)
3459 && !fixed_zerop (primop1))
3462 int temi = unsignedp0;
3470 unsignedp0 = unsignedp1;
3493 *rescode_ptr = code;
3496 /* If comparing an integer against a constant more bits wide,
3497 maybe we can deduce a value of 1 or 0 independent of the data.
3498 Or else truncate the constant now
3499 rather than extend the variable at run time.
3501 This is only interesting if the constant is the wider arg.
3502 Also, it is not safe if the constant is unsigned and the
3503 variable arg is signed, since in this case the variable
3504 would be sign-extended and then regarded as unsigned.
3505 Our technique fails in this case because the lowest/highest
3506 possible unsigned results don't follow naturally from the
3507 lowest/highest possible values of the variable operand.
3508 For just EQ_EXPR and NE_EXPR there is another technique that
3509 could be used: see if the constant can be faithfully represented
3510 in the other operand's type, by truncating it and reextending it
3511 and see if that preserves the constant's value. */
3513 if (!real1 && !real2
3514 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
3515 && TREE_CODE (primop1) == INTEGER_CST
3516 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3518 int min_gt, max_gt, min_lt, max_lt;
3519 tree maxval, minval;
3520 /* 1 if comparison is nominally unsigned. */
3521 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
3524 type = c_common_signed_or_unsigned_type (unsignedp0,
3525 TREE_TYPE (primop0));
3527 maxval = TYPE_MAX_VALUE (type);
3528 minval = TYPE_MIN_VALUE (type);
3530 if (unsignedp && !unsignedp0)
3531 *restype_ptr = c_common_signed_type (*restype_ptr);
3533 if (TREE_TYPE (primop1) != *restype_ptr)
3535 /* Convert primop1 to target type, but do not introduce
3536 additional overflow. We know primop1 is an int_cst. */
3537 primop1 = force_fit_type_double (*restype_ptr,
3538 TREE_INT_CST_LOW (primop1),
3539 TREE_INT_CST_HIGH (primop1), 0,
3540 TREE_OVERFLOW (primop1));
3542 if (type != *restype_ptr)
3544 minval = convert (*restype_ptr, minval);
3545 maxval = convert (*restype_ptr, maxval);
3548 if (unsignedp && unsignedp0)
3550 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3551 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3552 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3553 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3557 min_gt = INT_CST_LT (primop1, minval);
3558 max_gt = INT_CST_LT (primop1, maxval);
3559 min_lt = INT_CST_LT (minval, primop1);
3560 max_lt = INT_CST_LT (maxval, primop1);
3564 /* This used to be a switch, but Genix compiler can't handle that. */
3565 if (code == NE_EXPR)
3567 if (max_lt || min_gt)
3568 val = truthvalue_true_node;
3570 else if (code == EQ_EXPR)
3572 if (max_lt || min_gt)
3573 val = truthvalue_false_node;
3575 else if (code == LT_EXPR)
3578 val = truthvalue_true_node;
3580 val = truthvalue_false_node;
3582 else if (code == GT_EXPR)
3585 val = truthvalue_true_node;
3587 val = truthvalue_false_node;
3589 else if (code == LE_EXPR)
3592 val = truthvalue_true_node;
3594 val = truthvalue_false_node;
3596 else if (code == GE_EXPR)
3599 val = truthvalue_true_node;
3601 val = truthvalue_false_node;
3604 /* If primop0 was sign-extended and unsigned comparison specd,
3605 we did a signed comparison above using the signed type bounds.
3606 But the comparison we output must be unsigned.
3608 Also, for inequalities, VAL is no good; but if the signed
3609 comparison had *any* fixed result, it follows that the
3610 unsigned comparison just tests the sign in reverse
3611 (positive values are LE, negative ones GE).
3612 So we can generate an unsigned comparison
3613 against an extreme value of the signed type. */
3615 if (unsignedp && !unsignedp0)
3622 primop1 = TYPE_MIN_VALUE (type);
3628 primop1 = TYPE_MAX_VALUE (type);
3635 type = c_common_unsigned_type (type);
3638 if (TREE_CODE (primop0) != INTEGER_CST)
3640 if (val == truthvalue_false_node)
3641 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3642 if (val == truthvalue_true_node)
3643 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3648 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3649 if (TREE_SIDE_EFFECTS (primop0))
3650 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3654 /* Value is not predetermined, but do the comparison
3655 in the type of the operand that is not constant.
3656 TYPE is already properly set. */
3659 /* If either arg is decimal float and the other is float, find the
3660 proper common type to use for comparison. */
3661 else if (real1 && real2
3662 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3663 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3664 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3666 else if (real1 && real2
3667 && (TYPE_PRECISION (TREE_TYPE (primop0))
3668 == TYPE_PRECISION (TREE_TYPE (primop1))))
3669 type = TREE_TYPE (primop0);
3671 /* If args' natural types are both narrower than nominal type
3672 and both extend in the same manner, compare them
3673 in the type of the wider arg.
3674 Otherwise must actually extend both to the nominal
3675 common type lest different ways of extending
3677 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3679 else if (unsignedp0 == unsignedp1 && real1 == real2
3680 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3681 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3683 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3684 type = c_common_signed_or_unsigned_type (unsignedp0
3685 || TYPE_UNSIGNED (*restype_ptr),
3687 /* Make sure shorter operand is extended the right way
3688 to match the longer operand. */
3690 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3691 TREE_TYPE (primop0)),
3694 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3695 TREE_TYPE (primop1)),
3700 /* Here we must do the comparison on the nominal type
3701 using the args exactly as we received them. */
3702 type = *restype_ptr;
3706 if (!real1 && !real2 && integer_zerop (primop1)
3707 && TYPE_UNSIGNED (*restype_ptr))
3713 /* All unsigned values are >= 0, so we warn. However,
3714 if OP0 is a constant that is >= 0, the signedness of
3715 the comparison isn't an issue, so suppress the
3717 if (warn_type_limits && !in_system_header
3718 && !(TREE_CODE (primop0) == INTEGER_CST
3719 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3721 warning (OPT_Wtype_limits,
3722 "comparison of unsigned expression >= 0 is always true");
3723 value = truthvalue_true_node;
3727 if (warn_type_limits && !in_system_header
3728 && !(TREE_CODE (primop0) == INTEGER_CST
3729 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3731 warning (OPT_Wtype_limits,
3732 "comparison of unsigned expression < 0 is always false");
3733 value = truthvalue_false_node;
3742 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3743 if (TREE_SIDE_EFFECTS (primop0))
3744 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3751 *op0_ptr = convert (type, primop0);
3752 *op1_ptr = convert (type, primop1);
3754 *restype_ptr = truthvalue_type_node;
3759 /* Return a tree for the sum or difference (RESULTCODE says which)
3760 of pointer PTROP and integer INTOP. */
3763 pointer_int_sum (location_t location, enum tree_code resultcode,
3764 tree ptrop, tree intop)
3768 /* The result is a pointer of the same type that is being added. */
3769 tree result_type = TREE_TYPE (ptrop);
3771 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3773 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3774 "pointer of type %<void *%> used in arithmetic");
3775 size_exp = integer_one_node;
3777 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3779 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3780 "pointer to a function used in arithmetic");
3781 size_exp = integer_one_node;
3783 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3785 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3786 "pointer to member function used in arithmetic");
3787 size_exp = integer_one_node;
3790 size_exp = size_in_bytes (TREE_TYPE (result_type));
3792 /* We are manipulating pointer values, so we don't need to warn
3793 about relying on undefined signed overflow. We disable the
3794 warning here because we use integer types so fold won't know that
3795 they are really pointers. */
3796 fold_defer_overflow_warnings ();
3798 /* If what we are about to multiply by the size of the elements
3799 contains a constant term, apply distributive law
3800 and multiply that constant term separately.
3801 This helps produce common subexpressions. */
3802 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3803 && !TREE_CONSTANT (intop)
3804 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3805 && TREE_CONSTANT (size_exp)
3806 /* If the constant comes from pointer subtraction,
3807 skip this optimization--it would cause an error. */
3808 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3809 /* If the constant is unsigned, and smaller than the pointer size,
3810 then we must skip this optimization. This is because it could cause
3811 an overflow error if the constant is negative but INTOP is not. */
3812 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3813 || (TYPE_PRECISION (TREE_TYPE (intop))
3814 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3816 enum tree_code subcode = resultcode;
3817 tree int_type = TREE_TYPE (intop);
3818 if (TREE_CODE (intop) == MINUS_EXPR)
3819 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3820 /* Convert both subexpression types to the type of intop,
3821 because weird cases involving pointer arithmetic
3822 can result in a sum or difference with different type args. */
3823 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3825 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3826 intop = convert (int_type, TREE_OPERAND (intop, 0));
3829 /* Convert the integer argument to a type the same size as sizetype
3830 so the multiply won't overflow spuriously. */
3831 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3832 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3833 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3834 TYPE_UNSIGNED (sizetype)), intop);
3836 /* Replace the integer argument with a suitable product by the object size.
3837 Do this multiplication as signed, then convert to the appropriate
3838 type for the pointer operation. */
3839 intop = convert (sizetype,
3840 build_binary_op (EXPR_LOCATION (intop),
3842 convert (TREE_TYPE (intop), size_exp), 1));
3844 /* Create the sum or difference. */
3845 if (resultcode == MINUS_EXPR)
3846 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3848 if (TREE_CODE (intop) == INTEGER_CST)
3851 tree string_cst = string_constant (ptrop, &offset_node);
3854 && !(offset_node && TREE_CODE (offset_node) != INTEGER_CST))
3856 HOST_WIDE_INT max = TREE_STRING_LENGTH (string_cst);
3857 HOST_WIDE_INT offset;
3858 if (offset_node == 0)
3860 else if (! host_integerp (offset_node, 0))
3863 offset = tree_low_cst (offset_node, 0);
3865 offset = offset + tree_low_cst (intop, 0);
3866 if (offset < 0 || offset > max)
3867 warning_at (location, 0,
3868 "offset %<%wd%> outside bounds of constant string",
3869 tree_low_cst (intop, 0));
3873 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3875 fold_undefer_and_ignore_overflow_warnings ();
3880 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3881 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3882 around the SAVE_EXPR if needed so that c_fully_fold does not need
3883 to look inside SAVE_EXPRs. */
3886 c_save_expr (tree expr)
3888 bool maybe_const = true;
3889 if (c_dialect_cxx ())
3890 return save_expr (expr);
3891 expr = c_fully_fold (expr, false, &maybe_const);
3892 expr = save_expr (expr);
3895 expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3896 C_MAYBE_CONST_EXPR_NON_CONST (expr) = 1;
3901 /* Return whether EXPR is a declaration whose address can never be
3905 decl_with_nonnull_addr_p (const_tree expr)
3907 return (DECL_P (expr)
3908 && (TREE_CODE (expr) == PARM_DECL
3909 || TREE_CODE (expr) == LABEL_DECL
3910 || !DECL_WEAK (expr)));
3913 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3914 or for an `if' or `while' statement or ?..: exp. It should already
3915 have been validated to be of suitable type; otherwise, a bad
3916 diagnostic may result.
3918 The EXPR is located at LOCATION.
3920 This preparation consists of taking the ordinary
3921 representation of an expression expr and producing a valid tree
3922 boolean expression describing whether expr is nonzero. We could
3923 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3924 but we optimize comparisons, &&, ||, and !.
3926 The resulting type should always be `truthvalue_type_node'. */
3929 c_common_truthvalue_conversion (location_t location, tree expr)
3931 switch (TREE_CODE (expr))
3933 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
3934 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3935 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3936 case ORDERED_EXPR: case UNORDERED_EXPR:
3937 if (TREE_TYPE (expr) == truthvalue_type_node)
3939 return build2 (TREE_CODE (expr), truthvalue_type_node,
3940 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3942 case TRUTH_ANDIF_EXPR:
3943 case TRUTH_ORIF_EXPR:
3944 case TRUTH_AND_EXPR:
3946 case TRUTH_XOR_EXPR:
3947 if (TREE_TYPE (expr) == truthvalue_type_node)
3949 return build2 (TREE_CODE (expr), truthvalue_type_node,
3950 c_common_truthvalue_conversion (location,
3951 TREE_OPERAND (expr, 0)),
3952 c_common_truthvalue_conversion (location,
3953 TREE_OPERAND (expr, 1)));
3955 case TRUTH_NOT_EXPR:
3956 if (TREE_TYPE (expr) == truthvalue_type_node)
3958 return build1 (TREE_CODE (expr), truthvalue_type_node,
3959 c_common_truthvalue_conversion (location,
3960 TREE_OPERAND (expr, 0)));
3966 return integer_zerop (expr) ? truthvalue_false_node
3967 : truthvalue_true_node;
3970 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3971 ? truthvalue_true_node
3972 : truthvalue_false_node;
3975 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3976 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3977 ? truthvalue_true_node
3978 : truthvalue_false_node;
3981 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3986 tree inner = TREE_OPERAND (expr, 0);
3987 if (decl_with_nonnull_addr_p (inner))
3989 /* Common Ada/Pascal programmer's mistake. */
3990 warning_at (location,
3992 "the address of %qD will always evaluate as %<true%>",
3994 return truthvalue_true_node;
3997 /* If we still have a decl, it is possible for its address to
3998 be NULL, so we cannot optimize. */
4001 gcc_assert (DECL_WEAK (inner));
4005 if (TREE_SIDE_EFFECTS (inner))
4006 return build2 (COMPOUND_EXPR, truthvalue_type_node,
4007 inner, truthvalue_true_node);
4009 return truthvalue_true_node;
4013 return build_binary_op (EXPR_LOCATION (expr),
4014 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
4015 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4016 c_common_truthvalue_conversion (location,
4017 TREE_OPERAND (expr, 0)),
4018 c_common_truthvalue_conversion (location,
4019 TREE_OPERAND (expr, 1)),
4025 case EXCESS_PRECISION_EXPR:
4026 /* These don't change whether an object is nonzero or zero. */
4027 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
4031 /* These don't change whether an object is zero or nonzero, but
4032 we can't ignore them if their second arg has side-effects. */
4033 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
4034 return build2 (COMPOUND_EXPR, truthvalue_type_node,
4035 TREE_OPERAND (expr, 1),
4036 c_common_truthvalue_conversion
4037 (location, TREE_OPERAND (expr, 0)));
4039 return c_common_truthvalue_conversion (location,
4040 TREE_OPERAND (expr, 0));
4043 /* Distribute the conversion into the arms of a COND_EXPR. */
4044 if (c_dialect_cxx ())
4045 return fold_build3 (COND_EXPR, truthvalue_type_node,
4046 TREE_OPERAND (expr, 0),
4047 c_common_truthvalue_conversion (location,
4050 c_common_truthvalue_conversion (location,
4054 /* Folding will happen later for C. */
4055 return build3 (COND_EXPR, truthvalue_type_node,
4056 TREE_OPERAND (expr, 0),
4057 c_common_truthvalue_conversion (location,
4058 TREE_OPERAND (expr, 1)),
4059 c_common_truthvalue_conversion (location,
4060 TREE_OPERAND (expr, 2)));
4063 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4064 since that affects how `default_conversion' will behave. */
4065 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
4066 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
4068 /* If this is widening the argument, we can ignore it. */
4069 if (TYPE_PRECISION (TREE_TYPE (expr))
4070 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
4071 return c_common_truthvalue_conversion (location,
4072 TREE_OPERAND (expr, 0));
4076 if (!TREE_NO_WARNING (expr)
4077 && warn_parentheses)
4079 warning (OPT_Wparentheses,
4080 "suggest parentheses around assignment used as truth value");
4081 TREE_NO_WARNING (expr) = 1;
4089 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
4091 tree t = c_save_expr (expr);
4092 return (build_binary_op
4093 (EXPR_LOCATION (expr),
4094 (TREE_SIDE_EFFECTS (expr)
4095 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4096 c_common_truthvalue_conversion
4098 build_unary_op (location, REALPART_EXPR, t, 0)),
4099 c_common_truthvalue_conversion
4101 build_unary_op (location, IMAGPART_EXPR, t, 0)),
4105 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
4107 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
4109 (TREE_TYPE (expr))));
4110 return build_binary_op (EXPR_LOCATION (expr),
4111 NE_EXPR, expr, fixed_zero_node, 1);
4114 return build_binary_op (EXPR_LOCATION (expr),
4115 NE_EXPR, expr, integer_zero_node, 1);
4118 static void def_builtin_1 (enum built_in_function fncode,
4120 enum built_in_class fnclass,
4121 tree fntype, tree libtype,
4122 bool both_p, bool fallback_p, bool nonansi_p,
4123 tree fnattrs, bool implicit_p);
4126 /* Apply the TYPE_QUALS to the new DECL. */
4129 c_apply_type_quals_to_decl (int type_quals, tree decl)
4131 tree type = TREE_TYPE (decl);
4133 if (type == error_mark_node)
4136 if (((type_quals & TYPE_QUAL_CONST)
4137 || (type && TREE_CODE (type) == REFERENCE_TYPE))
4138 /* An object declared 'const' is only readonly after it is
4139 initialized. We don't have any way of expressing this currently,
4140 so we need to be conservative and unset TREE_READONLY for types
4141 with constructors. Otherwise aliasing code will ignore stores in
4142 an inline constructor. */
4143 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
4144 TREE_READONLY (decl) = 1;
4145 if (type_quals & TYPE_QUAL_VOLATILE)
4147 TREE_SIDE_EFFECTS (decl) = 1;
4148 TREE_THIS_VOLATILE (decl) = 1;
4150 if (type_quals & TYPE_QUAL_RESTRICT)
4152 while (type && TREE_CODE (type) == ARRAY_TYPE)
4153 /* Allow 'restrict' on arrays of pointers.
4154 FIXME currently we just ignore it. */
4155 type = TREE_TYPE (type);
4157 || !POINTER_TYPE_P (type)
4158 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
4159 error ("invalid use of %<restrict%>");
4160 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
4161 /* Indicate we need to make a unique alias set for this pointer.
4162 We can't do it here because it might be pointing to an
4164 DECL_POINTER_ALIAS_SET (decl) = -2;
4168 /* Hash function for the problem of multiple type definitions in
4169 different files. This must hash all types that will compare
4170 equal via comptypes to the same value. In practice it hashes
4171 on some of the simple stuff and leaves the details to comptypes. */
4174 c_type_hash (const void *p)
4178 const_tree const t = (const_tree) p;
4180 switch (TREE_CODE (t))
4182 /* For pointers, hash on pointee type plus some swizzling. */
4184 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4185 /* Hash on number of elements and total size. */
4188 t2 = TYPE_VALUES (t);
4192 t2 = TYPE_FIELDS (t);
4194 case QUAL_UNION_TYPE:
4196 t2 = TYPE_FIELDS (t);
4200 t2 = TYPE_FIELDS (t);
4205 for (; t2; t2 = TREE_CHAIN (t2))
4207 /* We might have a VLA here. */
4208 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4211 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
4212 return ((size << 24) | (i << shift));
4215 static GTY((param_is (union tree_node))) htab_t type_hash_table;
4217 /* Return the typed-based alias set for T, which may be an expression
4218 or a type. Return -1 if we don't do anything special. */
4221 c_common_get_alias_set (tree t)
4226 /* Permit type-punning when accessing a union, provided the access
4227 is directly through the union. For example, this code does not
4228 permit taking the address of a union member and then storing
4229 through it. Even the type-punning allowed here is a GCC
4230 extension, albeit a common and useful one; the C standard says
4231 that such accesses have implementation-defined behavior. */
4233 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4234 u = TREE_OPERAND (u, 0))
4235 if (TREE_CODE (u) == COMPONENT_REF
4236 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4239 /* That's all the expressions we handle specially. */
4243 /* The C standard guarantees that any object may be accessed via an
4244 lvalue that has character type. */
4245 if (t == char_type_node
4246 || t == signed_char_type_node
4247 || t == unsigned_char_type_node)
4250 /* The C standard specifically allows aliasing between signed and
4251 unsigned variants of the same type. We treat the signed
4252 variant as canonical. */
4253 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4255 tree t1 = c_common_signed_type (t);
4257 /* t1 == t can happen for boolean nodes which are always unsigned. */
4259 return get_alias_set (t1);
4261 else if (POINTER_TYPE_P (t))
4265 /* Unfortunately, there is no canonical form of a pointer type.
4266 In particular, if we have `typedef int I', then `int *', and
4267 `I *' are different types. So, we have to pick a canonical
4268 representative. We do this below.
4270 Technically, this approach is actually more conservative that
4271 it needs to be. In particular, `const int *' and `int *'
4272 should be in different alias sets, according to the C and C++
4273 standard, since their types are not the same, and so,
4274 technically, an `int **' and `const int **' cannot point at
4277 But, the standard is wrong. In particular, this code is
4282 const int* const* cipp = ipp;
4284 And, it doesn't make sense for that to be legal unless you
4285 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4286 the pointed-to types. This issue has been reported to the
4288 t1 = build_type_no_quals (t);
4290 return get_alias_set (t1);
4293 /* Handle the case of multiple type nodes referring to "the same" type,
4294 which occurs with IMA. These share an alias set. FIXME: Currently only
4295 C90 is handled. (In C99 type compatibility is not transitive, which
4296 complicates things mightily. The alias set splay trees can theoretically
4297 represent this, but insertion is tricky when you consider all the
4298 different orders things might arrive in.) */
4300 if (c_language != clk_c || flag_isoc99)
4303 /* Save time if there's only one input file. */
4304 if (num_in_fnames == 1)
4307 /* Pointers need special handling if they point to any type that
4308 needs special handling (below). */
4309 if (TREE_CODE (t) == POINTER_TYPE)
4312 /* Find bottom type under any nested POINTERs. */
4313 for (t2 = TREE_TYPE (t);
4314 TREE_CODE (t2) == POINTER_TYPE;
4315 t2 = TREE_TYPE (t2))
4317 if (TREE_CODE (t2) != RECORD_TYPE
4318 && TREE_CODE (t2) != ENUMERAL_TYPE
4319 && TREE_CODE (t2) != QUAL_UNION_TYPE
4320 && TREE_CODE (t2) != UNION_TYPE)
4322 if (TYPE_SIZE (t2) == 0)
4325 /* These are the only cases that need special handling. */
4326 if (TREE_CODE (t) != RECORD_TYPE
4327 && TREE_CODE (t) != ENUMERAL_TYPE
4328 && TREE_CODE (t) != QUAL_UNION_TYPE
4329 && TREE_CODE (t) != UNION_TYPE
4330 && TREE_CODE (t) != POINTER_TYPE)
4333 if (TYPE_SIZE (t) == 0)
4336 /* Look up t in hash table. Only one of the compatible types within each
4337 alias set is recorded in the table. */
4338 if (!type_hash_table)
4339 type_hash_table = htab_create_ggc (1021, c_type_hash,
4340 (htab_eq) lang_hooks.types_compatible_p,
4342 slot = htab_find_slot (type_hash_table, t, INSERT);
4345 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4346 return TYPE_ALIAS_SET ((tree)*slot);
4349 /* Our caller will assign and record (in t) a new alias set; all we need
4350 to do is remember t in the hash table. */
4356 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
4357 second parameter indicates which OPERATOR is being applied. The COMPLAIN
4358 flag controls whether we should diagnose possibly ill-formed
4359 constructs or not. */
4362 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
4364 const char *op_name;
4366 enum tree_code type_code = TREE_CODE (type);
4368 op_name = is_sizeof ? "sizeof" : "__alignof__";
4370 if (type_code == FUNCTION_TYPE)
4374 if (complain && (pedantic || warn_pointer_arith))
4375 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4376 "invalid application of %<sizeof%> to a function type");
4378 return error_mark_node;
4379 value = size_one_node;
4382 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4384 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4386 if (type_code == VOID_TYPE
4387 && complain && (pedantic || warn_pointer_arith))
4388 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4389 "invalid application of %qs to a void type", op_name);
4391 return error_mark_node;
4392 value = size_one_node;
4394 else if (!COMPLETE_TYPE_P (type))
4397 error ("invalid application of %qs to incomplete type %qT ",
4399 value = size_zero_node;
4404 /* Convert in case a char is more than one unit. */
4405 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4406 size_int (TYPE_PRECISION (char_type_node)
4409 value = size_int (TYPE_ALIGN_UNIT (type));
4412 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4413 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4414 never happen. However, this node should really have type
4415 `size_t', which is just a typedef for an ordinary integer type. */
4416 value = fold_convert (size_type_node, value);
4417 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
4422 /* Implement the __alignof keyword: Return the minimum required
4423 alignment of EXPR, measured in bytes. For VAR_DECLs,
4424 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4425 from an "aligned" __attribute__ specification). */
4428 c_alignof_expr (tree expr)
4432 if (VAR_OR_FUNCTION_DECL_P (expr))
4433 t = size_int (DECL_ALIGN_UNIT (expr));
4435 else if (TREE_CODE (expr) == COMPONENT_REF
4436 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4438 error ("%<__alignof%> applied to a bit-field");
4441 else if (TREE_CODE (expr) == COMPONENT_REF
4442 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
4443 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
4445 else if (TREE_CODE (expr) == INDIRECT_REF)
4447 tree t = TREE_OPERAND (expr, 0);
4449 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4451 while (CONVERT_EXPR_P (t)
4452 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
4456 t = TREE_OPERAND (t, 0);
4457 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4458 if (thisalign > bestalign)
4459 best = t, bestalign = thisalign;
4461 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
4464 return c_alignof (TREE_TYPE (expr));
4466 return fold_convert (size_type_node, t);
4469 /* Handle C and C++ default attributes. */
4471 enum built_in_attribute
4473 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4474 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4475 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4476 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4477 #include "builtin-attrs.def"
4478 #undef DEF_ATTR_NULL_TREE
4480 #undef DEF_ATTR_IDENT
4481 #undef DEF_ATTR_TREE_LIST
4485 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4487 static void c_init_attributes (void);
4491 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4492 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4493 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4494 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4495 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4496 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4497 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4498 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4499 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4500 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4501 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4502 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4503 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4504 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4505 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4507 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4508 #include "builtin-types.def"
4509 #undef DEF_PRIMITIVE_TYPE
4510 #undef DEF_FUNCTION_TYPE_0
4511 #undef DEF_FUNCTION_TYPE_1
4512 #undef DEF_FUNCTION_TYPE_2
4513 #undef DEF_FUNCTION_TYPE_3
4514 #undef DEF_FUNCTION_TYPE_4
4515 #undef DEF_FUNCTION_TYPE_5
4516 #undef DEF_FUNCTION_TYPE_6
4517 #undef DEF_FUNCTION_TYPE_7
4518 #undef DEF_FUNCTION_TYPE_VAR_0
4519 #undef DEF_FUNCTION_TYPE_VAR_1
4520 #undef DEF_FUNCTION_TYPE_VAR_2
4521 #undef DEF_FUNCTION_TYPE_VAR_3
4522 #undef DEF_FUNCTION_TYPE_VAR_4
4523 #undef DEF_FUNCTION_TYPE_VAR_5
4524 #undef DEF_POINTER_TYPE
4528 typedef enum c_builtin_type builtin_type;
4530 /* A temporary array for c_common_nodes_and_builtins. Used in
4531 communication with def_fn_type. */
4532 static tree builtin_types[(int) BT_LAST + 1];
4534 /* A helper function for c_common_nodes_and_builtins. Build function type
4535 for DEF with return type RET and N arguments. If VAR is true, then the
4536 function should be variadic after those N arguments.
4538 Takes special care not to ICE if any of the types involved are
4539 error_mark_node, which indicates that said type is not in fact available
4540 (see builtin_type_for_size). In which case the function type as a whole
4541 should be error_mark_node. */
4544 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4546 tree args = NULL, t;
4551 for (i = 0; i < n; ++i)
4553 builtin_type a = (builtin_type) va_arg (list, int);
4554 t = builtin_types[a];
4555 if (t == error_mark_node)
4557 args = tree_cons (NULL_TREE, t, args);
4561 args = nreverse (args);
4563 args = chainon (args, void_list_node);
4565 t = builtin_types[ret];
4566 if (t == error_mark_node)
4568 t = build_function_type (t, args);
4571 builtin_types[def] = t;
4574 /* Build builtin functions common to both C and C++ language
4578 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4580 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4581 builtin_types[ENUM] = VALUE;
4582 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4583 def_fn_type (ENUM, RETURN, 0, 0);
4584 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4585 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4586 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4587 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4588 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4589 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4590 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4591 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4592 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4593 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4594 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4596 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4597 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4599 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4600 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4601 def_fn_type (ENUM, RETURN, 1, 0);
4602 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4603 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4604 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4605 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4606 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4607 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4608 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4609 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4610 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4611 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4612 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4613 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4615 #include "builtin-types.def"
4617 #undef DEF_PRIMITIVE_TYPE
4618 #undef DEF_FUNCTION_TYPE_1
4619 #undef DEF_FUNCTION_TYPE_2
4620 #undef DEF_FUNCTION_TYPE_3
4621 #undef DEF_FUNCTION_TYPE_4
4622 #undef DEF_FUNCTION_TYPE_5
4623 #undef DEF_FUNCTION_TYPE_6
4624 #undef DEF_FUNCTION_TYPE_VAR_0
4625 #undef DEF_FUNCTION_TYPE_VAR_1
4626 #undef DEF_FUNCTION_TYPE_VAR_2
4627 #undef DEF_FUNCTION_TYPE_VAR_3
4628 #undef DEF_FUNCTION_TYPE_VAR_4
4629 #undef DEF_FUNCTION_TYPE_VAR_5
4630 #undef DEF_POINTER_TYPE
4631 builtin_types[(int) BT_LAST] = NULL_TREE;
4633 c_init_attributes ();
4635 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4636 NONANSI_P, ATTRS, IMPLICIT, COND) \
4638 def_builtin_1 (ENUM, NAME, CLASS, \
4639 builtin_types[(int) TYPE], \
4640 builtin_types[(int) LIBTYPE], \
4641 BOTH_P, FALLBACK_P, NONANSI_P, \
4642 built_in_attributes[(int) ATTRS], IMPLICIT);
4643 #include "builtins.def"
4646 targetm.init_builtins ();
4648 build_common_builtin_nodes ();
4654 /* Like get_identifier, but avoid warnings about null arguments when
4655 the argument may be NULL for targets where GCC lacks stdint.h type
4659 c_get_ident (const char *id)
4661 return get_identifier (id);
4664 /* Build tree nodes and builtin functions common to both C and C++ language
4668 c_common_nodes_and_builtins (void)
4670 int char16_type_size;
4671 int char32_type_size;
4672 int wchar_type_size;
4673 tree array_domain_type;
4674 tree va_list_ref_type_node;
4675 tree va_list_arg_type_node;
4677 /* Define `int' and `char' first so that dbx will output them first. */
4678 record_builtin_type (RID_INT, NULL, integer_type_node);
4679 record_builtin_type (RID_CHAR, "char", char_type_node);
4681 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4682 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4683 but not C. Are the conditionals here needed? */
4684 if (c_dialect_cxx ())
4685 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4686 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4687 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4688 record_builtin_type (RID_MAX, "long unsigned int",
4689 long_unsigned_type_node);
4690 if (c_dialect_cxx ())
4691 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4692 record_builtin_type (RID_MAX, "long long int",
4693 long_long_integer_type_node);
4694 record_builtin_type (RID_MAX, "long long unsigned int",
4695 long_long_unsigned_type_node);
4696 if (c_dialect_cxx ())
4697 record_builtin_type (RID_MAX, "long long unsigned",
4698 long_long_unsigned_type_node);
4699 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4700 record_builtin_type (RID_MAX, "short unsigned int",
4701 short_unsigned_type_node);
4702 if (c_dialect_cxx ())
4703 record_builtin_type (RID_MAX, "unsigned short",
4704 short_unsigned_type_node);
4706 /* Define both `signed char' and `unsigned char'. */
4707 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4708 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4710 /* These are types that c_common_type_for_size and
4711 c_common_type_for_mode use. */
4712 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4714 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4716 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4718 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4720 #if HOST_BITS_PER_WIDE_INT >= 64
4721 if (targetm.scalar_mode_supported_p (TImode))
4722 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4723 get_identifier ("__int128_t"),
4726 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4727 unsigned_intQI_type_node));
4728 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4729 unsigned_intHI_type_node));
4730 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4731 unsigned_intSI_type_node));
4732 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4733 unsigned_intDI_type_node));
4734 #if HOST_BITS_PER_WIDE_INT >= 64
4735 if (targetm.scalar_mode_supported_p (TImode))
4736 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4737 get_identifier ("__uint128_t"),
4738 unsigned_intTI_type_node));
4741 /* Create the widest literal types. */
4742 widest_integer_literal_type_node
4743 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4744 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4745 widest_integer_literal_type_node));
4747 widest_unsigned_literal_type_node
4748 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4749 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4750 widest_unsigned_literal_type_node));
4752 /* `unsigned long' is the standard type for sizeof.
4753 Note that stddef.h uses `unsigned long',
4754 and this must agree, even if long and int are the same size. */
4756 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4757 signed_size_type_node = c_common_signed_type (size_type_node);
4758 set_sizetype (size_type_node);
4761 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4763 build_common_tree_nodes_2 (flag_short_double);
4765 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4766 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4767 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4769 /* Only supported decimal floating point extension if the target
4770 actually supports underlying modes. */
4771 if (targetm.scalar_mode_supported_p (SDmode)
4772 && targetm.scalar_mode_supported_p (DDmode)
4773 && targetm.scalar_mode_supported_p (TDmode))
4775 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4776 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4777 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4780 if (targetm.fixed_point_supported_p ())
4782 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4783 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4784 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4785 record_builtin_type (RID_MAX, "long long _Fract",
4786 long_long_fract_type_node);
4787 record_builtin_type (RID_MAX, "unsigned short _Fract",
4788 unsigned_short_fract_type_node);
4789 record_builtin_type (RID_MAX, "unsigned _Fract",
4790 unsigned_fract_type_node);
4791 record_builtin_type (RID_MAX, "unsigned long _Fract",
4792 unsigned_long_fract_type_node);
4793 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4794 unsigned_long_long_fract_type_node);
4795 record_builtin_type (RID_MAX, "_Sat short _Fract",
4796 sat_short_fract_type_node);
4797 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4798 record_builtin_type (RID_MAX, "_Sat long _Fract",
4799 sat_long_fract_type_node);
4800 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4801 sat_long_long_fract_type_node);
4802 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4803 sat_unsigned_short_fract_type_node);
4804 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4805 sat_unsigned_fract_type_node);
4806 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4807 sat_unsigned_long_fract_type_node);
4808 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4809 sat_unsigned_long_long_fract_type_node);
4810 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4811 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4812 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4813 record_builtin_type (RID_MAX, "long long _Accum",
4814 long_long_accum_type_node);
4815 record_builtin_type (RID_MAX, "unsigned short _Accum",
4816 unsigned_short_accum_type_node);
4817 record_builtin_type (RID_MAX, "unsigned _Accum",
4818 unsigned_accum_type_node);
4819 record_builtin_type (RID_MAX, "unsigned long _Accum",
4820 unsigned_long_accum_type_node);
4821 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4822 unsigned_long_long_accum_type_node);
4823 record_builtin_type (RID_MAX, "_Sat short _Accum",
4824 sat_short_accum_type_node);
4825 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4826 record_builtin_type (RID_MAX, "_Sat long _Accum",
4827 sat_long_accum_type_node);
4828 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4829 sat_long_long_accum_type_node);
4830 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4831 sat_unsigned_short_accum_type_node);
4832 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4833 sat_unsigned_accum_type_node);
4834 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4835 sat_unsigned_long_accum_type_node);
4836 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4837 sat_unsigned_long_long_accum_type_node);
4841 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4842 get_identifier ("complex int"),
4843 complex_integer_type_node));
4844 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4845 get_identifier ("complex float"),
4846 complex_float_type_node));
4847 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4848 get_identifier ("complex double"),
4849 complex_double_type_node));
4850 lang_hooks.decls.pushdecl
4851 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4852 complex_long_double_type_node));
4854 if (c_dialect_cxx ())
4855 /* For C++, make fileptr_type_node a distinct void * type until
4856 FILE type is defined. */
4857 fileptr_type_node = build_variant_type_copy (ptr_type_node);
4859 record_builtin_type (RID_VOID, NULL, void_type_node);
4861 /* Set the TYPE_NAME for any variants that were built before
4862 record_builtin_type gave names to the built-in types. */
4864 tree void_name = TYPE_NAME (void_type_node);
4865 TYPE_NAME (void_type_node) = NULL_TREE;
4866 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4868 TYPE_NAME (void_type_node) = void_name;
4871 /* This node must not be shared. */
4872 void_zero_node = make_node (INTEGER_CST);
4873 TREE_TYPE (void_zero_node) = void_type_node;
4875 void_list_node = build_void_list_node ();
4877 /* Make a type to be the domain of a few array types
4878 whose domains don't really matter.
4879 200 is small enough that it always fits in size_t
4880 and large enough that it can hold most function names for the
4881 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4882 array_domain_type = build_index_type (size_int (200));
4884 /* Make a type for arrays of characters.
4885 With luck nothing will ever really depend on the length of this
4887 char_array_type_node
4888 = build_array_type (char_type_node, array_domain_type);
4890 /* Likewise for arrays of ints. */
4892 = build_array_type (integer_type_node, array_domain_type);
4894 string_type_node = build_pointer_type (char_type_node);
4895 const_string_type_node
4896 = build_pointer_type (build_qualified_type
4897 (char_type_node, TYPE_QUAL_CONST));
4899 /* This is special for C++ so functions can be overloaded. */
4900 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4901 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4902 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4903 underlying_wchar_type_node = wchar_type_node;
4904 if (c_dialect_cxx ())
4906 if (TYPE_UNSIGNED (wchar_type_node))
4907 wchar_type_node = make_unsigned_type (wchar_type_size);
4909 wchar_type_node = make_signed_type (wchar_type_size);
4910 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4913 /* This is for wide string constants. */
4914 wchar_array_type_node
4915 = build_array_type (wchar_type_node, array_domain_type);
4917 /* Define 'char16_t'. */
4918 char16_type_node = get_identifier (CHAR16_TYPE);
4919 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4920 char16_type_size = TYPE_PRECISION (char16_type_node);
4921 if (c_dialect_cxx ())
4923 char16_type_node = make_unsigned_type (char16_type_size);
4925 if (cxx_dialect == cxx0x)
4926 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4929 /* This is for UTF-16 string constants. */
4930 char16_array_type_node
4931 = build_array_type (char16_type_node, array_domain_type);
4933 /* Define 'char32_t'. */
4934 char32_type_node = get_identifier (CHAR32_TYPE);
4935 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4936 char32_type_size = TYPE_PRECISION (char32_type_node);
4937 if (c_dialect_cxx ())
4939 char32_type_node = make_unsigned_type (char32_type_size);
4941 if (cxx_dialect == cxx0x)
4942 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4945 /* This is for UTF-32 string constants. */
4946 char32_array_type_node
4947 = build_array_type (char32_type_node, array_domain_type);
4950 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4953 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4955 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4957 if (SIG_ATOMIC_TYPE)
4958 sig_atomic_type_node =
4959 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
4962 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
4965 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
4968 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
4971 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
4974 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
4977 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
4979 c_uint32_type_node =
4980 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
4982 c_uint64_type_node =
4983 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
4984 if (INT_LEAST8_TYPE)
4985 int_least8_type_node =
4986 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
4987 if (INT_LEAST16_TYPE)
4988 int_least16_type_node =
4989 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
4990 if (INT_LEAST32_TYPE)
4991 int_least32_type_node =
4992 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
4993 if (INT_LEAST64_TYPE)
4994 int_least64_type_node =
4995 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
4996 if (UINT_LEAST8_TYPE)
4997 uint_least8_type_node =
4998 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
4999 if (UINT_LEAST16_TYPE)
5000 uint_least16_type_node =
5001 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
5002 if (UINT_LEAST32_TYPE)
5003 uint_least32_type_node =
5004 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
5005 if (UINT_LEAST64_TYPE)
5006 uint_least64_type_node =
5007 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
5009 int_fast8_type_node =
5010 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
5011 if (INT_FAST16_TYPE)
5012 int_fast16_type_node =
5013 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
5014 if (INT_FAST32_TYPE)
5015 int_fast32_type_node =
5016 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
5017 if (INT_FAST64_TYPE)
5018 int_fast64_type_node =
5019 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
5020 if (UINT_FAST8_TYPE)
5021 uint_fast8_type_node =
5022 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
5023 if (UINT_FAST16_TYPE)
5024 uint_fast16_type_node =
5025 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
5026 if (UINT_FAST32_TYPE)
5027 uint_fast32_type_node =
5028 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
5029 if (UINT_FAST64_TYPE)
5030 uint_fast64_type_node =
5031 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
5034 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
5037 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
5039 default_function_type = build_function_type (integer_type_node, NULL_TREE);
5041 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
5042 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
5044 lang_hooks.decls.pushdecl
5045 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
5046 va_list_type_node));
5047 #ifdef TARGET_ENUM_VA_LIST
5052 for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
5054 lang_hooks.decls.pushdecl
5055 (build_decl (TYPE_DECL, get_identifier (pname),
5062 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
5064 va_list_arg_type_node = va_list_ref_type_node =
5065 build_pointer_type (TREE_TYPE (va_list_type_node));
5069 va_list_arg_type_node = va_list_type_node;
5070 va_list_ref_type_node = build_reference_type (va_list_type_node);
5073 if (!flag_preprocess_only)
5074 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
5076 main_identifier_node = get_identifier ("main");
5078 /* Create the built-in __null node. It is important that this is
5080 null_node = make_node (INTEGER_CST);
5081 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
5083 /* Since builtin_types isn't gc'ed, don't export these nodes. */
5084 memset (builtin_types, 0, sizeof (builtin_types));
5087 /* Look up the function in built_in_decls that corresponds to DECL
5088 and set ASMSPEC as its user assembler name. DECL must be a
5089 function decl that declares a builtin. */
5092 set_builtin_user_assembler_name (tree decl, const char *asmspec)
5095 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
5096 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
5099 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
5100 set_user_assembler_name (builtin, asmspec);
5101 switch (DECL_FUNCTION_CODE (decl))
5103 case BUILT_IN_MEMCPY:
5104 init_block_move_fn (asmspec);
5105 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
5107 case BUILT_IN_MEMSET:
5108 init_block_clear_fn (asmspec);
5109 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
5111 case BUILT_IN_MEMMOVE:
5112 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
5114 case BUILT_IN_MEMCMP:
5115 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
5117 case BUILT_IN_ABORT:
5118 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
5125 /* The number of named compound-literals generated thus far. */
5126 static GTY(()) int compound_literal_number;
5128 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
5131 set_compound_literal_name (tree decl)
5134 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
5135 compound_literal_number);
5136 compound_literal_number++;
5137 DECL_NAME (decl) = get_identifier (name);
5141 build_va_arg (tree expr, tree type)
5143 return build1 (VA_ARG_EXPR, type, expr);
5147 /* Linked list of disabled built-in functions. */
5149 typedef struct disabled_builtin
5152 struct disabled_builtin *next;
5154 static disabled_builtin *disabled_builtins = NULL;
5156 static bool builtin_function_disabled_p (const char *);
5158 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5159 begins with "__builtin_", give an error. */
5162 disable_builtin_function (const char *name)
5164 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
5165 error ("cannot disable built-in function %qs", name);
5168 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
5169 new_disabled_builtin->name = name;
5170 new_disabled_builtin->next = disabled_builtins;
5171 disabled_builtins = new_disabled_builtin;
5176 /* Return true if the built-in function NAME has been disabled, false
5180 builtin_function_disabled_p (const char *name)
5182 disabled_builtin *p;
5183 for (p = disabled_builtins; p != NULL; p = p->next)
5185 if (strcmp (name, p->name) == 0)
5192 /* Worker for DEF_BUILTIN.
5193 Possibly define a builtin function with one or two names.
5194 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5195 nonansi_p and flag_no_nonansi_builtin. */
5198 def_builtin_1 (enum built_in_function fncode,
5200 enum built_in_class fnclass,
5201 tree fntype, tree libtype,
5202 bool both_p, bool fallback_p, bool nonansi_p,
5203 tree fnattrs, bool implicit_p)
5206 const char *libname;
5208 if (fntype == error_mark_node)
5211 gcc_assert ((!both_p && !fallback_p)
5212 || !strncmp (name, "__builtin_",
5213 strlen ("__builtin_")));
5215 libname = name + strlen ("__builtin_");
5216 decl = add_builtin_function (name, fntype, fncode, fnclass,
5217 (fallback_p ? libname : NULL),
5220 && !flag_no_builtin && !builtin_function_disabled_p (libname)
5221 && !(nonansi_p && flag_no_nonansi_builtin))
5222 add_builtin_function (libname, libtype, fncode, fnclass,
5225 built_in_decls[(int) fncode] = decl;
5227 implicit_built_in_decls[(int) fncode] = decl;
5230 /* Nonzero if the type T promotes to int. This is (nearly) the
5231 integral promotions defined in ISO C99 6.3.1.1/2. */
5234 c_promoting_integer_type_p (const_tree t)
5236 switch (TREE_CODE (t))
5239 return (TYPE_MAIN_VARIANT (t) == char_type_node
5240 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5241 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5242 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
5243 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5244 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
5247 /* ??? Technically all enumerations not larger than an int
5248 promote to an int. But this is used along code paths
5249 that only want to notice a size change. */
5250 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5260 /* Return 1 if PARMS specifies a fixed number of parameters
5261 and none of their types is affected by default promotions. */
5264 self_promoting_args_p (const_tree parms)
5267 for (t = parms; t; t = TREE_CHAIN (t))
5269 tree type = TREE_VALUE (t);
5271 if (type == error_mark_node)
5274 if (TREE_CHAIN (t) == 0 && type != void_type_node)
5280 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5283 if (c_promoting_integer_type_p (type))
5289 /* Recursively remove any '*' or '&' operator from TYPE. */
5291 strip_pointer_operator (tree t)
5293 while (POINTER_TYPE_P (t))
5298 /* Recursively remove pointer or array type from TYPE. */
5300 strip_pointer_or_array_types (tree t)
5302 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5307 /* Used to compare case labels. K1 and K2 are actually tree nodes
5308 representing case labels, or NULL_TREE for a `default' label.
5309 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5310 K2, and 0 if K1 and K2 are equal. */
5313 case_compare (splay_tree_key k1, splay_tree_key k2)
5315 /* Consider a NULL key (such as arises with a `default' label) to be
5316 smaller than anything else. */
5322 return tree_int_cst_compare ((tree) k1, (tree) k2);
5325 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
5326 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
5327 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
5328 case label was declared using the usual C/C++ syntax, rather than
5329 the GNU case range extension. CASES is a tree containing all the
5330 case ranges processed so far; COND is the condition for the
5331 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
5332 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
5335 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
5336 tree low_value, tree high_value)
5341 splay_tree_node node;
5343 /* Create the LABEL_DECL itself. */
5344 label = create_artificial_label ();
5346 /* If there was an error processing the switch condition, bail now
5347 before we get more confused. */
5348 if (!cond || cond == error_mark_node)
5351 if ((low_value && TREE_TYPE (low_value)
5352 && POINTER_TYPE_P (TREE_TYPE (low_value)))
5353 || (high_value && TREE_TYPE (high_value)
5354 && POINTER_TYPE_P (TREE_TYPE (high_value))))
5356 error ("pointers are not permitted as case values");
5360 /* Case ranges are a GNU extension. */
5362 pedwarn (input_location, OPT_pedantic,
5363 "range expressions in switch statements are non-standard");
5365 type = TREE_TYPE (cond);
5368 low_value = check_case_value (low_value);
5369 low_value = convert_and_check (type, low_value);
5370 if (low_value == error_mark_node)
5375 high_value = check_case_value (high_value);
5376 high_value = convert_and_check (type, high_value);
5377 if (high_value == error_mark_node)
5381 if (low_value && high_value)
5383 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5384 really a case range, even though it was written that way.
5385 Remove the HIGH_VALUE to simplify later processing. */
5386 if (tree_int_cst_equal (low_value, high_value))
5387 high_value = NULL_TREE;
5388 else if (!tree_int_cst_lt (low_value, high_value))
5389 warning (0, "empty range specified");
5392 /* See if the case is in range of the type of the original testing
5393 expression. If both low_value and high_value are out of range,
5394 don't insert the case label and return NULL_TREE. */
5396 && !check_case_bounds (type, orig_type,
5397 &low_value, high_value ? &high_value : NULL))
5400 /* Look up the LOW_VALUE in the table of case labels we already
5402 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5403 /* If there was not an exact match, check for overlapping ranges.
5404 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5405 that's a `default' label and the only overlap is an exact match. */
5406 if (!node && (low_value || high_value))
5408 splay_tree_node low_bound;
5409 splay_tree_node high_bound;
5411 /* Even though there wasn't an exact match, there might be an
5412 overlap between this case range and another case range.
5413 Since we've (inductively) not allowed any overlapping case
5414 ranges, we simply need to find the greatest low case label
5415 that is smaller that LOW_VALUE, and the smallest low case
5416 label that is greater than LOW_VALUE. If there is an overlap
5417 it will occur in one of these two ranges. */
5418 low_bound = splay_tree_predecessor (cases,
5419 (splay_tree_key) low_value);
5420 high_bound = splay_tree_successor (cases,
5421 (splay_tree_key) low_value);
5423 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5424 the LOW_VALUE, so there is no need to check unless the
5425 LOW_BOUND is in fact itself a case range. */
5427 && CASE_HIGH ((tree) low_bound->value)
5428 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5431 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5432 range is bigger than the low end of the current range, so we
5433 are only interested if the current range is a real range, and
5434 not an ordinary case label. */
5437 && (tree_int_cst_compare ((tree) high_bound->key,
5442 /* If there was an overlap, issue an error. */
5445 tree duplicate = CASE_LABEL ((tree) node->value);
5449 error ("duplicate (or overlapping) case value");
5450 error ("%Jthis is the first entry overlapping that value", duplicate);
5454 error ("duplicate case value") ;
5455 error ("%Jpreviously used here", duplicate);
5459 error ("multiple default labels in one switch");
5460 error ("%Jthis is the first default label", duplicate);
5465 /* Add a CASE_LABEL to the statement-tree. */
5466 case_label = add_stmt (build_case_label (low_value, high_value, label));
5467 /* Register this case label in the splay tree. */
5468 splay_tree_insert (cases,
5469 (splay_tree_key) low_value,
5470 (splay_tree_value) case_label);
5475 /* Add a label so that the back-end doesn't think that the beginning of
5476 the switch is unreachable. Note that we do not add a case label, as
5477 that just leads to duplicates and thence to failure later on. */
5480 tree t = create_artificial_label ();
5481 add_stmt (build_stmt (LABEL_EXPR, t));
5483 return error_mark_node;
5486 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5487 Used to verify that case values match up with enumerator values. */
5490 match_case_to_enum_1 (tree key, tree type, tree label)
5492 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5494 /* ??? Not working too hard to print the double-word value.
5495 Should perhaps be done with %lwd in the diagnostic routines? */
5496 if (TREE_INT_CST_HIGH (key) == 0)
5497 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5498 TREE_INT_CST_LOW (key));
5499 else if (!TYPE_UNSIGNED (type)
5500 && TREE_INT_CST_HIGH (key) == -1
5501 && TREE_INT_CST_LOW (key) != 0)
5502 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5503 -TREE_INT_CST_LOW (key));
5505 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5506 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5507 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
5509 if (TYPE_NAME (type) == 0)
5510 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5511 "%Jcase value %qs not in enumerated type",
5512 CASE_LABEL (label), buf);
5514 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5515 "%Jcase value %qs not in enumerated type %qT",
5516 CASE_LABEL (label), buf, type);
5519 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5520 Used to verify that case values match up with enumerator values. */
5523 match_case_to_enum (splay_tree_node node, void *data)
5525 tree label = (tree) node->value;
5526 tree type = (tree) data;
5528 /* Skip default case. */
5529 if (!CASE_LOW (label))
5532 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5533 when we did our enum->case scan. Reset our scratch bit after. */
5534 if (!CASE_LOW_SEEN (label))
5535 match_case_to_enum_1 (CASE_LOW (label), type, label);
5537 CASE_LOW_SEEN (label) = 0;
5539 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5540 not set, that means that CASE_HIGH did not appear when we did our
5541 enum->case scan. Reset our scratch bit after. */
5542 if (CASE_HIGH (label))
5544 if (!CASE_HIGH_SEEN (label))
5545 match_case_to_enum_1 (CASE_HIGH (label), type, label);
5547 CASE_HIGH_SEEN (label) = 0;
5553 /* Handle -Wswitch*. Called from the front end after parsing the
5554 switch construct. */
5555 /* ??? Should probably be somewhere generic, since other languages
5556 besides C and C++ would want this. At the moment, however, C/C++
5557 are the only tree-ssa languages that support enumerations at all,
5558 so the point is moot. */
5561 c_do_switch_warnings (splay_tree cases, location_t switch_location,
5562 tree type, tree cond)
5564 splay_tree_node default_node;
5565 splay_tree_node node;
5567 int saved_warn_switch;
5569 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5572 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
5574 warning (OPT_Wswitch_default, "%Hswitch missing default case",
5577 /* From here on, we only care about about enumerated types. */
5578 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5581 /* If the switch expression was an enumerated type, check that
5582 exactly all enumeration literals are covered by the cases.
5583 The check is made when -Wswitch was specified and there is no
5584 default case, or when -Wswitch-enum was specified. */
5586 if (!warn_switch_enum
5587 && !(warn_switch && !default_node))
5590 /* Clearing COND if it is not an integer constant simplifies
5591 the tests inside the loop below. */
5592 if (TREE_CODE (cond) != INTEGER_CST)
5595 /* The time complexity here is O(N*lg(N)) worst case, but for the
5596 common case of monotonically increasing enumerators, it is
5597 O(N), since the nature of the splay tree will keep the next
5598 element adjacent to the root at all times. */
5600 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5602 tree value = TREE_VALUE (chain);
5603 if (TREE_CODE (value) == CONST_DECL)
5604 value = DECL_INITIAL (value);
5605 node = splay_tree_lookup (cases, (splay_tree_key) value);
5608 /* Mark the CASE_LOW part of the case entry as seen. */
5609 tree label = (tree) node->value;
5610 CASE_LOW_SEEN (label) = 1;
5614 /* Even though there wasn't an exact match, there might be a
5615 case range which includes the enumerator's value. */
5616 node = splay_tree_predecessor (cases, (splay_tree_key) value);
5617 if (node && CASE_HIGH ((tree) node->value))
5619 tree label = (tree) node->value;
5620 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5623 /* If we match the upper bound exactly, mark the CASE_HIGH
5624 part of the case entry as seen. */
5626 CASE_HIGH_SEEN (label) = 1;
5631 /* We've now determined that this enumerated literal isn't
5632 handled by the case labels of the switch statement. */
5634 /* If the switch expression is a constant, we only really care
5635 about whether that constant is handled by the switch. */
5636 if (cond && tree_int_cst_compare (cond, value))
5639 /* If there is a default_node, the only relevant option is
5640 Wswitch-enum. Otherwise, if both are enabled then we prefer
5641 to warn using -Wswitch because -Wswitch is enabled by -Wall
5642 while -Wswitch-enum is explicit. */
5643 warning ((default_node || !warn_switch)
5644 ? OPT_Wswitch_enum : OPT_Wswitch,
5645 "%Henumeration value %qE not handled in switch",
5646 &switch_location, TREE_PURPOSE (chain));
5649 /* Warn if there are case expressions that don't correspond to
5650 enumerators. This can occur since C and C++ don't enforce
5651 type-checking of assignments to enumeration variables.
5653 The time complexity here is now always O(N) worst case, since
5654 we should have marked both the lower bound and upper bound of
5655 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5656 above. This scan also resets those fields. */
5658 /* If there is a default_node, the only relevant option is
5659 Wswitch-enum. Otherwise, if both are enabled then we prefer
5660 to warn using -Wswitch because -Wswitch is enabled by -Wall
5661 while -Wswitch-enum is explicit. */
5662 saved_warn_switch = warn_switch;
5665 splay_tree_foreach (cases, match_case_to_enum, type);
5666 warn_switch = saved_warn_switch;
5670 /* Finish an expression taking the address of LABEL (an
5671 IDENTIFIER_NODE). Returns an expression for the address.
5673 LOC is the location for the expression returned. */
5676 finish_label_address_expr (tree label, location_t loc)
5680 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5682 if (label == error_mark_node)
5683 return error_mark_node;
5685 label = lookup_label (label);
5686 if (label == NULL_TREE)
5687 result = null_pointer_node;
5690 TREE_USED (label) = 1;
5691 result = build1 (ADDR_EXPR, ptr_type_node, label);
5692 /* The current function in not necessarily uninlinable.
5693 Computed gotos are incompatible with inlining, but the value
5694 here could be used only in a diagnostic, for example. */
5695 protected_set_expr_location (result, loc);
5702 /* Given a boolean expression ARG, return a tree representing an increment
5703 or decrement (as indicated by CODE) of ARG. The front end must check for
5704 invalid cases (e.g., decrement in C++). */
5706 boolean_increment (enum tree_code code, tree arg)
5709 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5711 arg = stabilize_reference (arg);
5714 case PREINCREMENT_EXPR:
5715 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5717 case POSTINCREMENT_EXPR:
5718 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5719 arg = save_expr (arg);
5720 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5721 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5723 case PREDECREMENT_EXPR:
5724 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5725 invert_truthvalue (arg));
5727 case POSTDECREMENT_EXPR:
5728 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5729 invert_truthvalue (arg));
5730 arg = save_expr (arg);
5731 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5732 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5737 TREE_SIDE_EFFECTS (val) = 1;
5741 /* Built-in macros for stddef.h and stdint.h, that require macros
5742 defined in this file. */
5744 c_stddef_cpp_builtins(void)
5746 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5747 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5748 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5749 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5750 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5751 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5752 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5753 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5754 if (SIG_ATOMIC_TYPE)
5755 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5757 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5759 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5761 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5763 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5765 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5767 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5769 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5771 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5772 if (INT_LEAST8_TYPE)
5773 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5774 if (INT_LEAST16_TYPE)
5775 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5776 if (INT_LEAST32_TYPE)
5777 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5778 if (INT_LEAST64_TYPE)
5779 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5780 if (UINT_LEAST8_TYPE)
5781 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5782 if (UINT_LEAST16_TYPE)
5783 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5784 if (UINT_LEAST32_TYPE)
5785 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5786 if (UINT_LEAST64_TYPE)
5787 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5789 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5790 if (INT_FAST16_TYPE)
5791 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5792 if (INT_FAST32_TYPE)
5793 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5794 if (INT_FAST64_TYPE)
5795 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5796 if (UINT_FAST8_TYPE)
5797 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5798 if (UINT_FAST16_TYPE)
5799 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5800 if (UINT_FAST32_TYPE)
5801 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5802 if (UINT_FAST64_TYPE)
5803 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5805 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5807 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
5811 c_init_attributes (void)
5813 /* Fill in the built_in_attributes array. */
5814 #define DEF_ATTR_NULL_TREE(ENUM) \
5815 built_in_attributes[(int) ENUM] = NULL_TREE;
5816 #define DEF_ATTR_INT(ENUM, VALUE) \
5817 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5818 #define DEF_ATTR_IDENT(ENUM, STRING) \
5819 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5820 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5821 built_in_attributes[(int) ENUM] \
5822 = tree_cons (built_in_attributes[(int) PURPOSE], \
5823 built_in_attributes[(int) VALUE], \
5824 built_in_attributes[(int) CHAIN]);
5825 #include "builtin-attrs.def"
5826 #undef DEF_ATTR_NULL_TREE
5828 #undef DEF_ATTR_IDENT
5829 #undef DEF_ATTR_TREE_LIST
5832 /* Attribute handlers common to C front ends. */
5834 /* Handle a "packed" attribute; arguments as in
5835 struct attribute_spec.handler. */
5838 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5839 int flags, bool *no_add_attrs)
5843 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5844 *node = build_variant_type_copy (*node);
5845 TYPE_PACKED (*node) = 1;
5847 else if (TREE_CODE (*node) == FIELD_DECL)
5849 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5850 /* Still pack bitfields. */
5851 && ! DECL_INITIAL (*node))
5852 warning (OPT_Wattributes,
5853 "%qE attribute ignored for field of type %qT",
5854 name, TREE_TYPE (*node));
5856 DECL_PACKED (*node) = 1;
5858 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5859 used for DECL_REGISTER. It wouldn't mean anything anyway.
5860 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5861 that changes what the typedef is typing. */
5864 warning (OPT_Wattributes, "%qE attribute ignored", name);
5865 *no_add_attrs = true;
5871 /* Handle a "nocommon" attribute; arguments as in
5872 struct attribute_spec.handler. */
5875 handle_nocommon_attribute (tree *node, tree name,
5876 tree ARG_UNUSED (args),
5877 int ARG_UNUSED (flags), bool *no_add_attrs)
5879 if (TREE_CODE (*node) == VAR_DECL)
5880 DECL_COMMON (*node) = 0;
5883 warning (OPT_Wattributes, "%qE attribute ignored", name);
5884 *no_add_attrs = true;
5890 /* Handle a "common" attribute; arguments as in
5891 struct attribute_spec.handler. */
5894 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5895 int ARG_UNUSED (flags), bool *no_add_attrs)
5897 if (TREE_CODE (*node) == VAR_DECL)
5898 DECL_COMMON (*node) = 1;
5901 warning (OPT_Wattributes, "%qE attribute ignored", name);
5902 *no_add_attrs = true;
5908 /* Handle a "noreturn" attribute; arguments as in
5909 struct attribute_spec.handler. */
5912 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5913 int ARG_UNUSED (flags), bool *no_add_attrs)
5915 tree type = TREE_TYPE (*node);
5917 /* See FIXME comment in c_common_attribute_table. */
5918 if (TREE_CODE (*node) == FUNCTION_DECL)
5919 TREE_THIS_VOLATILE (*node) = 1;
5920 else if (TREE_CODE (type) == POINTER_TYPE
5921 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5923 = build_pointer_type
5924 (build_type_variant (TREE_TYPE (type),
5925 TYPE_READONLY (TREE_TYPE (type)), 1));
5928 warning (OPT_Wattributes, "%qE attribute ignored", name);
5929 *no_add_attrs = true;
5935 /* Handle a "hot" and attribute; arguments as in
5936 struct attribute_spec.handler. */
5939 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5940 int ARG_UNUSED (flags), bool *no_add_attrs)
5942 if (TREE_CODE (*node) == FUNCTION_DECL)
5944 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5946 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5948 *no_add_attrs = true;
5950 /* Most of the rest of the hot processing is done later with
5951 lookup_attribute. */
5955 warning (OPT_Wattributes, "%qE attribute ignored", name);
5956 *no_add_attrs = true;
5961 /* Handle a "cold" and attribute; arguments as in
5962 struct attribute_spec.handler. */
5965 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5966 int ARG_UNUSED (flags), bool *no_add_attrs)
5968 if (TREE_CODE (*node) == FUNCTION_DECL)
5970 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5972 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5974 *no_add_attrs = true;
5976 /* Most of the rest of the cold processing is done later with
5977 lookup_attribute. */
5981 warning (OPT_Wattributes, "%qE attribute ignored", name);
5982 *no_add_attrs = true;
5988 /* Handle a "noinline" attribute; arguments as in
5989 struct attribute_spec.handler. */
5992 handle_noinline_attribute (tree *node, tree name,
5993 tree ARG_UNUSED (args),
5994 int ARG_UNUSED (flags), bool *no_add_attrs)
5996 if (TREE_CODE (*node) == FUNCTION_DECL)
5997 DECL_UNINLINABLE (*node) = 1;
6000 warning (OPT_Wattributes, "%qE attribute ignored", name);
6001 *no_add_attrs = true;
6007 /* Handle a "always_inline" attribute; arguments as in
6008 struct attribute_spec.handler. */
6011 handle_always_inline_attribute (tree *node, tree name,
6012 tree ARG_UNUSED (args),
6013 int ARG_UNUSED (flags),
6016 if (TREE_CODE (*node) == FUNCTION_DECL)
6018 /* Set the attribute and mark it for disregarding inline
6020 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
6024 warning (OPT_Wattributes, "%qE attribute ignored", name);
6025 *no_add_attrs = true;
6031 /* Handle a "gnu_inline" attribute; arguments as in
6032 struct attribute_spec.handler. */
6035 handle_gnu_inline_attribute (tree *node, tree name,
6036 tree ARG_UNUSED (args),
6037 int ARG_UNUSED (flags),
6040 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6042 /* Do nothing else, just set the attribute. We'll get at
6043 it later with lookup_attribute. */
6047 warning (OPT_Wattributes, "%qE attribute ignored", name);
6048 *no_add_attrs = true;
6054 /* Handle an "artificial" attribute; arguments as in
6055 struct attribute_spec.handler. */
6058 handle_artificial_attribute (tree *node, tree name,
6059 tree ARG_UNUSED (args),
6060 int ARG_UNUSED (flags),
6063 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6065 /* Do nothing else, just set the attribute. We'll get at
6066 it later with lookup_attribute. */
6070 warning (OPT_Wattributes, "%qE attribute ignored", name);
6071 *no_add_attrs = true;
6077 /* Handle a "flatten" attribute; arguments as in
6078 struct attribute_spec.handler. */
6081 handle_flatten_attribute (tree *node, tree name,
6082 tree args ATTRIBUTE_UNUSED,
6083 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
6085 if (TREE_CODE (*node) == FUNCTION_DECL)
6086 /* Do nothing else, just set the attribute. We'll get at
6087 it later with lookup_attribute. */
6091 warning (OPT_Wattributes, "%qE attribute ignored", name);
6092 *no_add_attrs = true;
6098 /* Handle a "warning" or "error" attribute; arguments as in
6099 struct attribute_spec.handler. */
6102 handle_error_attribute (tree *node, tree name, tree args,
6103 int ARG_UNUSED (flags), bool *no_add_attrs)
6105 if (TREE_CODE (*node) == FUNCTION_DECL
6106 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6107 /* Do nothing else, just set the attribute. We'll get at
6108 it later with lookup_attribute. */
6112 warning (OPT_Wattributes, "%qE attribute ignored", name);
6113 *no_add_attrs = true;
6119 /* Handle a "used" attribute; arguments as in
6120 struct attribute_spec.handler. */
6123 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6124 int ARG_UNUSED (flags), bool *no_add_attrs)
6128 if (TREE_CODE (node) == FUNCTION_DECL
6129 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
6131 TREE_USED (node) = 1;
6132 DECL_PRESERVE_P (node) = 1;
6136 warning (OPT_Wattributes, "%qE attribute ignored", name);
6137 *no_add_attrs = true;
6143 /* Handle a "unused" attribute; arguments as in
6144 struct attribute_spec.handler. */
6147 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6148 int flags, bool *no_add_attrs)
6154 if (TREE_CODE (decl) == PARM_DECL
6155 || TREE_CODE (decl) == VAR_DECL
6156 || TREE_CODE (decl) == FUNCTION_DECL
6157 || TREE_CODE (decl) == LABEL_DECL
6158 || TREE_CODE (decl) == TYPE_DECL)
6159 TREE_USED (decl) = 1;
6162 warning (OPT_Wattributes, "%qE attribute ignored", name);
6163 *no_add_attrs = true;
6168 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6169 *node = build_variant_type_copy (*node);
6170 TREE_USED (*node) = 1;
6176 /* Handle a "externally_visible" attribute; arguments as in
6177 struct attribute_spec.handler. */
6180 handle_externally_visible_attribute (tree *pnode, tree name,
6181 tree ARG_UNUSED (args),
6182 int ARG_UNUSED (flags),
6187 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
6189 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6190 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6192 warning (OPT_Wattributes,
6193 "%qE attribute have effect only on public objects", name);
6194 *no_add_attrs = true;
6199 warning (OPT_Wattributes, "%qE attribute ignored", name);
6200 *no_add_attrs = true;
6206 /* Handle a "const" attribute; arguments as in
6207 struct attribute_spec.handler. */
6210 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6211 int ARG_UNUSED (flags), bool *no_add_attrs)
6213 tree type = TREE_TYPE (*node);
6215 /* See FIXME comment on noreturn in c_common_attribute_table. */
6216 if (TREE_CODE (*node) == FUNCTION_DECL)
6217 TREE_READONLY (*node) = 1;
6218 else if (TREE_CODE (type) == POINTER_TYPE
6219 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6221 = build_pointer_type
6222 (build_type_variant (TREE_TYPE (type), 1,
6223 TREE_THIS_VOLATILE (TREE_TYPE (type))));
6226 warning (OPT_Wattributes, "%qE attribute ignored", name);
6227 *no_add_attrs = true;
6233 /* Handle a "transparent_union" attribute; arguments as in
6234 struct attribute_spec.handler. */
6237 handle_transparent_union_attribute (tree *node, tree name,
6238 tree ARG_UNUSED (args), int flags,
6243 *no_add_attrs = true;
6245 if (TREE_CODE (*node) == TYPE_DECL)
6246 node = &TREE_TYPE (*node);
6249 if (TREE_CODE (type) == UNION_TYPE)
6251 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6252 the code in finish_struct. */
6253 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6255 if (TYPE_FIELDS (type) == NULL_TREE
6256 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6259 /* A type variant isn't good enough, since we don't a cast
6260 to such a type removed as a no-op. */
6261 *node = type = build_duplicate_type (type);
6264 TYPE_TRANSPARENT_UNION (type) = 1;
6269 warning (OPT_Wattributes, "%qE attribute ignored", name);
6273 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6274 get the requested priority for a constructor or destructor,
6275 possibly issuing diagnostics for invalid or reserved
6278 static priority_type
6279 get_priority (tree args, bool is_destructor)
6285 return DEFAULT_INIT_PRIORITY;
6287 if (!SUPPORTS_INIT_PRIORITY)
6290 error ("destructor priorities are not supported");
6292 error ("constructor priorities are not supported");
6293 return DEFAULT_INIT_PRIORITY;
6296 arg = TREE_VALUE (args);
6297 if (!host_integerp (arg, /*pos=*/0)
6298 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
6301 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6302 if (pri < 0 || pri > MAX_INIT_PRIORITY)
6305 if (pri <= MAX_RESERVED_INIT_PRIORITY)
6309 "destructor priorities from 0 to %d are reserved "
6310 "for the implementation",
6311 MAX_RESERVED_INIT_PRIORITY);
6314 "constructor priorities from 0 to %d are reserved "
6315 "for the implementation",
6316 MAX_RESERVED_INIT_PRIORITY);
6322 error ("destructor priorities must be integers from 0 to %d inclusive",
6325 error ("constructor priorities must be integers from 0 to %d inclusive",
6327 return DEFAULT_INIT_PRIORITY;
6330 /* Handle a "constructor" attribute; arguments as in
6331 struct attribute_spec.handler. */
6334 handle_constructor_attribute (tree *node, tree name, tree args,
6335 int ARG_UNUSED (flags),
6339 tree type = TREE_TYPE (decl);
6341 if (TREE_CODE (decl) == FUNCTION_DECL
6342 && TREE_CODE (type) == FUNCTION_TYPE
6343 && decl_function_context (decl) == 0)
6345 priority_type priority;
6346 DECL_STATIC_CONSTRUCTOR (decl) = 1;
6347 priority = get_priority (args, /*is_destructor=*/false);
6348 SET_DECL_INIT_PRIORITY (decl, priority);
6349 TREE_USED (decl) = 1;
6353 warning (OPT_Wattributes, "%qE attribute ignored", name);
6354 *no_add_attrs = true;
6360 /* Handle a "destructor" attribute; arguments as in
6361 struct attribute_spec.handler. */
6364 handle_destructor_attribute (tree *node, tree name, tree args,
6365 int ARG_UNUSED (flags),
6369 tree type = TREE_TYPE (decl);
6371 if (TREE_CODE (decl) == FUNCTION_DECL
6372 && TREE_CODE (type) == FUNCTION_TYPE
6373 && decl_function_context (decl) == 0)
6375 priority_type priority;
6376 DECL_STATIC_DESTRUCTOR (decl) = 1;
6377 priority = get_priority (args, /*is_destructor=*/true);
6378 SET_DECL_FINI_PRIORITY (decl, priority);
6379 TREE_USED (decl) = 1;
6383 warning (OPT_Wattributes, "%qE attribute ignored", name);
6384 *no_add_attrs = true;
6390 /* Handle a "mode" attribute; arguments as in
6391 struct attribute_spec.handler. */
6394 handle_mode_attribute (tree *node, tree name, tree args,
6395 int ARG_UNUSED (flags), bool *no_add_attrs)
6399 *no_add_attrs = true;
6401 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
6402 warning (OPT_Wattributes, "%qE attribute ignored", name);
6406 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
6407 int len = strlen (p);
6408 enum machine_mode mode = VOIDmode;
6412 if (len > 4 && p[0] == '_' && p[1] == '_'
6413 && p[len - 1] == '_' && p[len - 2] == '_')
6415 char *newp = (char *) alloca (len - 1);
6417 strcpy (newp, &p[2]);
6418 newp[len - 4] = '\0';
6422 /* Change this type to have a type with the specified mode.
6423 First check for the special modes. */
6424 if (!strcmp (p, "byte"))
6426 else if (!strcmp (p, "word"))
6428 else if (!strcmp (p, "pointer"))
6430 else if (!strcmp (p, "libgcc_cmp_return"))
6431 mode = targetm.libgcc_cmp_return_mode ();
6432 else if (!strcmp (p, "libgcc_shift_count"))
6433 mode = targetm.libgcc_shift_count_mode ();
6434 else if (!strcmp (p, "unwind_word"))
6435 mode = targetm.unwind_word_mode ();
6437 for (j = 0; j < NUM_MACHINE_MODES; j++)
6438 if (!strcmp (p, GET_MODE_NAME (j)))
6440 mode = (enum machine_mode) j;
6444 if (mode == VOIDmode)
6446 error ("unknown machine mode %qs", p);
6451 switch (GET_MODE_CLASS (mode))
6454 case MODE_PARTIAL_INT:
6456 case MODE_DECIMAL_FLOAT:
6461 valid_mode = targetm.scalar_mode_supported_p (mode);
6464 case MODE_COMPLEX_INT:
6465 case MODE_COMPLEX_FLOAT:
6466 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6469 case MODE_VECTOR_INT:
6470 case MODE_VECTOR_FLOAT:
6471 case MODE_VECTOR_FRACT:
6472 case MODE_VECTOR_UFRACT:
6473 case MODE_VECTOR_ACCUM:
6474 case MODE_VECTOR_UACCUM:
6475 warning (OPT_Wattributes, "specifying vector types with "
6476 "__attribute__ ((mode)) is deprecated");
6477 warning (OPT_Wattributes,
6478 "use __attribute__ ((vector_size)) instead");
6479 valid_mode = vector_mode_valid_p (mode);
6487 error ("unable to emulate %qs", p);
6491 if (POINTER_TYPE_P (type))
6493 tree (*fn)(tree, enum machine_mode, bool);
6495 if (!targetm.valid_pointer_mode (mode))
6497 error ("invalid pointer mode %qs", p);
6501 if (TREE_CODE (type) == POINTER_TYPE)
6502 fn = build_pointer_type_for_mode;
6504 fn = build_reference_type_for_mode;
6505 typefm = fn (TREE_TYPE (type), mode, false);
6509 /* For fixed-point modes, we need to test if the signness of type
6510 and the machine mode are consistent. */
6511 if (ALL_FIXED_POINT_MODE_P (mode)
6512 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6514 error ("signness of type and machine mode %qs don't match", p);
6517 /* For fixed-point modes, we need to pass saturating info. */
6518 typefm = lang_hooks.types.type_for_mode (mode,
6519 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6520 : TYPE_UNSIGNED (type));
6523 if (typefm == NULL_TREE)
6525 error ("no data type for mode %qs", p);
6528 else if (TREE_CODE (type) == ENUMERAL_TYPE)
6530 /* For enumeral types, copy the precision from the integer
6531 type returned above. If not an INTEGER_TYPE, we can't use
6532 this mode for this type. */
6533 if (TREE_CODE (typefm) != INTEGER_TYPE)
6535 error ("cannot use mode %qs for enumeral types", p);
6539 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6541 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6546 /* We cannot build a type variant, as there's code that assumes
6547 that TYPE_MAIN_VARIANT has the same mode. This includes the
6548 debug generators. Instead, create a subrange type. This
6549 results in all of the enumeral values being emitted only once
6550 in the original, and the subtype gets them by reference. */
6551 if (TYPE_UNSIGNED (type))
6552 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6554 typefm = make_signed_type (TYPE_PRECISION (typefm));
6555 TREE_TYPE (typefm) = type;
6558 else if (VECTOR_MODE_P (mode)
6559 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6560 : TREE_CODE (type) != TREE_CODE (typefm))
6562 error ("mode %qs applied to inappropriate type", p);
6572 /* Handle a "section" attribute; arguments as in
6573 struct attribute_spec.handler. */
6576 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6577 int ARG_UNUSED (flags), bool *no_add_attrs)
6581 if (targetm.have_named_sections)
6583 user_defined_section_attribute = true;
6585 if ((TREE_CODE (decl) == FUNCTION_DECL
6586 || TREE_CODE (decl) == VAR_DECL)
6587 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6589 if (TREE_CODE (decl) == VAR_DECL
6590 && current_function_decl != NULL_TREE
6591 && !TREE_STATIC (decl))
6593 error ("%Jsection attribute cannot be specified for "
6594 "local variables", decl);
6595 *no_add_attrs = true;
6598 /* The decl may have already been given a section attribute
6599 from a previous declaration. Ensure they match. */
6600 else if (DECL_SECTION_NAME (decl) != NULL_TREE
6601 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6602 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6604 error ("section of %q+D conflicts with previous declaration",
6606 *no_add_attrs = true;
6608 else if (TREE_CODE (decl) == VAR_DECL
6609 && !targetm.have_tls && targetm.emutls.tmpl_section
6610 && DECL_THREAD_LOCAL_P (decl))
6612 error ("section of %q+D cannot be overridden", *node);
6613 *no_add_attrs = true;
6616 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6620 error ("section attribute not allowed for %q+D", *node);
6621 *no_add_attrs = true;
6626 error ("%Jsection attributes are not supported for this target", *node);
6627 *no_add_attrs = true;
6633 /* Handle a "aligned" attribute; arguments as in
6634 struct attribute_spec.handler. */
6637 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6638 int flags, bool *no_add_attrs)
6640 tree decl = NULL_TREE;
6643 tree align_expr = (args ? TREE_VALUE (args)
6644 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
6650 type = &TREE_TYPE (decl);
6651 is_type = TREE_CODE (*node) == TYPE_DECL;
6653 else if (TYPE_P (*node))
6654 type = node, is_type = 1;
6656 if (TREE_CODE (align_expr) != INTEGER_CST)
6658 error ("requested alignment is not a constant");
6659 *no_add_attrs = true;
6661 else if ((i = tree_log2 (align_expr)) == -1)
6663 error ("requested alignment is not a power of 2");
6664 *no_add_attrs = true;
6666 else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
6668 error ("requested alignment is too large");
6669 *no_add_attrs = true;
6673 /* If we have a TYPE_DECL, then copy the type, so that we
6674 don't accidentally modify a builtin type. See pushdecl. */
6675 if (decl && TREE_TYPE (decl) != error_mark_node
6676 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6678 tree tt = TREE_TYPE (decl);
6679 *type = build_variant_type_copy (*type);
6680 DECL_ORIGINAL_TYPE (decl) = tt;
6681 TYPE_NAME (*type) = decl;
6682 TREE_USED (*type) = TREE_USED (decl);
6683 TREE_TYPE (decl) = *type;
6685 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6686 *type = build_variant_type_copy (*type);
6688 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
6689 TYPE_USER_ALIGN (*type) = 1;
6691 else if (! VAR_OR_FUNCTION_DECL_P (decl)
6692 && TREE_CODE (decl) != FIELD_DECL)
6694 error ("alignment may not be specified for %q+D", decl);
6695 *no_add_attrs = true;
6697 else if (TREE_CODE (decl) == FUNCTION_DECL
6698 && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
6700 if (DECL_USER_ALIGN (decl))
6701 error ("alignment for %q+D was previously specified as %d "
6702 "and may not be decreased", decl,
6703 DECL_ALIGN (decl) / BITS_PER_UNIT);
6705 error ("alignment for %q+D must be at least %d", decl,
6706 DECL_ALIGN (decl) / BITS_PER_UNIT);
6707 *no_add_attrs = true;
6711 DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
6712 DECL_USER_ALIGN (decl) = 1;
6718 /* Handle a "weak" attribute; arguments as in
6719 struct attribute_spec.handler. */
6722 handle_weak_attribute (tree *node, tree name,
6723 tree ARG_UNUSED (args),
6724 int ARG_UNUSED (flags),
6725 bool * ARG_UNUSED (no_add_attrs))
6727 if (TREE_CODE (*node) == FUNCTION_DECL
6728 && DECL_DECLARED_INLINE_P (*node))
6730 error ("inline function %q+D cannot be declared weak", *node);
6731 *no_add_attrs = true;
6733 else if (TREE_CODE (*node) == FUNCTION_DECL
6734 || TREE_CODE (*node) == VAR_DECL)
6735 declare_weak (*node);
6737 warning (OPT_Wattributes, "%qE attribute ignored", name);
6742 /* Handle an "alias" attribute; arguments as in
6743 struct attribute_spec.handler. */
6746 handle_alias_attribute (tree *node, tree name, tree args,
6747 int ARG_UNUSED (flags), bool *no_add_attrs)
6751 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6753 warning (OPT_Wattributes, "%qE attribute ignored", name);
6754 *no_add_attrs = true;
6756 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6757 || (TREE_CODE (decl) != FUNCTION_DECL
6758 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6759 /* A static variable declaration is always a tentative definition,
6760 but the alias is a non-tentative definition which overrides. */
6761 || (TREE_CODE (decl) != FUNCTION_DECL
6762 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6764 error ("%q+D defined both normally and as an alias", decl);
6765 *no_add_attrs = true;
6768 /* Note that the very first time we process a nested declaration,
6769 decl_function_context will not be set. Indeed, *would* never
6770 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6771 we do below. After such frobbery, pushdecl would set the context.
6772 In any case, this is never what we want. */
6773 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6777 id = TREE_VALUE (args);
6778 if (TREE_CODE (id) != STRING_CST)
6780 error ("alias argument not a string");
6781 *no_add_attrs = true;
6784 id = get_identifier (TREE_STRING_POINTER (id));
6785 /* This counts as a use of the object pointed to. */
6788 if (TREE_CODE (decl) == FUNCTION_DECL)
6789 DECL_INITIAL (decl) = error_mark_node;
6792 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6793 DECL_EXTERNAL (decl) = 1;
6795 DECL_EXTERNAL (decl) = 0;
6796 TREE_STATIC (decl) = 1;
6801 warning (OPT_Wattributes, "%qE attribute ignored", name);
6802 *no_add_attrs = true;
6808 /* Handle a "weakref" attribute; arguments as in struct
6809 attribute_spec.handler. */
6812 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6813 int flags, bool *no_add_attrs)
6815 tree attr = NULL_TREE;
6817 /* We must ignore the attribute when it is associated with
6818 local-scoped decls, since attribute alias is ignored and many
6819 such symbols do not even have a DECL_WEAK field. */
6820 if (decl_function_context (*node)
6821 || current_function_decl
6822 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6824 warning (OPT_Wattributes, "%qE attribute ignored", name);
6825 *no_add_attrs = true;
6829 /* The idea here is that `weakref("name")' mutates into `weakref,
6830 alias("name")', and weakref without arguments, in turn,
6831 implicitly adds weak. */
6835 attr = tree_cons (get_identifier ("alias"), args, attr);
6836 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6838 *no_add_attrs = true;
6840 decl_attributes (node, attr, flags);
6844 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6845 error ("%Jweakref attribute must appear before alias attribute",
6848 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6849 and that isn't supported; and because it wants to add it to
6850 the list of weak decls, which isn't helpful. */
6851 DECL_WEAK (*node) = 1;
6857 /* Handle an "visibility" attribute; arguments as in
6858 struct attribute_spec.handler. */
6861 handle_visibility_attribute (tree *node, tree name, tree args,
6862 int ARG_UNUSED (flags),
6863 bool *ARG_UNUSED (no_add_attrs))
6866 tree id = TREE_VALUE (args);
6867 enum symbol_visibility vis;
6871 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6873 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6875 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6879 else if (TYPE_FIELDS (*node))
6881 error ("%qE attribute ignored because %qT is already defined",
6886 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6888 warning (OPT_Wattributes, "%qE attribute ignored", name);
6892 if (TREE_CODE (id) != STRING_CST)
6894 error ("visibility argument not a string");
6898 /* If this is a type, set the visibility on the type decl. */
6901 decl = TYPE_NAME (decl);
6904 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6906 warning (OPT_Wattributes, "%qE attribute ignored on types",
6912 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6913 vis = VISIBILITY_DEFAULT;
6914 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6915 vis = VISIBILITY_INTERNAL;
6916 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6917 vis = VISIBILITY_HIDDEN;
6918 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6919 vis = VISIBILITY_PROTECTED;
6922 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6923 vis = VISIBILITY_DEFAULT;
6926 if (DECL_VISIBILITY_SPECIFIED (decl)
6927 && vis != DECL_VISIBILITY (decl))
6929 tree attributes = (TYPE_P (*node)
6930 ? TYPE_ATTRIBUTES (*node)
6931 : DECL_ATTRIBUTES (decl));
6932 if (lookup_attribute ("visibility", attributes))
6933 error ("%qD redeclared with different visibility", decl);
6934 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6935 && lookup_attribute ("dllimport", attributes))
6936 error ("%qD was declared %qs which implies default visibility",
6938 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6939 && lookup_attribute ("dllexport", attributes))
6940 error ("%qD was declared %qs which implies default visibility",
6944 DECL_VISIBILITY (decl) = vis;
6945 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6947 /* Go ahead and attach the attribute to the node as well. This is needed
6948 so we can determine whether we have VISIBILITY_DEFAULT because the
6949 visibility was not specified, or because it was explicitly overridden
6950 from the containing scope. */
6955 /* Determine the ELF symbol visibility for DECL, which is either a
6956 variable or a function. It is an error to use this function if a
6957 definition of DECL is not available in this translation unit.
6958 Returns true if the final visibility has been determined by this
6959 function; false if the caller is free to make additional
6963 c_determine_visibility (tree decl)
6965 gcc_assert (TREE_CODE (decl) == VAR_DECL
6966 || TREE_CODE (decl) == FUNCTION_DECL);
6968 /* If the user explicitly specified the visibility with an
6969 attribute, honor that. DECL_VISIBILITY will have been set during
6970 the processing of the attribute. We check for an explicit
6971 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6972 to distinguish the use of an attribute from the use of a "#pragma
6973 GCC visibility push(...)"; in the latter case we still want other
6974 considerations to be able to overrule the #pragma. */
6975 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6976 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6977 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6978 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6981 /* Set default visibility to whatever the user supplied with
6982 visibility_specified depending on #pragma GCC visibility. */
6983 if (!DECL_VISIBILITY_SPECIFIED (decl))
6985 if (visibility_options.inpragma
6986 || DECL_VISIBILITY (decl) != default_visibility)
6988 DECL_VISIBILITY (decl) = default_visibility;
6989 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6990 /* If visibility changed and DECL already has DECL_RTL, ensure
6991 symbol flags are updated. */
6992 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6993 || TREE_CODE (decl) == FUNCTION_DECL)
6994 && DECL_RTL_SET_P (decl))
6995 make_decl_rtl (decl);
7001 /* Handle an "tls_model" attribute; arguments as in
7002 struct attribute_spec.handler. */
7005 handle_tls_model_attribute (tree *node, tree name, tree args,
7006 int ARG_UNUSED (flags), bool *no_add_attrs)
7010 enum tls_model kind;
7012 *no_add_attrs = true;
7014 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
7016 warning (OPT_Wattributes, "%qE attribute ignored", name);
7020 kind = DECL_TLS_MODEL (decl);
7021 id = TREE_VALUE (args);
7022 if (TREE_CODE (id) != STRING_CST)
7024 error ("tls_model argument not a string");
7028 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7029 kind = TLS_MODEL_LOCAL_EXEC;
7030 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7031 kind = TLS_MODEL_INITIAL_EXEC;
7032 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7033 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7034 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7035 kind = TLS_MODEL_GLOBAL_DYNAMIC;
7037 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7039 DECL_TLS_MODEL (decl) = kind;
7043 /* Handle a "no_instrument_function" attribute; arguments as in
7044 struct attribute_spec.handler. */
7047 handle_no_instrument_function_attribute (tree *node, tree name,
7048 tree ARG_UNUSED (args),
7049 int ARG_UNUSED (flags),
7054 if (TREE_CODE (decl) != FUNCTION_DECL)
7056 error ("%J%qE attribute applies only to functions", decl, name);
7057 *no_add_attrs = true;
7059 else if (DECL_INITIAL (decl))
7061 error ("%Jcan%'t set %qE attribute after definition", decl, name);
7062 *no_add_attrs = true;
7065 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7070 /* Handle a "malloc" attribute; arguments as in
7071 struct attribute_spec.handler. */
7074 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7075 int ARG_UNUSED (flags), bool *no_add_attrs)
7077 if (TREE_CODE (*node) == FUNCTION_DECL
7078 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
7079 DECL_IS_MALLOC (*node) = 1;
7082 warning (OPT_Wattributes, "%qE attribute ignored", name);
7083 *no_add_attrs = true;
7089 /* Handle a "alloc_size" attribute; arguments as in
7090 struct attribute_spec.handler. */
7093 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7094 int ARG_UNUSED (flags), bool *no_add_attrs)
7096 unsigned arg_count = type_num_arguments (*node);
7097 for (; args; args = TREE_CHAIN (args))
7099 tree position = TREE_VALUE (args);
7101 if (TREE_CODE (position) != INTEGER_CST
7102 || TREE_INT_CST_HIGH (position)
7103 || TREE_INT_CST_LOW (position) < 1
7104 || TREE_INT_CST_LOW (position) > arg_count )
7106 warning (OPT_Wattributes,
7107 "alloc_size parameter outside range");
7108 *no_add_attrs = true;
7115 /* Handle a "returns_twice" attribute; arguments as in
7116 struct attribute_spec.handler. */
7119 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7120 int ARG_UNUSED (flags), bool *no_add_attrs)
7122 if (TREE_CODE (*node) == FUNCTION_DECL)
7123 DECL_IS_RETURNS_TWICE (*node) = 1;
7126 warning (OPT_Wattributes, "%qE attribute ignored", name);
7127 *no_add_attrs = true;
7133 /* Handle a "no_limit_stack" attribute; arguments as in
7134 struct attribute_spec.handler. */
7137 handle_no_limit_stack_attribute (tree *node, tree name,
7138 tree ARG_UNUSED (args),
7139 int ARG_UNUSED (flags),
7144 if (TREE_CODE (decl) != FUNCTION_DECL)
7146 error ("%J%qE attribute applies only to functions", decl, name);
7147 *no_add_attrs = true;
7149 else if (DECL_INITIAL (decl))
7151 error ("%Jcan%'t set %qE attribute after definition", decl, name);
7152 *no_add_attrs = true;
7155 DECL_NO_LIMIT_STACK (decl) = 1;
7160 /* Handle a "pure" attribute; arguments as in
7161 struct attribute_spec.handler. */
7164 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7165 int ARG_UNUSED (flags), bool *no_add_attrs)
7167 if (TREE_CODE (*node) == FUNCTION_DECL)
7168 DECL_PURE_P (*node) = 1;
7169 /* ??? TODO: Support types. */
7172 warning (OPT_Wattributes, "%qE attribute ignored", name);
7173 *no_add_attrs = true;
7179 /* Handle a "no vops" attribute; arguments as in
7180 struct attribute_spec.handler. */
7183 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7184 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7185 bool *ARG_UNUSED (no_add_attrs))
7187 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7188 DECL_IS_NOVOPS (*node) = 1;
7192 /* Handle a "deprecated" attribute; arguments as in
7193 struct attribute_spec.handler. */
7196 handle_deprecated_attribute (tree *node, tree name,
7197 tree ARG_UNUSED (args), int flags,
7200 tree type = NULL_TREE;
7202 tree what = NULL_TREE;
7207 type = TREE_TYPE (decl);
7209 if (TREE_CODE (decl) == TYPE_DECL
7210 || TREE_CODE (decl) == PARM_DECL
7211 || TREE_CODE (decl) == VAR_DECL
7212 || TREE_CODE (decl) == FUNCTION_DECL
7213 || TREE_CODE (decl) == FIELD_DECL)
7214 TREE_DEPRECATED (decl) = 1;
7218 else if (TYPE_P (*node))
7220 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
7221 *node = build_variant_type_copy (*node);
7222 TREE_DEPRECATED (*node) = 1;
7230 *no_add_attrs = true;
7231 if (type && TYPE_NAME (type))
7233 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7234 what = TYPE_NAME (*node);
7235 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7236 && DECL_NAME (TYPE_NAME (type)))
7237 what = DECL_NAME (TYPE_NAME (type));
7240 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
7242 warning (OPT_Wattributes, "%qE attribute ignored", name);
7248 /* Handle a "vector_size" attribute; arguments as in
7249 struct attribute_spec.handler. */
7252 handle_vector_size_attribute (tree *node, tree name, tree args,
7253 int ARG_UNUSED (flags),
7256 unsigned HOST_WIDE_INT vecsize, nunits;
7257 enum machine_mode orig_mode;
7258 tree type = *node, new_type, size;
7260 *no_add_attrs = true;
7262 size = TREE_VALUE (args);
7264 if (!host_integerp (size, 1))
7266 warning (OPT_Wattributes, "%qE attribute ignored", name);
7270 /* Get the vector size (in bytes). */
7271 vecsize = tree_low_cst (size, 1);
7273 /* We need to provide for vector pointers, vector arrays, and
7274 functions returning vectors. For example:
7276 __attribute__((vector_size(16))) short *foo;
7278 In this case, the mode is SI, but the type being modified is
7279 HI, so we need to look further. */
7281 while (POINTER_TYPE_P (type)
7282 || TREE_CODE (type) == FUNCTION_TYPE
7283 || TREE_CODE (type) == METHOD_TYPE
7284 || TREE_CODE (type) == ARRAY_TYPE
7285 || TREE_CODE (type) == OFFSET_TYPE)
7286 type = TREE_TYPE (type);
7288 /* Get the mode of the type being modified. */
7289 orig_mode = TYPE_MODE (type);
7291 if ((!INTEGRAL_TYPE_P (type)
7292 && !SCALAR_FLOAT_TYPE_P (type)
7293 && !FIXED_POINT_TYPE_P (type))
7294 || (!SCALAR_FLOAT_MODE_P (orig_mode)
7295 && GET_MODE_CLASS (orig_mode) != MODE_INT
7296 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7297 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7298 || TREE_CODE (type) == BOOLEAN_TYPE)
7300 error ("invalid vector type for attribute %qE", name);
7304 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7306 error ("vector size not an integral multiple of component size");
7312 error ("zero vector size");
7316 /* Calculate how many units fit in the vector. */
7317 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7318 if (nunits & (nunits - 1))
7320 error ("number of components of the vector not a power of two");
7324 new_type = build_vector_type (type, nunits);
7326 /* Build back pointers if needed. */
7327 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
7332 /* Handle the "nonnull" attribute. */
7334 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7335 tree args, int ARG_UNUSED (flags),
7339 unsigned HOST_WIDE_INT attr_arg_num;
7341 /* If no arguments are specified, all pointer arguments should be
7342 non-null. Verify a full prototype is given so that the arguments
7343 will have the correct types when we actually check them later. */
7346 if (!TYPE_ARG_TYPES (type))
7348 error ("nonnull attribute without arguments on a non-prototype");
7349 *no_add_attrs = true;
7354 /* Argument list specified. Verify that each argument number references
7355 a pointer argument. */
7356 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7359 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
7361 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
7363 error ("nonnull argument has invalid operand number (argument %lu)",
7364 (unsigned long) attr_arg_num);
7365 *no_add_attrs = true;
7369 argument = TYPE_ARG_TYPES (type);
7372 for (ck_num = 1; ; ck_num++)
7374 if (!argument || ck_num == arg_num)
7376 argument = TREE_CHAIN (argument);
7380 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7382 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7383 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7384 *no_add_attrs = true;
7388 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
7390 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7391 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7392 *no_add_attrs = true;
7401 /* Check the argument list of a function call for null in argument slots
7402 that are marked as requiring a non-null pointer argument. The NARGS
7403 arguments are passed in the array ARGARRAY.
7407 check_function_nonnull (tree attrs, int nargs, tree *argarray)
7412 for (a = attrs; a; a = TREE_CHAIN (a))
7414 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7416 args = TREE_VALUE (a);
7418 /* Walk the argument list. If we encounter an argument number we
7419 should check for non-null, do it. If the attribute has no args,
7420 then every pointer argument is checked (in which case the check
7421 for pointer type is done in check_nonnull_arg). */
7422 for (i = 0; i < nargs; i++)
7424 if (!args || nonnull_check_p (args, i + 1))
7425 check_function_arguments_recurse (check_nonnull_arg, NULL,
7433 /* Check that the Nth argument of a function call (counting backwards
7434 from the end) is a (pointer)0. The NARGS arguments are passed in the
7438 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
7440 tree attr = lookup_attribute ("sentinel", attrs);
7448 /* Skip over the named arguments. */
7449 while (typelist && len < nargs)
7451 typelist = TREE_CHAIN (typelist);
7455 if (TREE_VALUE (attr))
7457 tree p = TREE_VALUE (TREE_VALUE (attr));
7458 pos = TREE_INT_CST_LOW (p);
7461 /* The sentinel must be one of the varargs, i.e.
7462 in position >= the number of fixed arguments. */
7463 if ((nargs - 1 - pos) < len)
7465 warning (OPT_Wformat,
7466 "not enough variable arguments to fit a sentinel");
7470 /* Validate the sentinel. */
7471 sentinel = argarray[nargs - 1 - pos];
7472 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7473 || !integer_zerop (sentinel))
7474 /* Although __null (in C++) is only an integer we allow it
7475 nevertheless, as we are guaranteed that it's exactly
7476 as wide as a pointer, and we don't want to force
7477 users to cast the NULL they have written there.
7478 We warn with -Wstrict-null-sentinel, though. */
7479 && (warn_strict_null_sentinel || null_node != sentinel))
7480 warning (OPT_Wformat, "missing sentinel in function call");
7484 /* Helper for check_function_nonnull; given a list of operands which
7485 must be non-null in ARGS, determine if operand PARAM_NUM should be
7489 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
7491 unsigned HOST_WIDE_INT arg_num = 0;
7493 for (; args; args = TREE_CHAIN (args))
7495 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7499 if (arg_num == param_num)
7505 /* Check that the function argument PARAM (which is operand number
7506 PARAM_NUM) is non-null. This is called by check_function_nonnull
7507 via check_function_arguments_recurse. */
7510 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
7511 unsigned HOST_WIDE_INT param_num)
7513 /* Just skip checking the argument if it's not a pointer. This can
7514 happen if the "nonnull" attribute was given without an operand
7515 list (which means to check every pointer argument). */
7517 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7520 if (integer_zerop (param))
7521 warning (OPT_Wnonnull, "null argument where non-null required "
7522 "(argument %lu)", (unsigned long) param_num);
7525 /* Helper for nonnull attribute handling; fetch the operand number
7526 from the attribute argument list. */
7529 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
7531 /* Verify the arg number is a constant. */
7532 if (TREE_CODE (arg_num_expr) != INTEGER_CST
7533 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7536 *valp = TREE_INT_CST_LOW (arg_num_expr);
7540 /* Handle a "nothrow" attribute; arguments as in
7541 struct attribute_spec.handler. */
7544 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7545 int ARG_UNUSED (flags), bool *no_add_attrs)
7547 if (TREE_CODE (*node) == FUNCTION_DECL)
7548 TREE_NOTHROW (*node) = 1;
7549 /* ??? TODO: Support types. */
7552 warning (OPT_Wattributes, "%qE attribute ignored", name);
7553 *no_add_attrs = true;
7559 /* Handle a "cleanup" attribute; arguments as in
7560 struct attribute_spec.handler. */
7563 handle_cleanup_attribute (tree *node, tree name, tree args,
7564 int ARG_UNUSED (flags), bool *no_add_attrs)
7567 tree cleanup_id, cleanup_decl;
7569 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7570 for global destructors in C++. This requires infrastructure that
7571 we don't have generically at the moment. It's also not a feature
7572 we'd be missing too much, since we do have attribute constructor. */
7573 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7575 warning (OPT_Wattributes, "%qE attribute ignored", name);
7576 *no_add_attrs = true;
7580 /* Verify that the argument is a function in scope. */
7581 /* ??? We could support pointers to functions here as well, if
7582 that was considered desirable. */
7583 cleanup_id = TREE_VALUE (args);
7584 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7586 error ("cleanup argument not an identifier");
7587 *no_add_attrs = true;
7590 cleanup_decl = lookup_name (cleanup_id);
7591 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7593 error ("cleanup argument not a function");
7594 *no_add_attrs = true;
7598 /* That the function has proper type is checked with the
7599 eventual call to build_function_call. */
7604 /* Handle a "warn_unused_result" attribute. No special handling. */
7607 handle_warn_unused_result_attribute (tree *node, tree name,
7608 tree ARG_UNUSED (args),
7609 int ARG_UNUSED (flags), bool *no_add_attrs)
7611 /* Ignore the attribute for functions not returning any value. */
7612 if (VOID_TYPE_P (TREE_TYPE (*node)))
7614 warning (OPT_Wattributes, "%qE attribute ignored", name);
7615 *no_add_attrs = true;
7621 /* Handle a "sentinel" attribute. */
7624 handle_sentinel_attribute (tree *node, tree name, tree args,
7625 int ARG_UNUSED (flags), bool *no_add_attrs)
7627 tree params = TYPE_ARG_TYPES (*node);
7631 warning (OPT_Wattributes,
7632 "%qE attribute requires prototypes with named arguments", name);
7633 *no_add_attrs = true;
7637 while (TREE_CHAIN (params))
7638 params = TREE_CHAIN (params);
7640 if (VOID_TYPE_P (TREE_VALUE (params)))
7642 warning (OPT_Wattributes,
7643 "%qE attribute only applies to variadic functions", name);
7644 *no_add_attrs = true;
7650 tree position = TREE_VALUE (args);
7652 if (TREE_CODE (position) != INTEGER_CST)
7654 warning (OPT_Wattributes,
7655 "requested position is not an integer constant");
7656 *no_add_attrs = true;
7660 if (tree_int_cst_lt (position, integer_zero_node))
7662 warning (OPT_Wattributes,
7663 "requested position is less than zero");
7664 *no_add_attrs = true;
7672 /* Handle a "type_generic" attribute. */
7675 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7676 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7677 bool * ARG_UNUSED (no_add_attrs))
7681 /* Ensure we have a function type. */
7682 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
7684 params = TYPE_ARG_TYPES (*node);
7685 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7686 params = TREE_CHAIN (params);
7688 /* Ensure we have a variadic function. */
7689 gcc_assert (!params);
7694 /* Handle a "target" attribute. */
7697 handle_target_attribute (tree *node, tree name, tree args, int flags,
7700 /* Ensure we have a function type. */
7701 if (TREE_CODE (*node) != FUNCTION_DECL)
7703 warning (OPT_Wattributes, "%qE attribute ignored", name);
7704 *no_add_attrs = true;
7706 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7708 *no_add_attrs = true;
7713 /* Arguments being collected for optimization. */
7714 typedef const char *const_char_p; /* For DEF_VEC_P. */
7715 DEF_VEC_P(const_char_p);
7716 DEF_VEC_ALLOC_P(const_char_p, gc);
7717 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7720 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7721 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7722 false for #pragma GCC optimize. */
7725 parse_optimize_options (tree args, bool attr_p)
7730 int saved_flag_strict_aliasing;
7731 const char **opt_argv;
7734 /* Build up argv vector. Just in case the string is stored away, use garbage
7735 collected strings. */
7736 VEC_truncate (const_char_p, optimize_args, 0);
7737 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7739 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7741 tree value = TREE_VALUE (ap);
7743 if (TREE_CODE (value) == INTEGER_CST)
7746 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7747 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7750 else if (TREE_CODE (value) == STRING_CST)
7752 /* Split string into multiple substrings. */
7753 size_t len = TREE_STRING_LENGTH (value);
7754 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7755 char *end = p + len;
7759 while (next_p != NULL)
7765 comma = strchr (p, ',');
7778 r = q = (char *) ggc_alloc (len2 + 3);
7780 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7782 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7786 warning (OPT_Wattributes,
7787 "Bad option %s to optimize attribute.", p);
7789 warning (OPT_Wpragmas,
7790 "Bad option %s to pragma attribute", p);
7798 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7799 itself is -Os, and any other switch begins with a -f. */
7800 if ((*p >= '0' && *p <= '9')
7801 || (p[0] == 's' && p[1] == '\0'))
7807 memcpy (r, p, len2);
7809 VEC_safe_push (const_char_p, gc, optimize_args, q);
7815 opt_argc = VEC_length (const_char_p, optimize_args);
7816 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7818 for (i = 1; i < opt_argc; i++)
7819 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7821 saved_flag_strict_aliasing = flag_strict_aliasing;
7823 /* Now parse the options. */
7824 decode_options (opt_argc, opt_argv);
7826 /* Don't allow changing -fstrict-aliasing. */
7827 flag_strict_aliasing = saved_flag_strict_aliasing;
7829 VEC_truncate (const_char_p, optimize_args, 0);
7833 /* For handling "optimize" attribute. arguments as in
7834 struct attribute_spec.handler. */
7837 handle_optimize_attribute (tree *node, tree name, tree args,
7838 int ARG_UNUSED (flags), bool *no_add_attrs)
7840 /* Ensure we have a function type. */
7841 if (TREE_CODE (*node) != FUNCTION_DECL)
7843 warning (OPT_Wattributes, "%qE attribute ignored", name);
7844 *no_add_attrs = true;
7848 struct cl_optimization cur_opts;
7849 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7851 /* Save current options. */
7852 cl_optimization_save (&cur_opts);
7854 /* If we previously had some optimization options, use them as the
7857 cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7859 /* Parse options, and update the vector. */
7860 parse_optimize_options (args, true);
7861 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7862 = build_optimization_node ();
7864 /* Restore current options. */
7865 cl_optimization_restore (&cur_opts);
7871 /* Check for valid arguments being passed to a function.
7872 ATTRS is a list of attributes. There are NARGS arguments in the array
7873 ARGARRAY. TYPELIST is the list of argument types for the function.
7876 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7878 /* Check for null being passed in a pointer argument that must be
7879 non-null. We also need to do this if format checking is enabled. */
7882 check_function_nonnull (attrs, nargs, argarray);
7884 /* Check for errors in format strings. */
7886 if (warn_format || warn_missing_format_attribute)
7887 check_function_format (attrs, nargs, argarray);
7890 check_function_sentinel (attrs, nargs, argarray, typelist);
7893 /* Generic argument checking recursion routine. PARAM is the argument to
7894 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7895 once the argument is resolved. CTX is context for the callback. */
7897 check_function_arguments_recurse (void (*callback)
7898 (void *, tree, unsigned HOST_WIDE_INT),
7899 void *ctx, tree param,
7900 unsigned HOST_WIDE_INT param_num)
7902 if (CONVERT_EXPR_P (param)
7903 && (TYPE_PRECISION (TREE_TYPE (param))
7904 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7906 /* Strip coercion. */
7907 check_function_arguments_recurse (callback, ctx,
7908 TREE_OPERAND (param, 0), param_num);
7912 if (TREE_CODE (param) == CALL_EXPR)
7914 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7916 bool found_format_arg = false;
7918 /* See if this is a call to a known internationalization function
7919 that modifies a format arg. Such a function may have multiple
7920 format_arg attributes (for example, ngettext). */
7922 for (attrs = TYPE_ATTRIBUTES (type);
7924 attrs = TREE_CHAIN (attrs))
7925 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7928 tree format_num_expr;
7931 call_expr_arg_iterator iter;
7933 /* Extract the argument number, which was previously checked
7935 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7937 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7938 && !TREE_INT_CST_HIGH (format_num_expr));
7940 format_num = TREE_INT_CST_LOW (format_num_expr);
7942 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7944 inner_arg = next_call_expr_arg (&iter), i++)
7945 if (i == format_num)
7947 check_function_arguments_recurse (callback, ctx,
7948 inner_arg, param_num);
7949 found_format_arg = true;
7954 /* If we found a format_arg attribute and did a recursive check,
7955 we are done with checking this argument. Otherwise, we continue
7956 and this will be considered a non-literal. */
7957 if (found_format_arg)
7961 if (TREE_CODE (param) == COND_EXPR)
7963 /* Check both halves of the conditional expression. */
7964 check_function_arguments_recurse (callback, ctx,
7965 TREE_OPERAND (param, 1), param_num);
7966 check_function_arguments_recurse (callback, ctx,
7967 TREE_OPERAND (param, 2), param_num);
7971 (*callback) (ctx, param, param_num);
7974 /* Checks the number of arguments NARGS against the required number
7975 REQUIRED and issues an error if there is a mismatch. Returns true
7976 if the number of arguments is correct, otherwise false. */
7979 validate_nargs (tree fndecl, int nargs, int required)
7981 if (nargs < required)
7983 error ("not enough arguments to function %qE", fndecl);
7986 else if (nargs > required)
7988 error ("too many arguments to function %qE", fndecl);
7994 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7995 Returns false if there was an error, otherwise true. */
7998 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
8000 if (!DECL_BUILT_IN (fndecl)
8001 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
8004 switch (DECL_FUNCTION_CODE (fndecl))
8006 case BUILT_IN_CONSTANT_P:
8007 return validate_nargs (fndecl, nargs, 1);
8009 case BUILT_IN_ISFINITE:
8010 case BUILT_IN_ISINF:
8011 case BUILT_IN_ISINF_SIGN:
8012 case BUILT_IN_ISNAN:
8013 case BUILT_IN_ISNORMAL:
8014 if (validate_nargs (fndecl, nargs, 1))
8016 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8018 error ("non-floating-point argument in call to "
8019 "function %qE", fndecl);
8026 case BUILT_IN_ISGREATER:
8027 case BUILT_IN_ISGREATEREQUAL:
8028 case BUILT_IN_ISLESS:
8029 case BUILT_IN_ISLESSEQUAL:
8030 case BUILT_IN_ISLESSGREATER:
8031 case BUILT_IN_ISUNORDERED:
8032 if (validate_nargs (fndecl, nargs, 2))
8034 enum tree_code code0, code1;
8035 code0 = TREE_CODE (TREE_TYPE (args[0]));
8036 code1 = TREE_CODE (TREE_TYPE (args[1]));
8037 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8038 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8039 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8041 error ("non-floating-point arguments in call to "
8042 "function %qE", fndecl);
8049 case BUILT_IN_FPCLASSIFY:
8050 if (validate_nargs (fndecl, nargs, 6))
8055 if (TREE_CODE (args[i]) != INTEGER_CST)
8057 error ("non-const integer argument %u in call to function %qE",
8062 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8064 error ("non-floating-point argument in call to function %qE",
8077 /* Function to help qsort sort FIELD_DECLs by name order. */
8080 field_decl_cmp (const void *x_p, const void *y_p)
8082 const tree *const x = (const tree *const) x_p;
8083 const tree *const y = (const tree *const) y_p;
8085 if (DECL_NAME (*x) == DECL_NAME (*y))
8086 /* A nontype is "greater" than a type. */
8087 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8088 if (DECL_NAME (*x) == NULL_TREE)
8090 if (DECL_NAME (*y) == NULL_TREE)
8092 if (DECL_NAME (*x) < DECL_NAME (*y))
8098 gt_pointer_operator new_value;
8102 /* This routine compares two fields like field_decl_cmp but using the
8103 pointer operator in resort_data. */
8106 resort_field_decl_cmp (const void *x_p, const void *y_p)
8108 const tree *const x = (const tree *const) x_p;
8109 const tree *const y = (const tree *const) y_p;
8111 if (DECL_NAME (*x) == DECL_NAME (*y))
8112 /* A nontype is "greater" than a type. */
8113 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8114 if (DECL_NAME (*x) == NULL_TREE)
8116 if (DECL_NAME (*y) == NULL_TREE)
8119 tree d1 = DECL_NAME (*x);
8120 tree d2 = DECL_NAME (*y);
8121 resort_data.new_value (&d1, resort_data.cookie);
8122 resort_data.new_value (&d2, resort_data.cookie);
8129 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8132 resort_sorted_fields (void *obj,
8133 void * ARG_UNUSED (orig_obj),
8134 gt_pointer_operator new_value,
8137 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
8138 resort_data.new_value = new_value;
8139 resort_data.cookie = cookie;
8140 qsort (&sf->elts[0], sf->len, sizeof (tree),
8141 resort_field_decl_cmp);
8144 /* Subroutine of c_parse_error.
8145 Return the result of concatenating LHS and RHS. RHS is really
8146 a string literal, its first character is indicated by RHS_START and
8147 RHS_SIZE is its length (including the terminating NUL character).
8149 The caller is responsible for deleting the returned pointer. */
8152 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8154 const int lhs_size = strlen (lhs);
8155 char *result = XNEWVEC (char, lhs_size + rhs_size);
8156 strncpy (result, lhs, lhs_size);
8157 strncpy (result + lhs_size, rhs_start, rhs_size);
8161 /* Issue the error given by GMSGID, indicating that it occurred before
8162 TOKEN, which had the associated VALUE. */
8165 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
8167 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8169 char *message = NULL;
8171 if (token == CPP_EOF)
8172 message = catenate_messages (gmsgid, " at end of input");
8173 else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
8174 || token == CPP_CHAR32)
8176 unsigned int val = TREE_INT_CST_LOW (value);
8195 if (val <= UCHAR_MAX && ISGRAPH (val))
8196 message = catenate_messages (gmsgid, " before %s'%c'");
8198 message = catenate_messages (gmsgid, " before %s'\\x%x'");
8200 error (message, prefix, val);
8204 else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
8205 || token == CPP_STRING32)
8206 message = catenate_messages (gmsgid, " before string constant");
8207 else if (token == CPP_NUMBER)
8208 message = catenate_messages (gmsgid, " before numeric constant");
8209 else if (token == CPP_NAME)
8211 message = catenate_messages (gmsgid, " before %qE");
8212 error (message, value);
8216 else if (token == CPP_PRAGMA)
8217 message = catenate_messages (gmsgid, " before %<#pragma%>");
8218 else if (token == CPP_PRAGMA_EOL)
8219 message = catenate_messages (gmsgid, " before end of line");
8220 else if (token < N_TTYPES)
8222 message = catenate_messages (gmsgid, " before %qs token");
8223 error (message, cpp_type2name (token));
8235 #undef catenate_messages
8238 /* Callback from cpp_error for PFILE to print diagnostics from the
8239 preprocessor. The diagnostic is of type LEVEL, at location
8240 LOCATION unless this is after lexing and the compiler's location
8241 should be used instead, with column number possibly overridden by
8242 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8243 the arguments. Returns true if a diagnostic was emitted, false
8247 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
8248 location_t location, unsigned int column_override,
8249 const char *msg, va_list *ap)
8251 diagnostic_info diagnostic;
8252 diagnostic_t dlevel;
8253 int save_warn_system_headers = warn_system_headers;
8258 case CPP_DL_WARNING_SYSHDR:
8261 warn_system_headers = 1;
8263 case CPP_DL_WARNING:
8266 dlevel = DK_WARNING;
8268 case CPP_DL_PEDWARN:
8269 if (flag_no_output && !flag_pedantic_errors)
8271 dlevel = DK_PEDWARN;
8289 location = input_location;
8290 diagnostic_set_info_translated (&diagnostic, msg, ap,
8292 if (column_override)
8293 diagnostic_override_column (&diagnostic, column_override);
8294 ret = report_diagnostic (&diagnostic);
8295 if (level == CPP_DL_WARNING_SYSHDR)
8296 warn_system_headers = save_warn_system_headers;
8300 /* Walk a gimplified function and warn for functions whose return value is
8301 ignored and attribute((warn_unused_result)) is set. This is done before
8302 inlining, so we don't have to worry about that. */
8305 c_warn_unused_result (gimple_seq seq)
8308 gimple_stmt_iterator i;
8310 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
8312 gimple g = gsi_stmt (i);
8314 switch (gimple_code (g))
8317 c_warn_unused_result (gimple_bind_body (g));
8320 c_warn_unused_result (gimple_try_eval (g));
8321 c_warn_unused_result (gimple_try_cleanup (g));
8324 c_warn_unused_result (gimple_catch_handler (g));
8326 case GIMPLE_EH_FILTER:
8327 c_warn_unused_result (gimple_eh_filter_failure (g));
8331 if (gimple_call_lhs (g))
8334 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8335 LHS. All calls whose value is ignored should be
8336 represented like this. Look for the attribute. */
8337 fdecl = gimple_call_fndecl (g);
8338 ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
8340 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
8342 location_t loc = gimple_location (g);
8345 warning (0, "%Hignoring return value of %qD, "
8346 "declared with attribute warn_unused_result",
8349 warning (0, "%Hignoring return value of function "
8350 "declared with attribute warn_unused_result",
8356 /* Not a container, not a call, or a call whose value is used. */
8362 /* Convert a character from the host to the target execution character
8363 set. cpplib handles this, mostly. */
8366 c_common_to_target_charset (HOST_WIDE_INT c)
8368 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8369 zero-extended under -fno-signed-char. cpplib insists that characters
8370 and character constants are always unsigned. Hence we must convert
8372 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8374 uc = cpp_host_to_exec_charset (parse_in, uc);
8376 if (flag_signed_char)
8377 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8378 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8383 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8384 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8385 NULL, at the bottom; much like the traditional rendering of offsetof as a
8386 macro. Returns the folded and properly cast result. */
8389 fold_offsetof_1 (tree expr, tree stop_ref)
8391 enum tree_code code = PLUS_EXPR;
8394 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8395 return size_zero_node;
8397 switch (TREE_CODE (expr))
8403 error ("cannot apply %<offsetof%> to static data member %qD", expr);
8404 return error_mark_node;
8408 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8409 return error_mark_node;
8412 gcc_assert (integer_zerop (expr));
8413 return size_zero_node;
8417 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8418 gcc_assert (base == error_mark_node || base == size_zero_node);
8422 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8423 if (base == error_mark_node)
8426 t = TREE_OPERAND (expr, 1);
8427 if (DECL_C_BIT_FIELD (t))
8429 error ("attempt to take address of bit-field structure "
8431 return error_mark_node;
8433 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
8434 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
8439 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8440 if (base == error_mark_node)
8443 t = TREE_OPERAND (expr, 1);
8444 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8447 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
8449 t = convert (sizetype, t);
8450 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8454 /* Handle static members of volatile structs. */
8455 t = TREE_OPERAND (expr, 1);
8456 gcc_assert (TREE_CODE (t) == VAR_DECL);
8457 return fold_offsetof_1 (t, stop_ref);
8463 return size_binop (code, base, off);
8467 fold_offsetof (tree expr, tree stop_ref)
8469 /* Convert back from the internal sizetype to size_t. */
8470 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
8473 /* Print an error message for an invalid lvalue. USE says
8474 how the lvalue is being used and so selects the error message. */
8477 lvalue_error (enum lvalue_use use)
8482 error ("lvalue required as left operand of assignment");
8485 error ("lvalue required as increment operand");
8488 error ("lvalue required as decrement operand");
8491 error ("lvalue required as unary %<&%> operand");
8494 error ("lvalue required in asm statement");
8501 /* *PTYPE is an incomplete array. Complete it with a domain based on
8502 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8503 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8504 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8507 complete_array_type (tree *ptype, tree initial_value, bool do_default)
8509 tree maxindex, type, main_type, elt, unqual_elt;
8510 int failure = 0, quals;
8511 hashval_t hashcode = 0;
8513 maxindex = size_zero_node;
8516 if (TREE_CODE (initial_value) == STRING_CST)
8519 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8520 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8522 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8524 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
8526 if (VEC_empty (constructor_elt, v))
8530 maxindex = integer_minus_one_node;
8535 unsigned HOST_WIDE_INT cnt;
8536 constructor_elt *ce;
8537 bool fold_p = false;
8539 if (VEC_index (constructor_elt, v, 0)->index)
8540 maxindex = fold_convert (sizetype,
8541 VEC_index (constructor_elt,
8543 curindex = maxindex;
8546 VEC_iterate (constructor_elt, v, cnt, ce);
8549 bool curfold_p = false;
8551 curindex = ce->index, curfold_p = true;
8555 curindex = fold_convert (sizetype, curindex);
8556 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
8558 if (tree_int_cst_lt (maxindex, curindex))
8559 maxindex = curindex, fold_p = curfold_p;
8562 maxindex = fold_convert (sizetype, maxindex);
8567 /* Make an error message unless that happened already. */
8568 if (initial_value != error_mark_node)
8580 elt = TREE_TYPE (type);
8581 quals = TYPE_QUALS (strip_array_types (elt));
8585 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
8587 /* Using build_distinct_type_copy and modifying things afterward instead
8588 of using build_array_type to create a new type preserves all of the
8589 TYPE_LANG_FLAG_? bits that the front end may have set. */
8590 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8591 TREE_TYPE (main_type) = unqual_elt;
8592 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8593 layout_type (main_type);
8595 /* Make sure we have the canonical MAIN_TYPE. */
8596 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
8597 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
8599 main_type = type_hash_canon (hashcode, main_type);
8601 /* Fix the canonical type. */
8602 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8603 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8604 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8605 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8606 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8607 != TYPE_DOMAIN (main_type)))
8608 TYPE_CANONICAL (main_type)
8609 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8610 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8612 TYPE_CANONICAL (main_type) = main_type;
8617 type = c_build_qualified_type (main_type, quals);
8619 if (COMPLETE_TYPE_P (type)
8620 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8621 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8623 error ("size of array is too large");
8624 /* If we proceed with the array type as it is, we'll eventually
8625 crash in tree_low_cst(). */
8626 type = error_mark_node;
8634 /* Used to help initialize the builtin-types.def table. When a type of
8635 the correct size doesn't exist, use error_mark_node instead of NULL.
8636 The later results in segfaults even when a decl using the type doesn't
8640 builtin_type_for_size (int size, bool unsignedp)
8642 tree type = lang_hooks.types.type_for_size (size, unsignedp);
8643 return type ? type : error_mark_node;
8646 /* A helper function for resolve_overloaded_builtin in resolving the
8647 overloaded __sync_ builtins. Returns a positive power of 2 if the
8648 first operand of PARAMS is a pointer to a supported data type.
8649 Returns 0 if an error is encountered. */
8652 sync_resolve_size (tree function, VEC(tree,gc) *params)
8657 if (VEC_empty (tree, params))
8659 error ("too few arguments to function %qE", function);
8663 type = TREE_TYPE (VEC_index (tree, params, 0));
8664 if (TREE_CODE (type) != POINTER_TYPE)
8667 type = TREE_TYPE (type);
8668 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8671 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
8672 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
8676 error ("incompatible type for argument %d of %qE", 1, function);
8680 /* A helper function for resolve_overloaded_builtin. Adds casts to
8681 PARAMS to make arguments match up with those of FUNCTION. Drops
8682 the variadic arguments at the end. Returns false if some error
8683 was encountered; true on success. */
8686 sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
8688 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8691 unsigned int parmnum;
8693 /* We've declared the implementation functions to use "volatile void *"
8694 as the pointer parameter, so we shouldn't get any complaints from the
8695 call to check_function_arguments what ever type the user used. */
8696 arg_types = TREE_CHAIN (arg_types);
8697 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
8700 /* For the rest of the values, we need to cast these to FTYPE, so that we
8701 don't get warnings for passing pointer types, etc. */
8703 while (arg_types != void_list_node)
8708 if (VEC_length (tree, params) <= parmnum)
8710 error ("too few arguments to function %qE", orig_function);
8714 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8715 so that we get warnings for anything that doesn't match the pointer
8716 type. This isn't portable across the C and C++ front ends atm. */
8717 val = VEC_index (tree, params, parmnum);
8718 val = convert (ptype, val);
8719 val = convert (TREE_VALUE (arg_types), val);
8720 VEC_replace (tree, params, parmnum, val);
8722 arg_types = TREE_CHAIN (arg_types);
8726 /* The definition of these primitives is variadic, with the remaining
8727 being "an optional list of variables protected by the memory barrier".
8728 No clue what that's supposed to mean, precisely, but we consider all
8729 call-clobbered variables to be protected so we're safe. */
8730 VEC_truncate (tree, params, parmnum + 1);
8735 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8736 RESULT to make it match the type of the first pointer argument in
8740 sync_resolve_return (tree first_param, tree result)
8742 tree ptype = TREE_TYPE (TREE_TYPE (first_param));
8743 ptype = TYPE_MAIN_VARIANT (ptype);
8744 return convert (ptype, result);
8747 /* Some builtin functions are placeholders for other expressions. This
8748 function should be called immediately after parsing the call expression
8749 before surrounding code has committed to the type of the expression.
8751 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8752 PARAMS is the argument list for the call. The return value is non-null
8753 when expansion is complete, and null if normal processing should
8757 resolve_overloaded_builtin (tree function, VEC(tree,gc) *params)
8759 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8760 switch (DECL_BUILT_IN_CLASS (function))
8762 case BUILT_IN_NORMAL:
8765 if (targetm.resolve_overloaded_builtin)
8766 return targetm.resolve_overloaded_builtin (function, params);
8773 /* Handle BUILT_IN_NORMAL here. */
8776 case BUILT_IN_FETCH_AND_ADD_N:
8777 case BUILT_IN_FETCH_AND_SUB_N:
8778 case BUILT_IN_FETCH_AND_OR_N:
8779 case BUILT_IN_FETCH_AND_AND_N:
8780 case BUILT_IN_FETCH_AND_XOR_N:
8781 case BUILT_IN_FETCH_AND_NAND_N:
8782 case BUILT_IN_ADD_AND_FETCH_N:
8783 case BUILT_IN_SUB_AND_FETCH_N:
8784 case BUILT_IN_OR_AND_FETCH_N:
8785 case BUILT_IN_AND_AND_FETCH_N:
8786 case BUILT_IN_XOR_AND_FETCH_N:
8787 case BUILT_IN_NAND_AND_FETCH_N:
8788 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8789 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8790 case BUILT_IN_LOCK_TEST_AND_SET_N:
8791 case BUILT_IN_LOCK_RELEASE_N:
8793 int n = sync_resolve_size (function, params);
8794 tree new_function, first_param, result;
8797 return error_mark_node;
8799 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8800 if (!sync_resolve_params (function, new_function, params))
8801 return error_mark_node;
8803 first_param = VEC_index (tree, params, 0);
8804 result = build_function_call_vec (new_function, params, NULL);
8805 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8806 && orig_code != BUILT_IN_LOCK_RELEASE_N)
8807 result = sync_resolve_return (first_param, result);
8817 /* Ignoring their sign, return true if two scalar types are the same. */
8819 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8821 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8823 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8824 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8825 || c2 == FIXED_POINT_TYPE));
8827 /* Equality works here because c_common_signed_type uses
8828 TYPE_MAIN_VARIANT. */
8829 return c_common_signed_type (t1)
8830 == c_common_signed_type (t2);
8833 /* Check for missing format attributes on function pointers. LTYPE is
8834 the new type or left-hand side type. RTYPE is the old type or
8835 right-hand side type. Returns TRUE if LTYPE is missing the desired
8839 check_missing_format_attribute (tree ltype, tree rtype)
8841 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8844 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8845 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8850 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8851 if (is_attribute_p ("format", TREE_PURPOSE (la)))
8859 /* Subscripting with type char is likely to lose on a machine where
8860 chars are signed. So warn on any machine, but optionally. Don't
8861 warn for unsigned char since that type is safe. Don't warn for
8862 signed char because anyone who uses that must have done so
8863 deliberately. Furthermore, we reduce the false positive load by
8864 warning only for non-constant value of type char. */
8867 warn_array_subscript_with_type_char (tree index)
8869 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8870 && TREE_CODE (index) != INTEGER_CST)
8871 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8874 /* Implement -Wparentheses for the unexpected C precedence rules, to
8875 cover cases like x + y << z which readers are likely to
8876 misinterpret. We have seen an expression in which CODE is a binary
8877 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8878 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8879 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8880 expression was not formed using a binary or unary operator, or it
8881 was enclosed in parentheses. */
8884 warn_about_parentheses (enum tree_code code,
8885 enum tree_code code_left, tree arg_left,
8886 enum tree_code code_right, tree arg_right)
8888 if (!warn_parentheses)
8891 /* This macro tests that the expression ARG with original tree code
8892 CODE appears to be a boolean expression. or the result of folding a
8893 boolean expression. */
8894 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8895 (truth_value_p (TREE_CODE (ARG)) \
8896 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8897 /* Folding may create 0 or 1 integers from other expressions. */ \
8898 || ((CODE) != INTEGER_CST \
8899 && (integer_onep (ARG) || integer_zerop (ARG))))
8904 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8905 warning (OPT_Wparentheses,
8906 "suggest parentheses around %<+%> inside %<<<%>");
8907 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8908 warning (OPT_Wparentheses,
8909 "suggest parentheses around %<-%> inside %<<<%>");
8913 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8914 warning (OPT_Wparentheses,
8915 "suggest parentheses around %<+%> inside %<>>%>");
8916 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8917 warning (OPT_Wparentheses,
8918 "suggest parentheses around %<-%> inside %<>>%>");
8921 case TRUTH_ORIF_EXPR:
8922 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8923 warning (OPT_Wparentheses,
8924 "suggest parentheses around %<&&%> within %<||%>");
8928 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8929 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8930 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8931 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8932 warning (OPT_Wparentheses,
8933 "suggest parentheses around arithmetic in operand of %<|%>");
8934 /* Check cases like x|y==z */
8935 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8936 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8937 warning (OPT_Wparentheses,
8938 "suggest parentheses around comparison in operand of %<|%>");
8939 /* Check cases like !x | y */
8940 else if (code_left == TRUTH_NOT_EXPR
8941 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8942 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8943 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8947 if (code_left == BIT_AND_EXPR
8948 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8949 || code_right == BIT_AND_EXPR
8950 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8951 warning (OPT_Wparentheses,
8952 "suggest parentheses around arithmetic in operand of %<^%>");
8953 /* Check cases like x^y==z */
8954 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8955 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8956 warning (OPT_Wparentheses,
8957 "suggest parentheses around comparison in operand of %<^%>");
8961 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8962 warning (OPT_Wparentheses,
8963 "suggest parentheses around %<+%> in operand of %<&%>");
8964 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8965 warning (OPT_Wparentheses,
8966 "suggest parentheses around %<-%> in operand of %<&%>");
8967 /* Check cases like x&y==z */
8968 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8969 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8970 warning (OPT_Wparentheses,
8971 "suggest parentheses around comparison in operand of %<&%>");
8972 /* Check cases like !x & y */
8973 else if (code_left == TRUTH_NOT_EXPR
8974 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8975 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8976 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8980 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8981 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8982 warning (OPT_Wparentheses,
8983 "suggest parentheses around comparison in operand of %<==%>");
8986 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8987 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8988 warning (OPT_Wparentheses,
8989 "suggest parentheses around comparison in operand of %<!=%>");
8993 if (TREE_CODE_CLASS (code) == tcc_comparison
8994 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
8995 && code_left != NE_EXPR && code_left != EQ_EXPR
8996 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
8997 || (TREE_CODE_CLASS (code_right) == tcc_comparison
8998 && code_right != NE_EXPR && code_right != EQ_EXPR
8999 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
9000 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
9001 "have their mathematical meaning");
9004 #undef NOT_A_BOOLEAN_EXPR_P
9007 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
9010 warn_for_unused_label (tree label)
9012 if (!TREE_USED (label))
9014 if (DECL_INITIAL (label))
9015 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9017 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9021 #ifndef TARGET_HAS_TARGETCM
9022 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
9025 /* Warn for division by zero according to the value of DIVISOR. LOC
9026 is the location of the division operator. */
9029 warn_for_div_by_zero (location_t loc, tree divisor)
9031 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9032 about division by zero. Do not issue a warning if DIVISOR has a
9033 floating-point type, since we consider 0.0/0.0 a valid way of
9034 generating a NaN. */
9035 if (skip_evaluation == 0
9036 && (integer_zerop (divisor) || fixed_zerop (divisor)))
9037 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
9040 /* Subroutine of build_binary_op. Give warnings for comparisons
9041 between signed and unsigned quantities that may fail. Do the
9042 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9043 so that casts will be considered, but default promotions won't
9046 LOCATION is the location of the comparison operator.
9048 The arguments of this function map directly to local variables
9049 of build_binary_op. */
9052 warn_for_sign_compare (location_t location,
9053 tree orig_op0, tree orig_op1,
9055 tree result_type, enum tree_code resultcode)
9057 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9058 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9059 int unsignedp0, unsignedp1;
9061 /* In C++, check for comparison of different enum types. */
9063 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9064 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9065 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
9066 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
9068 warning_at (location,
9069 OPT_Wsign_compare, "comparison between types %qT and %qT",
9070 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
9073 /* Do not warn if the comparison is being done in a signed type,
9074 since the signed type will only be chosen if it can represent
9075 all the values of the unsigned type. */
9076 if (!TYPE_UNSIGNED (result_type))
9078 /* Do not warn if both operands are unsigned. */
9079 else if (op0_signed == op1_signed)
9083 tree sop, uop, base_type;
9087 sop = orig_op0, uop = orig_op1;
9089 sop = orig_op1, uop = orig_op0;
9091 STRIP_TYPE_NOPS (sop);
9092 STRIP_TYPE_NOPS (uop);
9093 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9094 ? TREE_TYPE (result_type) : result_type);
9096 /* Do not warn if the signed quantity is an unsuffixed integer
9097 literal (or some static constant expression involving such
9098 literals or a conditional expression involving such literals)
9099 and it is non-negative. */
9100 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9102 /* Do not warn if the comparison is an equality operation, the
9103 unsigned quantity is an integral constant, and it would fit
9104 in the result if the result were signed. */
9105 else if (TREE_CODE (uop) == INTEGER_CST
9106 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
9107 && int_fits_type_p (uop, c_common_signed_type (base_type)))
9109 /* In C, do not warn if the unsigned quantity is an enumeration
9110 constant and its maximum value would fit in the result if the
9111 result were signed. */
9112 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9113 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9114 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
9115 c_common_signed_type (base_type)))
9118 warning_at (location,
9120 "comparison between signed and unsigned integer expressions");
9123 /* Warn if two unsigned values are being compared in a size larger
9124 than their original size, and one (and only one) is the result of
9125 a `~' operator. This comparison will always fail.
9127 Also warn if one operand is a constant, and the constant does not
9128 have all bits set that are set in the ~ operand when it is
9131 op0 = get_narrower (op0, &unsignedp0);
9132 op1 = get_narrower (op1, &unsignedp1);
9134 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9135 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9137 if (TREE_CODE (op0) == BIT_NOT_EXPR)
9138 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9139 if (TREE_CODE (op1) == BIT_NOT_EXPR)
9140 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9142 if (host_integerp (op0, 0) || host_integerp (op1, 0))
9145 HOST_WIDE_INT constant, mask;
9149 if (host_integerp (op0, 0))
9152 unsignedp = unsignedp1;
9153 constant = tree_low_cst (op0, 0);
9158 unsignedp = unsignedp0;
9159 constant = tree_low_cst (op1, 0);
9162 bits = TYPE_PRECISION (TREE_TYPE (primop));
9163 if (bits < TYPE_PRECISION (result_type)
9164 && bits < HOST_BITS_PER_LONG && unsignedp)
9166 mask = (~ (HOST_WIDE_INT) 0) << bits;
9167 if ((mask & constant) != mask)
9170 warning (OPT_Wsign_compare,
9171 "promoted ~unsigned is always non-zero");
9173 warning_at (location, OPT_Wsign_compare,
9174 "comparison of promoted ~unsigned with constant");
9178 else if (unsignedp0 && unsignedp1
9179 && (TYPE_PRECISION (TREE_TYPE (op0))
9180 < TYPE_PRECISION (result_type))
9181 && (TYPE_PRECISION (TREE_TYPE (op1))
9182 < TYPE_PRECISION (result_type)))
9183 warning_at (location, OPT_Wsign_compare,
9184 "comparison of promoted ~unsigned with unsigned");
9188 /* Setup a TYPE_DECL node as a typedef representation.
9190 X is a TYPE_DECL for a typedef statement. Create a brand new
9191 ..._TYPE node (which will be just a variant of the existing
9192 ..._TYPE node with identical properties) and then install X
9193 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9195 The whole point here is to end up with a situation where each
9196 and every ..._TYPE node the compiler creates will be uniquely
9197 associated with AT MOST one node representing a typedef name.
9198 This way, even though the compiler substitutes corresponding
9199 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9200 early on, later parts of the compiler can always do the reverse
9201 translation and get back the corresponding typedef name. For
9204 typedef struct S MY_TYPE;
9207 Later parts of the compiler might only know that `object' was of
9208 type `struct S' if it were not for code just below. With this
9209 code however, later parts of the compiler see something like:
9211 struct S' == struct S
9212 typedef struct S' MY_TYPE;
9215 And they can then deduce (from the node for type struct S') that
9216 the original object declaration was:
9220 Being able to do this is important for proper support of protoize,
9221 and also for generating precise symbolic debugging information
9222 which takes full account of the programmer's (typedef) vocabulary.
9224 Obviously, we don't want to generate a duplicate ..._TYPE node if
9225 the TYPE_DECL node that we are now processing really represents a
9226 standard built-in type. */
9229 set_underlying_type (tree x)
9231 if (x == error_mark_node)
9233 if (DECL_IS_BUILTIN (x))
9235 if (TYPE_NAME (TREE_TYPE (x)) == 0)
9236 TYPE_NAME (TREE_TYPE (x)) = x;
9238 else if (TREE_TYPE (x) != error_mark_node
9239 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9241 tree tt = TREE_TYPE (x);
9242 DECL_ORIGINAL_TYPE (x) = tt;
9243 tt = build_variant_type_copy (tt);
9244 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9246 TREE_USED (tt) = TREE_USED (x);
9251 /* Returns true if X is a typedef decl. */
9254 is_typedef_decl (tree x)
9256 return (x && TREE_CODE (x) == TYPE_DECL
9257 && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
9260 #include "gt-c-common.h"