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 means warn about implicit declarations. */
598 int warn_implicit
= 1;
600 /* Maximum template instantiation depth. This limit is rather
601 arbitrary, but it exists to limit the time it takes to notice
602 infinite template instantiations. */
604 int max_tinst_depth
= 500;
608 /* The elements of `ridpointers' are identifier nodes for the reserved
609 type names and storage classes. It is indexed by a RID_... value. */
612 tree (*make_fname_decl
) (tree
, int);
614 /* Nonzero means the expression being parsed will never be evaluated.
615 This is a count, since unevaluated expressions can nest. */
618 /* Whether lexing has been completed, so subsequent preprocessor
619 errors should use the compiler's input_location. */
620 bool done_lexing
= false;
622 /* Information about how a function name is generated. */
625 tree
*const decl
; /* pointer to the VAR_DECL. */
626 const unsigned rid
; /* RID number for the identifier. */
627 const int pretty
; /* How pretty is it? */
630 /* The three ways of getting then name of the current function. */
632 const struct fname_var_t fname_vars
[] =
634 /* C99 compliant __func__, must be first. */
635 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
636 /* GCC __FUNCTION__ compliant. */
637 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
638 /* GCC __PRETTY_FUNCTION__ compliant. */
639 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
643 static tree
c_fully_fold_internal (tree expr
, bool, bool *, bool *);
644 static tree
check_case_value (tree
);
645 static bool check_case_bounds (tree
, tree
, tree
*, tree
*);
647 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
648 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
649 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
650 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
651 static tree
handle_hot_attribute (tree
*, tree
, tree
, int, bool *);
652 static tree
handle_cold_attribute (tree
*, tree
, tree
, int, bool *);
653 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
654 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
656 static tree
handle_gnu_inline_attribute (tree
*, tree
, tree
, int, bool *);
657 static tree
handle_artificial_attribute (tree
*, tree
, tree
, int, bool *);
658 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
659 static tree
handle_error_attribute (tree
*, tree
, tree
, int, bool *);
660 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
661 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
662 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
664 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
665 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
667 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
668 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
669 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
670 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
671 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
672 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
673 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
674 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
675 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
677 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
679 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
681 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
682 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
683 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
685 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
686 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
687 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
689 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
691 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
692 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
693 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
694 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
696 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
697 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
698 static tree
handle_alloc_size_attribute (tree
*, tree
, tree
, int, bool *);
699 static tree
handle_target_attribute (tree
*, tree
, tree
, int, bool *);
700 static tree
handle_optimize_attribute (tree
*, tree
, tree
, int, bool *);
702 static void check_function_nonnull (tree
, int, tree
*);
703 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
704 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
705 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
706 static int resort_field_decl_cmp (const void *, const void *);
708 /* Reserved words. The third field is a mask: keywords are disabled
709 if they match the mask.
712 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
713 C --std=c99: D_CXXONLY | D_OBJC
714 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
715 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
716 C++ --std=c0x: D_CONLY | D_OBJC
717 ObjC++ is like C++ except that D_OBJC is not set
719 If -fno-asm is used, D_ASM is added to the mask. If
720 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
721 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
722 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
724 const struct c_common_resword c_common_reswords
[] =
726 { "_Bool", RID_BOOL
, D_CONLY
},
727 { "_Complex", RID_COMPLEX
, 0 },
728 { "_Decimal32", RID_DFLOAT32
, D_CONLY
| D_EXT
},
729 { "_Decimal64", RID_DFLOAT64
, D_CONLY
| D_EXT
},
730 { "_Decimal128", RID_DFLOAT128
, D_CONLY
| D_EXT
},
731 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
732 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
733 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
734 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
735 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
736 { "__alignof", RID_ALIGNOF
, 0 },
737 { "__alignof__", RID_ALIGNOF
, 0 },
738 { "__asm", RID_ASM
, 0 },
739 { "__asm__", RID_ASM
, 0 },
740 { "__attribute", RID_ATTRIBUTE
, 0 },
741 { "__attribute__", RID_ATTRIBUTE
, 0 },
742 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
743 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
744 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
745 { "__builtin_va_arg", RID_VA_ARG
, 0 },
746 { "__complex", RID_COMPLEX
, 0 },
747 { "__complex__", RID_COMPLEX
, 0 },
748 { "__const", RID_CONST
, 0 },
749 { "__const__", RID_CONST
, 0 },
750 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
751 { "__extension__", RID_EXTENSION
, 0 },
752 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
753 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
754 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
755 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
756 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
757 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
758 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
759 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
760 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
761 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
762 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
763 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
764 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO
, D_CXXONLY
},
765 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
766 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
767 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
768 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
769 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
770 { "__imag", RID_IMAGPART
, 0 },
771 { "__imag__", RID_IMAGPART
, 0 },
772 { "__inline", RID_INLINE
, 0 },
773 { "__inline__", RID_INLINE
, 0 },
774 { "__label__", RID_LABEL
, 0 },
775 { "__null", RID_NULL
, 0 },
776 { "__real", RID_REALPART
, 0 },
777 { "__real__", RID_REALPART
, 0 },
778 { "__restrict", RID_RESTRICT
, 0 },
779 { "__restrict__", RID_RESTRICT
, 0 },
780 { "__signed", RID_SIGNED
, 0 },
781 { "__signed__", RID_SIGNED
, 0 },
782 { "__thread", RID_THREAD
, 0 },
783 { "__typeof", RID_TYPEOF
, 0 },
784 { "__typeof__", RID_TYPEOF
, 0 },
785 { "__volatile", RID_VOLATILE
, 0 },
786 { "__volatile__", RID_VOLATILE
, 0 },
787 { "asm", RID_ASM
, D_ASM
},
788 { "auto", RID_AUTO
, 0 },
789 { "bool", RID_BOOL
, D_CXXONLY
| D_CXXWARN
},
790 { "break", RID_BREAK
, 0 },
791 { "case", RID_CASE
, 0 },
792 { "catch", RID_CATCH
, D_CXX_OBJC
| D_CXXWARN
},
793 { "char", RID_CHAR
, 0 },
794 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
795 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
796 { "class", RID_CLASS
, D_CXX_OBJC
| D_CXXWARN
},
797 { "const", RID_CONST
, 0 },
798 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
799 { "continue", RID_CONTINUE
, 0 },
800 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
801 { "default", RID_DEFAULT
, 0 },
802 { "delete", RID_DELETE
, D_CXXONLY
| D_CXXWARN
},
804 { "double", RID_DOUBLE
, 0 },
805 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
806 { "else", RID_ELSE
, 0 },
807 { "enum", RID_ENUM
, 0 },
808 { "explicit", RID_EXPLICIT
, D_CXXONLY
| D_CXXWARN
},
809 { "export", RID_EXPORT
, D_CXXONLY
| D_CXXWARN
},
810 { "extern", RID_EXTERN
, 0 },
811 { "false", RID_FALSE
, D_CXXONLY
| D_CXXWARN
},
812 { "float", RID_FLOAT
, 0 },
813 { "for", RID_FOR
, 0 },
814 { "friend", RID_FRIEND
, D_CXXONLY
| D_CXXWARN
},
815 { "goto", RID_GOTO
, 0 },
817 { "inline", RID_INLINE
, D_EXT89
},
818 { "int", RID_INT
, 0 },
819 { "long", RID_LONG
, 0 },
820 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
821 { "namespace", RID_NAMESPACE
, D_CXXONLY
| D_CXXWARN
},
822 { "new", RID_NEW
, D_CXXONLY
| D_CXXWARN
},
823 { "operator", RID_OPERATOR
, D_CXXONLY
| D_CXXWARN
},
824 { "private", RID_PRIVATE
, D_CXX_OBJC
| D_CXXWARN
},
825 { "protected", RID_PROTECTED
, D_CXX_OBJC
| D_CXXWARN
},
826 { "public", RID_PUBLIC
, D_CXX_OBJC
| D_CXXWARN
},
827 { "register", RID_REGISTER
, 0 },
828 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
829 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
830 { "return", RID_RETURN
, 0 },
831 { "short", RID_SHORT
, 0 },
832 { "signed", RID_SIGNED
, 0 },
833 { "sizeof", RID_SIZEOF
, 0 },
834 { "static", RID_STATIC
, 0 },
835 { "static_assert", RID_STATIC_ASSERT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
836 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
837 { "struct", RID_STRUCT
, 0 },
838 { "switch", RID_SWITCH
, 0 },
839 { "template", RID_TEMPLATE
, D_CXXONLY
| D_CXXWARN
},
840 { "this", RID_THIS
, D_CXXONLY
| D_CXXWARN
},
841 { "throw", RID_THROW
, D_CXX_OBJC
| D_CXXWARN
},
842 { "true", RID_TRUE
, D_CXXONLY
| D_CXXWARN
},
843 { "try", RID_TRY
, D_CXX_OBJC
| D_CXXWARN
},
844 { "typedef", RID_TYPEDEF
, 0 },
845 { "typename", RID_TYPENAME
, D_CXXONLY
| D_CXXWARN
},
846 { "typeid", RID_TYPEID
, D_CXXONLY
| D_CXXWARN
},
847 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
848 { "union", RID_UNION
, 0 },
849 { "unsigned", RID_UNSIGNED
, 0 },
850 { "using", RID_USING
, D_CXXONLY
| D_CXXWARN
},
851 { "virtual", RID_VIRTUAL
, D_CXXONLY
| D_CXXWARN
},
852 { "void", RID_VOID
, 0 },
853 { "volatile", RID_VOLATILE
, 0 },
854 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
855 { "while", RID_WHILE
, 0 },
856 /* These Objective-C keywords are recognized only immediately after
858 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
859 { "defs", RID_AT_DEFS
, D_OBJC
},
860 { "encode", RID_AT_ENCODE
, D_OBJC
},
861 { "end", RID_AT_END
, D_OBJC
},
862 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
863 { "interface", RID_AT_INTERFACE
, D_OBJC
},
864 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
865 { "selector", RID_AT_SELECTOR
, D_OBJC
},
866 { "finally", RID_AT_FINALLY
, D_OBJC
},
867 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
868 /* These are recognized only in protocol-qualifier context
870 { "bycopy", RID_BYCOPY
, D_OBJC
},
871 { "byref", RID_BYREF
, D_OBJC
},
872 { "in", RID_IN
, D_OBJC
},
873 { "inout", RID_INOUT
, D_OBJC
},
874 { "oneway", RID_ONEWAY
, D_OBJC
},
875 { "out", RID_OUT
, D_OBJC
},
878 const unsigned int num_c_common_reswords
=
879 sizeof c_common_reswords
/ sizeof (struct c_common_resword
);
881 /* Table of machine-independent attributes common to all C-like languages. */
882 const struct attribute_spec c_common_attribute_table
[] =
884 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
885 { "packed", 0, 0, false, false, false,
886 handle_packed_attribute
},
887 { "nocommon", 0, 0, true, false, false,
888 handle_nocommon_attribute
},
889 { "common", 0, 0, true, false, false,
890 handle_common_attribute
},
891 /* FIXME: logically, noreturn attributes should be listed as
892 "false, true, true" and apply to function types. But implementing this
893 would require all the places in the compiler that use TREE_THIS_VOLATILE
894 on a decl to identify non-returning functions to be located and fixed
895 to check the function type instead. */
896 { "noreturn", 0, 0, true, false, false,
897 handle_noreturn_attribute
},
898 { "volatile", 0, 0, true, false, false,
899 handle_noreturn_attribute
},
900 { "noinline", 0, 0, true, false, false,
901 handle_noinline_attribute
},
902 { "always_inline", 0, 0, true, false, false,
903 handle_always_inline_attribute
},
904 { "gnu_inline", 0, 0, true, false, false,
905 handle_gnu_inline_attribute
},
906 { "artificial", 0, 0, true, false, false,
907 handle_artificial_attribute
},
908 { "flatten", 0, 0, true, false, false,
909 handle_flatten_attribute
},
910 { "used", 0, 0, true, false, false,
911 handle_used_attribute
},
912 { "unused", 0, 0, false, false, false,
913 handle_unused_attribute
},
914 { "externally_visible", 0, 0, true, false, false,
915 handle_externally_visible_attribute
},
916 /* The same comments as for noreturn attributes apply to const ones. */
917 { "const", 0, 0, true, false, false,
918 handle_const_attribute
},
919 { "transparent_union", 0, 0, false, false, false,
920 handle_transparent_union_attribute
},
921 { "constructor", 0, 1, true, false, false,
922 handle_constructor_attribute
},
923 { "destructor", 0, 1, true, false, false,
924 handle_destructor_attribute
},
925 { "mode", 1, 1, false, true, false,
926 handle_mode_attribute
},
927 { "section", 1, 1, true, false, false,
928 handle_section_attribute
},
929 { "aligned", 0, 1, false, false, false,
930 handle_aligned_attribute
},
931 { "weak", 0, 0, true, false, false,
932 handle_weak_attribute
},
933 { "alias", 1, 1, true, false, false,
934 handle_alias_attribute
},
935 { "weakref", 0, 1, true, false, false,
936 handle_weakref_attribute
},
937 { "no_instrument_function", 0, 0, true, false, false,
938 handle_no_instrument_function_attribute
},
939 { "malloc", 0, 0, true, false, false,
940 handle_malloc_attribute
},
941 { "returns_twice", 0, 0, true, false, false,
942 handle_returns_twice_attribute
},
943 { "no_stack_limit", 0, 0, true, false, false,
944 handle_no_limit_stack_attribute
},
945 { "pure", 0, 0, true, false, false,
946 handle_pure_attribute
},
947 /* For internal use (marking of builtins) only. The name contains space
948 to prevent its usage in source code. */
949 { "no vops", 0, 0, true, false, false,
950 handle_novops_attribute
},
951 { "deprecated", 0, 0, false, false, false,
952 handle_deprecated_attribute
},
953 { "vector_size", 1, 1, false, true, false,
954 handle_vector_size_attribute
},
955 { "visibility", 1, 1, false, false, false,
956 handle_visibility_attribute
},
957 { "tls_model", 1, 1, true, false, false,
958 handle_tls_model_attribute
},
959 { "nonnull", 0, -1, false, true, true,
960 handle_nonnull_attribute
},
961 { "nothrow", 0, 0, true, false, false,
962 handle_nothrow_attribute
},
963 { "may_alias", 0, 0, false, true, false, NULL
},
964 { "cleanup", 1, 1, true, false, false,
965 handle_cleanup_attribute
},
966 { "warn_unused_result", 0, 0, false, true, true,
967 handle_warn_unused_result_attribute
},
968 { "sentinel", 0, 1, false, true, true,
969 handle_sentinel_attribute
},
970 /* For internal use (marking of builtins) only. The name contains space
971 to prevent its usage in source code. */
972 { "type generic", 0, 0, false, true, true,
973 handle_type_generic_attribute
},
974 { "alloc_size", 1, 2, false, true, true,
975 handle_alloc_size_attribute
},
976 { "cold", 0, 0, true, false, false,
977 handle_cold_attribute
},
978 { "hot", 0, 0, true, false, false,
979 handle_hot_attribute
},
980 { "warning", 1, 1, true, false, false,
981 handle_error_attribute
},
982 { "error", 1, 1, true, false, false,
983 handle_error_attribute
},
984 { "target", 1, -1, true, false, false,
985 handle_target_attribute
},
986 { "optimize", 1, -1, true, false, false,
987 handle_optimize_attribute
},
988 { NULL
, 0, 0, false, false, false, NULL
}
991 /* Give the specifications for the format attributes, used by C and all
994 const struct attribute_spec c_common_format_attribute_table
[] =
996 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
997 { "format", 3, 3, false, true, true,
998 handle_format_attribute
},
999 { "format_arg", 1, 1, false, true, true,
1000 handle_format_arg_attribute
},
1001 { NULL
, 0, 0, false, false, false, NULL
}
1004 /* Push current bindings for the function name VAR_DECLS. */
1007 start_fname_decls (void)
1010 tree saved
= NULL_TREE
;
1012 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1014 tree decl
= *fname_vars
[ix
].decl
;
1018 saved
= tree_cons (decl
, build_int_cst (NULL_TREE
, ix
), saved
);
1019 *fname_vars
[ix
].decl
= NULL_TREE
;
1022 if (saved
|| saved_function_name_decls
)
1023 /* Normally they'll have been NULL, so only push if we've got a
1024 stack, or they are non-NULL. */
1025 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
1026 saved_function_name_decls
);
1029 /* Finish up the current bindings, adding them into the current function's
1030 statement tree. This must be done _before_ finish_stmt_tree is called.
1031 If there is no current function, we must be at file scope and no statements
1032 are involved. Pop the previous bindings. */
1035 finish_fname_decls (void)
1038 tree stmts
= NULL_TREE
;
1039 tree stack
= saved_function_name_decls
;
1041 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
1042 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
1046 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
1048 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
1049 bodyp
= &BIND_EXPR_BODY (*bodyp
);
1051 append_to_statement_list_force (*bodyp
, &stmts
);
1055 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1056 *fname_vars
[ix
].decl
= NULL_TREE
;
1060 /* We had saved values, restore them. */
1063 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
1065 tree decl
= TREE_PURPOSE (saved
);
1066 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
1068 *fname_vars
[ix
].decl
= decl
;
1070 stack
= TREE_CHAIN (stack
);
1072 saved_function_name_decls
= stack
;
1075 /* Return the text name of the current function, suitably prettified
1076 by PRETTY_P. Return string must be freed by caller. */
1079 fname_as_string (int pretty_p
)
1081 const char *name
= "top level";
1084 cpp_string cstr
= { 0, 0 }, strname
;
1092 if (current_function_decl
)
1093 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
1095 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
1097 namep
= XNEWVEC (char, len
);
1098 snprintf (namep
, len
, "\"%s\"", name
);
1099 strname
.text
= (unsigned char *) namep
;
1100 strname
.len
= len
- 1;
1102 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
1105 return (const char *) cstr
.text
;
1111 /* Return the VAR_DECL for a const char array naming the current
1112 function. If the VAR_DECL has not yet been created, create it
1113 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1114 ID is its name (unfortunately C and C++ hold the RID values of
1115 keywords in different places, so we can't derive RID from ID in
1116 this language independent code. LOC is the location of the
1120 fname_decl (location_t loc
, unsigned int rid
, tree id
)
1123 tree decl
= NULL_TREE
;
1125 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1126 if (fname_vars
[ix
].rid
== rid
)
1129 decl
= *fname_vars
[ix
].decl
;
1132 /* If a tree is built here, it would normally have the lineno of
1133 the current statement. Later this tree will be moved to the
1134 beginning of the function and this line number will be wrong.
1135 To avoid this problem set the lineno to 0 here; that prevents
1136 it from appearing in the RTL. */
1138 location_t saved_location
= input_location
;
1139 input_location
= UNKNOWN_LOCATION
;
1141 stmts
= push_stmt_list ();
1142 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
1143 stmts
= pop_stmt_list (stmts
);
1144 if (!IS_EMPTY_STMT (stmts
))
1145 saved_function_name_decls
1146 = tree_cons (decl
, stmts
, saved_function_name_decls
);
1147 *fname_vars
[ix
].decl
= decl
;
1148 input_location
= saved_location
;
1150 if (!ix
&& !current_function_decl
)
1151 pedwarn (loc
, 0, "%qD is not defined outside of function scope", decl
);
1156 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1159 fix_string_type (tree value
)
1161 int length
= TREE_STRING_LENGTH (value
);
1163 tree e_type
, i_type
, a_type
;
1165 /* Compute the number of elements, for the array type. */
1166 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
1169 e_type
= char_type_node
;
1171 else if (TREE_TYPE (value
) == char16_array_type_node
)
1173 nchars
= length
/ (TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
);
1174 e_type
= char16_type_node
;
1176 else if (TREE_TYPE (value
) == char32_array_type_node
)
1178 nchars
= length
/ (TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
);
1179 e_type
= char32_type_node
;
1183 nchars
= length
/ (TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
);
1184 e_type
= wchar_type_node
;
1187 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1188 limit in C++98 Annex B is very large (65536) and is not normative,
1189 so we do not diagnose it (warn_overlength_strings is forced off
1190 in c_common_post_options). */
1191 if (warn_overlength_strings
)
1193 const int nchars_max
= flag_isoc99
? 4095 : 509;
1194 const int relevant_std
= flag_isoc99
? 99 : 90;
1195 if (nchars
- 1 > nchars_max
)
1196 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1197 separate the %d from the 'C'. 'ISO' should not be
1198 translated, but it may be moved after 'C%d' in languages
1199 where modifiers follow nouns. */
1200 pedwarn (input_location
, OPT_Woverlength_strings
,
1201 "string length %qd is greater than the length %qd "
1202 "ISO C%d compilers are required to support",
1203 nchars
- 1, nchars_max
, relevant_std
);
1206 /* Create the array type for the string constant. The ISO C++
1207 standard says that a string literal has type `const char[N]' or
1208 `const wchar_t[N]'. We use the same logic when invoked as a C
1209 front-end with -Wwrite-strings.
1210 ??? We should change the type of an expression depending on the
1211 state of a warning flag. We should just be warning -- see how
1212 this is handled in the C++ front-end for the deprecated implicit
1213 conversion from string literals to `char*' or `wchar_t*'.
1215 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1216 array type being the unqualified version of that type.
1217 Therefore, if we are constructing an array of const char, we must
1218 construct the matching unqualified array type first. The C front
1219 end does not require this, but it does no harm, so we do it
1221 i_type
= build_index_type (build_int_cst (NULL_TREE
, nchars
- 1));
1222 a_type
= build_array_type (e_type
, i_type
);
1223 if (c_dialect_cxx() || warn_write_strings
)
1224 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
1226 TREE_TYPE (value
) = a_type
;
1227 TREE_CONSTANT (value
) = 1;
1228 TREE_READONLY (value
) = 1;
1229 TREE_STATIC (value
) = 1;
1233 /* Fully fold EXPR, an expression that was not folded (beyond integer
1234 constant expressions and null pointer constants) when being built
1235 up. If IN_INIT, this is in a static initializer and certain
1236 changes are made to the folding done. Clear *MAYBE_CONST if
1237 MAYBE_CONST is not NULL and EXPR is definitely not a constant
1238 expression because it contains an evaluated operator (in C99) or an
1239 operator outside of sizeof returning an integer constant (in C90)
1240 not permitted in constant expressions, or because it contains an
1241 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
1242 set to true by callers before calling this function.) Return the
1243 folded expression. Function arguments have already been folded
1244 before calling this function, as have the contents of SAVE_EXPR,
1245 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1246 C_MAYBE_CONST_EXPR. */
1249 c_fully_fold (tree expr
, bool in_init
, bool *maybe_const
)
1252 tree eptype
= NULL_TREE
;
1254 bool maybe_const_itself
= true;
1256 /* This function is not relevant to C++ because C++ folds while
1257 parsing, and may need changes to be correct for C++ when C++
1258 stops folding while parsing. */
1259 if (c_dialect_cxx ())
1263 maybe_const
= &dummy
;
1264 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
1266 eptype
= TREE_TYPE (expr
);
1267 expr
= TREE_OPERAND (expr
, 0);
1269 ret
= c_fully_fold_internal (expr
, in_init
, maybe_const
,
1270 &maybe_const_itself
);
1272 ret
= fold_convert (eptype
, ret
);
1273 *maybe_const
&= maybe_const_itself
;
1277 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1278 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1279 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1280 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1281 both evaluated and unevaluated subexpressions while
1282 *MAYBE_CONST_ITSELF is carried from only evaluated
1286 c_fully_fold_internal (tree expr
, bool in_init
, bool *maybe_const_operands
,
1287 bool *maybe_const_itself
)
1290 enum tree_code code
= TREE_CODE (expr
);
1291 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
1292 location_t loc
= EXPR_LOCATION (expr
);
1293 tree op0
, op1
, op2
, op3
;
1294 tree orig_op0
, orig_op1
, orig_op2
;
1295 bool op0_const
= true, op1_const
= true, op2_const
= true;
1296 bool op0_const_self
= true, op1_const_self
= true, op2_const_self
= true;
1297 bool nowarning
= TREE_NO_WARNING (expr
);
1299 /* This function is not relevant to C++ because C++ folds while
1300 parsing, and may need changes to be correct for C++ when C++
1301 stops folding while parsing. */
1302 if (c_dialect_cxx ())
1305 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1306 anything else not counted as an expression cannot usefully be
1307 folded further at this point. */
1308 if (!IS_EXPR_CODE_CLASS (kind
)
1309 || kind
== tcc_statement
1310 || code
== SAVE_EXPR
)
1313 /* Operands of variable-length expressions (function calls) have
1314 already been folded, as have __builtin_* function calls, and such
1315 expressions cannot occur in constant expressions. */
1316 if (kind
== tcc_vl_exp
)
1318 *maybe_const_operands
= false;
1323 if (code
== C_MAYBE_CONST_EXPR
)
1325 tree pre
= C_MAYBE_CONST_EXPR_PRE (expr
);
1326 tree inner
= C_MAYBE_CONST_EXPR_EXPR (expr
);
1327 if (C_MAYBE_CONST_EXPR_NON_CONST (expr
))
1328 *maybe_const_operands
= false;
1329 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr
))
1330 *maybe_const_itself
= false;
1331 if (pre
&& !in_init
)
1332 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), pre
, inner
);
1338 /* Assignment, increment, decrement, function call and comma
1339 operators, and statement expressions, cannot occur in constant
1340 expressions if evaluated / outside of sizeof. (Function calls
1341 were handled above, though VA_ARG_EXPR is treated like a function
1342 call here, and statement expressions are handled through
1343 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1347 case PREDECREMENT_EXPR
:
1348 case PREINCREMENT_EXPR
:
1349 case POSTDECREMENT_EXPR
:
1350 case POSTINCREMENT_EXPR
:
1352 *maybe_const_operands
= false;
1359 *maybe_const_operands
= false;
1367 /* Fold individual tree codes as appropriate. */
1370 case COMPOUND_LITERAL_EXPR
:
1371 /* Any non-constancy will have been marked in a containing
1372 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1376 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1377 op1
= TREE_OPERAND (expr
, 1);
1378 op2
= TREE_OPERAND (expr
, 2);
1379 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1380 maybe_const_itself
);
1381 if (op0
!= orig_op0
)
1382 ret
= build3 (COMPONENT_REF
, TREE_TYPE (expr
), op0
, op1
, op2
);
1385 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1386 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1391 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1392 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1393 op2
= TREE_OPERAND (expr
, 2);
1394 op3
= TREE_OPERAND (expr
, 3);
1395 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1396 maybe_const_itself
);
1397 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1398 maybe_const_itself
);
1399 op1
= decl_constant_value_for_optimization (op1
);
1400 if (op0
!= orig_op0
|| op1
!= orig_op1
)
1401 ret
= build4 (ARRAY_REF
, TREE_TYPE (expr
), op0
, op1
, op2
, op3
);
1404 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1405 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1406 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1413 case PREDECREMENT_EXPR
:
1414 case PREINCREMENT_EXPR
:
1415 case POSTDECREMENT_EXPR
:
1416 case POSTINCREMENT_EXPR
:
1420 case POINTER_PLUS_EXPR
:
1421 case TRUNC_DIV_EXPR
:
1423 case FLOOR_DIV_EXPR
:
1424 case TRUNC_MOD_EXPR
:
1426 case EXACT_DIV_EXPR
:
1439 case TRUTH_AND_EXPR
:
1441 case TRUTH_XOR_EXPR
:
1442 case UNORDERED_EXPR
:
1449 /* Binary operations evaluating both arguments (increment and
1450 decrement are binary internally in GCC). */
1451 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1452 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1453 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1454 maybe_const_itself
);
1455 if (code
!= MODIFY_EXPR
1456 && code
!= PREDECREMENT_EXPR
1457 && code
!= PREINCREMENT_EXPR
1458 && code
!= POSTDECREMENT_EXPR
1459 && code
!= POSTINCREMENT_EXPR
)
1460 op0
= decl_constant_value_for_optimization (op0
);
1461 /* The RHS of a MODIFY_EXPR was fully folded when building that
1462 expression for the sake of conversion warnings. */
1463 if (code
!= MODIFY_EXPR
)
1464 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1465 maybe_const_itself
);
1466 op1
= decl_constant_value_for_optimization (op1
);
1467 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1469 ? fold_build2_initializer (code
, TREE_TYPE (expr
), op0
, op1
)
1470 : fold_build2 (code
, TREE_TYPE (expr
), op0
, op1
);
1476 case FIX_TRUNC_EXPR
:
1479 case NON_LVALUE_EXPR
:
1482 case TRUTH_NOT_EXPR
:
1487 /* Unary operations. */
1488 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1489 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1490 maybe_const_itself
);
1491 if (code
!= ADDR_EXPR
&& code
!= REALPART_EXPR
&& code
!= IMAGPART_EXPR
)
1492 op0
= decl_constant_value_for_optimization (op0
);
1493 if (op0
!= orig_op0
|| in_init
)
1495 ? fold_build1_initializer (code
, TREE_TYPE (expr
), op0
)
1496 : fold_build1 (code
, TREE_TYPE (expr
), op0
);
1499 if (code
== INDIRECT_REF
1501 && TREE_CODE (ret
) == INDIRECT_REF
)
1503 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1504 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1505 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1509 case TRUTH_ANDIF_EXPR
:
1510 case TRUTH_ORIF_EXPR
:
1511 /* Binary operations not necessarily evaluating both
1513 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1514 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1515 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1516 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1517 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1519 ? fold_build2_initializer (code
, TREE_TYPE (expr
), op0
, op1
)
1520 : fold_build2 (code
, TREE_TYPE (expr
), op0
, op1
);
1523 *maybe_const_operands
&= op0_const
;
1524 *maybe_const_itself
&= op0_const_self
;
1528 && (code
== TRUTH_ANDIF_EXPR
1529 ? op0
== truthvalue_false_node
1530 : op0
== truthvalue_true_node
)))
1531 *maybe_const_operands
&= op1_const
;
1534 && (code
== TRUTH_ANDIF_EXPR
1535 ? op0
== truthvalue_false_node
1536 : op0
== truthvalue_true_node
)))
1537 *maybe_const_itself
&= op1_const_self
;
1541 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1542 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1543 orig_op2
= op2
= TREE_OPERAND (expr
, 2);
1544 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1545 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1546 op2
= c_fully_fold_internal (op2
, in_init
, &op2_const
, &op2_const_self
);
1547 if (op0
!= orig_op0
|| op1
!= orig_op1
|| op2
!= orig_op2
)
1548 ret
= fold_build3 (code
, TREE_TYPE (expr
), op0
, op1
, op2
);
1551 *maybe_const_operands
&= op0_const
;
1552 *maybe_const_itself
&= op0_const_self
;
1556 && op0
== truthvalue_false_node
))
1557 *maybe_const_operands
&= op1_const
;
1560 && op0
== truthvalue_false_node
))
1561 *maybe_const_itself
&= op1_const_self
;
1565 && op0
== truthvalue_true_node
))
1566 *maybe_const_operands
&= op2_const
;
1569 && op0
== truthvalue_true_node
))
1570 *maybe_const_itself
&= op2_const_self
;
1573 case EXCESS_PRECISION_EXPR
:
1574 /* Each case where an operand with excess precision may be
1575 encountered must remove the EXCESS_PRECISION_EXPR around
1576 inner operands and possibly put one around the whole
1577 expression or possibly convert to the semantic type (which
1578 c_fully_fold does); we cannot tell at this stage which is
1579 appropriate in any particular case. */
1583 /* Various codes may appear through folding built-in functions
1584 and their arguments. */
1589 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1590 have been done by this point, so remove them again. */
1591 nowarning
|= TREE_NO_WARNING (ret
);
1592 STRIP_TYPE_NOPS (ret
);
1593 if (nowarning
&& !TREE_NO_WARNING (ret
))
1595 if (!CAN_HAVE_LOCATION_P (ret
))
1596 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
1597 TREE_NO_WARNING (ret
) = 1;
1600 protected_set_expr_location (ret
, loc
);
1604 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1605 return EXP. Otherwise, return either EXP or its known constant
1606 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1607 Is the BLKmode test appropriate? */
1610 decl_constant_value_for_optimization (tree exp
)
1614 /* This function is only used by C, for c_fully_fold and other
1615 optimization, and may not be correct for C++. */
1616 if (c_dialect_cxx ())
1620 || TREE_CODE (exp
) != VAR_DECL
1621 || TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1622 || DECL_MODE (exp
) == BLKmode
)
1625 ret
= decl_constant_value (exp
);
1626 /* Avoid unwanted tree sharing between the initializer and current
1627 function's body where the tree can be modified e.g. by the
1629 if (ret
!= exp
&& TREE_STATIC (exp
))
1630 ret
= unshare_expr (ret
);
1634 /* Print a warning if a constant expression had overflow in folding.
1635 Invoke this function on every expression that the language
1636 requires to be a constant expression.
1637 Note the ANSI C standard says it is erroneous for a
1638 constant expression to overflow. */
1641 constant_expression_warning (tree value
)
1643 if (warn_overflow
&& pedantic
1644 && (TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1645 || TREE_CODE (value
) == FIXED_CST
1646 || TREE_CODE (value
) == VECTOR_CST
1647 || TREE_CODE (value
) == COMPLEX_CST
)
1648 && TREE_OVERFLOW (value
))
1649 pedwarn (input_location
, OPT_Woverflow
, "overflow in constant expression");
1652 /* The same as above but print an unconditional error. */
1654 constant_expression_error (tree value
)
1656 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1657 || TREE_CODE (value
) == FIXED_CST
1658 || TREE_CODE (value
) == VECTOR_CST
1659 || TREE_CODE (value
) == COMPLEX_CST
)
1660 && TREE_OVERFLOW (value
))
1661 error ("overflow in constant expression");
1664 /* Print a warning if an expression had overflow in folding and its
1667 Invoke this function on every expression that
1668 (1) appears in the source code, and
1669 (2) is a constant expression that overflowed, and
1670 (3) is not already checked by convert_and_check;
1671 however, do not invoke this function on operands of explicit casts
1672 or when the expression is the result of an operator and any operand
1673 already overflowed. */
1676 overflow_warning (tree value
)
1678 if (skip_evaluation
) return;
1680 switch (TREE_CODE (value
))
1683 warning (OPT_Woverflow
, "integer overflow in expression");
1687 warning (OPT_Woverflow
, "floating point overflow in expression");
1691 warning (OPT_Woverflow
, "fixed-point overflow in expression");
1695 warning (OPT_Woverflow
, "vector overflow in expression");
1699 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
1700 warning (OPT_Woverflow
, "complex integer overflow in expression");
1701 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
1702 warning (OPT_Woverflow
, "complex floating point overflow in expression");
1711 /* Warn about use of a logical || / && operator being used in a
1712 context where it is likely that the bitwise equivalent was intended
1713 by the programmer. CODE is the TREE_CODE of the operator, ARG1
1714 and ARG2 the arguments. */
1717 warn_logical_operator (enum tree_code code
, tree arg1
, tree
1722 case TRUTH_ANDIF_EXPR
:
1723 case TRUTH_ORIF_EXPR
:
1725 case TRUTH_AND_EXPR
:
1726 if (!TREE_NO_WARNING (arg1
)
1727 && INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
1728 && !CONSTANT_CLASS_P (arg1
)
1729 && TREE_CODE (arg2
) == INTEGER_CST
1730 && !integer_zerop (arg2
))
1732 warning (OPT_Wlogical_op
,
1733 "logical %<%s%> with non-zero constant "
1734 "will always evaluate as true",
1735 ((code
== TRUTH_ANDIF_EXPR
)
1736 || (code
== TRUTH_AND_EXPR
)) ? "&&" : "||");
1737 TREE_NO_WARNING (arg1
) = true;
1746 /* Print a warning about casts that might indicate violation
1747 of strict aliasing rules if -Wstrict-aliasing is used and
1748 strict aliasing mode is in effect. OTYPE is the original
1749 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1752 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
1754 if (!(flag_strict_aliasing
1755 && POINTER_TYPE_P (type
)
1756 && POINTER_TYPE_P (otype
)
1757 && !VOID_TYPE_P (TREE_TYPE (type
)))
1758 /* If the type we are casting to is a ref-all pointer
1759 dereferencing it is always valid. */
1760 || TYPE_REF_CAN_ALIAS_ALL (type
))
1763 if ((warn_strict_aliasing
> 1) && TREE_CODE (expr
) == ADDR_EXPR
1764 && (DECL_P (TREE_OPERAND (expr
, 0))
1765 || handled_component_p (TREE_OPERAND (expr
, 0))))
1767 /* Casting the address of an object to non void pointer. Warn
1768 if the cast breaks type based aliasing. */
1769 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)) && warn_strict_aliasing
== 2)
1771 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
1772 "might break strict-aliasing rules");
1777 /* warn_strict_aliasing >= 3. This includes the default (3).
1778 Only warn if the cast is dereferenced immediately. */
1779 alias_set_type set1
=
1780 get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1781 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1783 if (set1
!= set2
&& set2
!= 0
1784 && (set1
== 0 || !alias_sets_conflict_p (set1
, set2
)))
1786 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1787 "pointer will break strict-aliasing rules");
1790 else if (warn_strict_aliasing
== 2
1791 && !alias_sets_must_conflict_p (set1
, set2
))
1793 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1794 "pointer might break strict-aliasing rules");
1800 if ((warn_strict_aliasing
== 1) && !VOID_TYPE_P (TREE_TYPE (otype
)))
1802 /* At this level, warn for any conversions, even if an address is
1803 not taken in the same statement. This will likely produce many
1804 false positives, but could be useful to pinpoint problems that
1805 are not revealed at higher levels. */
1806 alias_set_type set1
= get_alias_set (TREE_TYPE (otype
));
1807 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1808 if (!COMPLETE_TYPE_P (type
)
1809 || !alias_sets_must_conflict_p (set1
, set2
))
1811 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1812 "pointer might break strict-aliasing rules");
1820 /* Warn for unlikely, improbable, or stupid DECL declarations
1824 check_main_parameter_types (tree decl
)
1829 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); args
;
1830 args
= TREE_CHAIN (args
))
1832 tree type
= args
? TREE_VALUE (args
) : 0;
1834 if (type
== void_type_node
|| type
== error_mark_node
)
1841 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
1842 pedwarn (input_location
, OPT_Wmain
, "first argument of %q+D should be %<int%>",
1847 if (TREE_CODE (type
) != POINTER_TYPE
1848 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1849 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1851 pedwarn (input_location
, OPT_Wmain
, "second argument of %q+D should be %<char **%>",
1856 if (TREE_CODE (type
) != POINTER_TYPE
1857 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1858 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1860 pedwarn (input_location
, OPT_Wmain
, "third argument of %q+D should probably be "
1861 "%<char **%>", decl
);
1866 /* It is intentional that this message does not mention the third
1867 argument because it's only mentioned in an appendix of the
1869 if (argct
> 0 && (argct
< 2 || argct
> 3))
1870 pedwarn (input_location
, OPT_Wmain
, "%q+D takes only zero or two arguments", decl
);
1873 /* True if pointers to distinct types T1 and T2 can be converted to
1874 each other without an explicit cast. Only returns true for opaque
1877 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
1879 if (TREE_CODE (t1
) == VECTOR_TYPE
&& TREE_CODE (t2
) == VECTOR_TYPE
1880 && (targetm
.vector_opaque_p (t1
) || targetm
.vector_opaque_p (t2
))
1881 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1887 /* True if vector types T1 and T2 can be converted to each other
1888 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1889 can only be converted with -flax-vector-conversions yet that is not
1890 in effect, emit a note telling the user about that option if such
1891 a note has not previously been emitted. */
1893 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
1895 static bool emitted_lax_note
= false;
1896 bool convertible_lax
;
1898 if ((targetm
.vector_opaque_p (t1
) || targetm
.vector_opaque_p (t2
))
1899 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1903 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1904 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
1905 TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
1906 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1907 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
1909 if (!convertible_lax
|| flag_lax_vector_conversions
)
1910 return convertible_lax
;
1912 if (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
1913 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1916 if (emit_lax_note
&& !emitted_lax_note
)
1918 emitted_lax_note
= true;
1919 inform (input_location
, "use -flax-vector-conversions to permit "
1920 "conversions between vectors with differing "
1921 "element types or numbers of subparts");
1927 /* This is a helper function of build_binary_op.
1929 For certain operations if both args were extended from the same
1930 smaller type, do the arithmetic in that type and then extend.
1932 BITWISE indicates a bitwise operation.
1933 For them, this optimization is safe only if
1934 both args are zero-extended or both are sign-extended.
1935 Otherwise, we might change the result.
1936 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1937 but calculated in (unsigned short) it would be (unsigned short)-1.
1939 tree
shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
1941 int unsigned0
, unsigned1
;
1946 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1947 excessive narrowing when we call get_narrower below. For
1948 example, suppose that OP0 is of unsigned int extended
1949 from signed char and that RESULT_TYPE is long long int.
1950 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1953 (long long int) (unsigned int) signed_char
1955 which get_narrower would narrow down to
1957 (unsigned int) signed char
1959 If we do not cast OP0 first, get_narrower would return
1960 signed_char, which is inconsistent with the case of the
1962 op0
= convert (result_type
, op0
);
1963 op1
= convert (result_type
, op1
);
1965 arg0
= get_narrower (op0
, &unsigned0
);
1966 arg1
= get_narrower (op1
, &unsigned1
);
1968 /* UNS is 1 if the operation to be done is an unsigned one. */
1969 uns
= TYPE_UNSIGNED (result_type
);
1971 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1972 but it *requires* conversion to FINAL_TYPE. */
1974 if ((TYPE_PRECISION (TREE_TYPE (op0
))
1975 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1976 && TREE_TYPE (op0
) != result_type
)
1977 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1978 if ((TYPE_PRECISION (TREE_TYPE (op1
))
1979 == TYPE_PRECISION (TREE_TYPE (arg1
)))
1980 && TREE_TYPE (op1
) != result_type
)
1981 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1983 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1985 /* For bitwise operations, signedness of nominal type
1986 does not matter. Consider only how operands were extended. */
1990 /* Note that in all three cases below we refrain from optimizing
1991 an unsigned operation on sign-extended args.
1992 That would not be valid. */
1994 /* Both args variable: if both extended in same way
1995 from same width, do it in that width.
1996 Do it unsigned if args were zero-extended. */
1997 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
1998 < TYPE_PRECISION (result_type
))
1999 && (TYPE_PRECISION (TREE_TYPE (arg1
))
2000 == TYPE_PRECISION (TREE_TYPE (arg0
)))
2001 && unsigned0
== unsigned1
2002 && (unsigned0
|| !uns
))
2003 return c_common_signed_or_unsigned_type
2004 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
2006 else if (TREE_CODE (arg0
) == INTEGER_CST
2007 && (unsigned1
|| !uns
)
2008 && (TYPE_PRECISION (TREE_TYPE (arg1
))
2009 < TYPE_PRECISION (result_type
))
2011 = c_common_signed_or_unsigned_type (unsigned1
,
2013 && !POINTER_TYPE_P (type
)
2014 && int_fits_type_p (arg0
, type
))
2017 else if (TREE_CODE (arg1
) == INTEGER_CST
2018 && (unsigned0
|| !uns
)
2019 && (TYPE_PRECISION (TREE_TYPE (arg0
))
2020 < TYPE_PRECISION (result_type
))
2022 = c_common_signed_or_unsigned_type (unsigned0
,
2024 && !POINTER_TYPE_P (type
)
2025 && int_fits_type_p (arg1
, type
))
2031 /* Warns if the conversion of EXPR to TYPE may alter a value.
2032 This is a helper function for warnings_for_convert_and_check. */
2035 conversion_warning (tree type
, tree expr
)
2037 bool give_warning
= false;
2040 const int expr_num_operands
= TREE_OPERAND_LENGTH (expr
);
2041 tree expr_type
= TREE_TYPE (expr
);
2043 if (!warn_conversion
&& !warn_sign_conversion
)
2046 /* If any operand is artificial, then this expression was generated
2047 by the compiler and we do not warn. */
2048 for (i
= 0; i
< expr_num_operands
; i
++)
2050 tree op
= TREE_OPERAND (expr
, i
);
2051 if (op
&& DECL_P (op
) && DECL_ARTIFICIAL (op
))
2055 switch (TREE_CODE (expr
))
2063 case TRUTH_ANDIF_EXPR
:
2064 case TRUTH_ORIF_EXPR
:
2065 case TRUTH_AND_EXPR
:
2067 case TRUTH_XOR_EXPR
:
2068 case TRUTH_NOT_EXPR
:
2069 /* Conversion from boolean to a signed:1 bit-field (which only
2070 can hold the values 0 and -1) doesn't lose information - but
2071 it does change the value. */
2072 if (TYPE_PRECISION (type
) == 1 && !TYPE_UNSIGNED (type
))
2073 warning (OPT_Wconversion
,
2074 "conversion to %qT from boolean expression", type
);
2080 /* Warn for real constant that is not an exact integer converted
2082 if (TREE_CODE (expr_type
) == REAL_TYPE
2083 && TREE_CODE (type
) == INTEGER_TYPE
)
2085 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (expr_type
)))
2086 give_warning
= true;
2088 /* Warn for an integer constant that does not fit into integer type. */
2089 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2090 && TREE_CODE (type
) == INTEGER_TYPE
2091 && !int_fits_type_p (expr
, type
))
2093 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)
2094 && tree_int_cst_sgn (expr
) < 0)
2095 warning (OPT_Wsign_conversion
,
2096 "negative integer implicitly converted to unsigned type");
2097 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (expr_type
))
2098 warning (OPT_Wsign_conversion
, "conversion of unsigned constant "
2099 "value to negative integer");
2101 give_warning
= true;
2103 else if (TREE_CODE (type
) == REAL_TYPE
)
2105 /* Warn for an integer constant that does not fit into real type. */
2106 if (TREE_CODE (expr_type
) == INTEGER_TYPE
)
2108 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
2109 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
2110 give_warning
= true;
2112 /* Warn for a real constant that does not fit into a smaller
2114 else if (TREE_CODE (expr_type
) == REAL_TYPE
2115 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2117 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
2118 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
2119 give_warning
= true;
2124 warning (OPT_Wconversion
,
2125 "conversion to %qT alters %qT constant value",
2132 /* In case of COND_EXPR, if both operands are constants or
2133 COND_EXPR, then we do not care about the type of COND_EXPR,
2134 only about the conversion of each operand. */
2135 tree op1
= TREE_OPERAND (expr
, 1);
2136 tree op2
= TREE_OPERAND (expr
, 2);
2138 if ((TREE_CODE (op1
) == REAL_CST
|| TREE_CODE (op1
) == INTEGER_CST
2139 || TREE_CODE (op1
) == COND_EXPR
)
2140 && (TREE_CODE (op2
) == REAL_CST
|| TREE_CODE (op2
) == INTEGER_CST
2141 || TREE_CODE (op2
) == COND_EXPR
))
2143 conversion_warning (type
, op1
);
2144 conversion_warning (type
, op2
);
2150 default: /* 'expr' is not a constant. */
2152 /* Warn for real types converted to integer types. */
2153 if (TREE_CODE (expr_type
) == REAL_TYPE
2154 && TREE_CODE (type
) == INTEGER_TYPE
)
2155 give_warning
= true;
2157 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2158 && TREE_CODE (type
) == INTEGER_TYPE
)
2160 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2161 expr
= get_unwidened (expr
, 0);
2162 expr_type
= TREE_TYPE (expr
);
2164 /* Don't warn for short y; short x = ((int)y & 0xff); */
2165 if (TREE_CODE (expr
) == BIT_AND_EXPR
2166 || TREE_CODE (expr
) == BIT_IOR_EXPR
2167 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
2169 /* If both args were extended from a shortest type,
2170 use that type if that is safe. */
2171 expr_type
= shorten_binary_op (expr_type
,
2172 TREE_OPERAND (expr
, 0),
2173 TREE_OPERAND (expr
, 1),
2176 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
2178 tree op0
= TREE_OPERAND (expr
, 0);
2179 tree op1
= TREE_OPERAND (expr
, 1);
2180 bool unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2181 bool unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2183 /* If one of the operands is a non-negative constant
2184 that fits in the target type, then the type of the
2185 other operand does not matter. */
2186 if ((TREE_CODE (op0
) == INTEGER_CST
2187 && int_fits_type_p (op0
, c_common_signed_type (type
))
2188 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
2189 || (TREE_CODE (op1
) == INTEGER_CST
2190 && int_fits_type_p (op1
, c_common_signed_type (type
))
2191 && int_fits_type_p (op1
,
2192 c_common_unsigned_type (type
))))
2194 /* If constant is unsigned and fits in the target
2195 type, then the result will also fit. */
2196 else if ((TREE_CODE (op0
) == INTEGER_CST
2198 && int_fits_type_p (op0
, type
))
2199 || (TREE_CODE (op1
) == INTEGER_CST
2201 && int_fits_type_p (op1
, type
)))
2205 /* Warn for integer types converted to smaller integer types. */
2206 if (TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2207 give_warning
= true;
2209 /* When they are the same width but different signedness,
2210 then the value may change. */
2211 else if ((TYPE_PRECISION (type
) == TYPE_PRECISION (expr_type
)
2212 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
2213 /* Even when converted to a bigger type, if the type is
2214 unsigned but expr is signed, then negative values
2216 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
2217 warning (OPT_Wsign_conversion
, "conversion to %qT from %qT "
2218 "may change the sign of the result",
2222 /* Warn for integer types converted to real types if and only if
2223 all the range of values of the integer type cannot be
2224 represented by the real type. */
2225 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2226 && TREE_CODE (type
) == REAL_TYPE
)
2228 tree type_low_bound
= TYPE_MIN_VALUE (expr_type
);
2229 tree type_high_bound
= TYPE_MAX_VALUE (expr_type
);
2230 REAL_VALUE_TYPE real_low_bound
2231 = real_value_from_int_cst (0, type_low_bound
);
2232 REAL_VALUE_TYPE real_high_bound
2233 = real_value_from_int_cst (0, type_high_bound
);
2235 if (!exact_real_truncate (TYPE_MODE (type
), &real_low_bound
)
2236 || !exact_real_truncate (TYPE_MODE (type
), &real_high_bound
))
2237 give_warning
= true;
2240 /* Warn for real types converted to smaller real types. */
2241 else if (TREE_CODE (expr_type
) == REAL_TYPE
2242 && TREE_CODE (type
) == REAL_TYPE
2243 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2244 give_warning
= true;
2248 warning (OPT_Wconversion
,
2249 "conversion to %qT from %qT may alter its value",
2254 /* Produce warnings after a conversion. RESULT is the result of
2255 converting EXPR to TYPE. This is a helper function for
2256 convert_and_check and cp_convert_and_check. */
2259 warnings_for_convert_and_check (tree type
, tree expr
, tree result
)
2261 if (TREE_CODE (expr
) == INTEGER_CST
2262 && (TREE_CODE (type
) == INTEGER_TYPE
2263 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2264 && !int_fits_type_p (expr
, type
))
2266 /* Do not diagnose overflow in a constant expression merely
2267 because a conversion overflowed. */
2268 if (TREE_OVERFLOW (result
))
2269 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
2271 if (TYPE_UNSIGNED (type
))
2273 /* This detects cases like converting -129 or 256 to
2275 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
2276 warning (OPT_Woverflow
,
2277 "large integer implicitly truncated to unsigned type");
2279 conversion_warning (type
, expr
);
2281 else if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
2282 warning (OPT_Woverflow
,
2283 "overflow in implicit constant conversion");
2284 /* No warning for converting 0x80000000 to int. */
2286 && (TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
2287 || TYPE_PRECISION (TREE_TYPE (expr
))
2288 != TYPE_PRECISION (type
)))
2289 warning (OPT_Woverflow
,
2290 "overflow in implicit constant conversion");
2293 conversion_warning (type
, expr
);
2295 else if ((TREE_CODE (result
) == INTEGER_CST
2296 || TREE_CODE (result
) == FIXED_CST
) && TREE_OVERFLOW (result
))
2297 warning (OPT_Woverflow
,
2298 "overflow in implicit constant conversion");
2300 conversion_warning (type
, expr
);
2304 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2305 Invoke this function on every expression that is converted implicitly,
2306 i.e. because of language rules and not because of an explicit cast. */
2309 convert_and_check (tree type
, tree expr
)
2312 tree expr_for_warning
;
2314 /* Convert from a value with possible excess precision rather than
2315 via the semantic type, but do not warn about values not fitting
2316 exactly in the semantic type. */
2317 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
2319 tree orig_type
= TREE_TYPE (expr
);
2320 expr
= TREE_OPERAND (expr
, 0);
2321 expr_for_warning
= convert (orig_type
, expr
);
2322 if (orig_type
== type
)
2323 return expr_for_warning
;
2326 expr_for_warning
= expr
;
2328 if (TREE_TYPE (expr
) == type
)
2331 result
= convert (type
, expr
);
2333 if (!skip_evaluation
&& !TREE_OVERFLOW_P (expr
) && result
!= error_mark_node
)
2334 warnings_for_convert_and_check (type
, expr_for_warning
, result
);
2339 /* A node in a list that describes references to variables (EXPR), which are
2340 either read accesses if WRITER is zero, or write accesses, in which case
2341 WRITER is the parent of EXPR. */
2348 /* Used to implement a cache the results of a call to verify_tree. We only
2349 use this for SAVE_EXPRs. */
2352 struct tlist_cache
*next
;
2353 struct tlist
*cache_before_sp
;
2354 struct tlist
*cache_after_sp
;
2358 /* Obstack to use when allocating tlist structures, and corresponding
2360 static struct obstack tlist_obstack
;
2361 static char *tlist_firstobj
= 0;
2363 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2365 static struct tlist
*warned_ids
;
2366 /* SAVE_EXPRs need special treatment. We process them only once and then
2367 cache the results. */
2368 static struct tlist_cache
*save_expr_cache
;
2370 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
2371 static void merge_tlist (struct tlist
**, struct tlist
*, int);
2372 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
2373 static int warning_candidate_p (tree
);
2374 static void warn_for_collisions (struct tlist
*);
2375 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
2376 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
2378 /* Create a new struct tlist and fill in its fields. */
2379 static struct tlist
*
2380 new_tlist (struct tlist
*next
, tree t
, tree writer
)
2383 l
= XOBNEW (&tlist_obstack
, struct tlist
);
2390 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2391 is nonnull, we ignore any node we find which has a writer equal to it. */
2394 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
2398 struct tlist
*next
= add
->next
;
2401 if (!exclude_writer
|| add
->writer
!= exclude_writer
)
2402 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
2407 /* Merge the nodes of ADD into TO. This merging process is done so that for
2408 each variable that already exists in TO, no new node is added; however if
2409 there is a write access recorded in ADD, and an occurrence on TO is only
2410 a read access, then the occurrence in TO will be modified to record the
2414 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
2416 struct tlist
**end
= to
;
2419 end
= &(*end
)->next
;
2425 struct tlist
*next
= add
->next
;
2427 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
2428 if (tmp2
->expr
== add
->expr
)
2432 tmp2
->writer
= add
->writer
;
2436 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
2437 end
= &(*end
)->next
;
2444 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2445 references in list LIST conflict with it, excluding reads if ONLY writers
2449 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
2454 /* Avoid duplicate warnings. */
2455 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
2456 if (tmp
->expr
== written
)
2461 if (list
->expr
== written
2462 && list
->writer
!= writer
2463 && (!only_writes
|| list
->writer
)
2464 && DECL_NAME (list
->expr
))
2466 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
2467 warning_at (EXPR_HAS_LOCATION (writer
)
2468 ? EXPR_LOCATION (writer
) : input_location
,
2469 OPT_Wsequence_point
, "operation on %qE may be undefined",
2476 /* Given a list LIST of references to variables, find whether any of these
2477 can cause conflicts due to missing sequence points. */
2480 warn_for_collisions (struct tlist
*list
)
2484 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
2487 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
2491 /* Return nonzero if X is a tree that can be verified by the sequence point
2494 warning_candidate_p (tree x
)
2496 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
2499 /* Walk the tree X, and record accesses to variables. If X is written by the
2500 parent tree, WRITER is the parent.
2501 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2502 expression or its only operand forces a sequence point, then everything up
2503 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2505 Once we return, we will have emitted warnings if any subexpression before
2506 such a sequence point could be undefined. On a higher level, however, the
2507 sequence point may not be relevant, and we'll merge the two lists.
2509 Example: (b++, a) + b;
2510 The call that processes the COMPOUND_EXPR will store the increment of B
2511 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2512 processes the PLUS_EXPR will need to merge the two lists so that
2513 eventually, all accesses end up on the same list (and we'll warn about the
2514 unordered subexpressions b++ and b.
2516 A note on merging. If we modify the former example so that our expression
2519 care must be taken not simply to add all three expressions into the final
2520 PNO_SP list. The function merge_tlist takes care of that by merging the
2521 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2522 way, so that no more than one access to B is recorded. */
2525 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
2528 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
2529 enum tree_code code
;
2530 enum tree_code_class cl
;
2532 /* X may be NULL if it is the operand of an empty statement expression
2538 code
= TREE_CODE (x
);
2539 cl
= TREE_CODE_CLASS (code
);
2541 if (warning_candidate_p (x
))
2543 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
2553 case TRUTH_ANDIF_EXPR
:
2554 case TRUTH_ORIF_EXPR
:
2555 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2556 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2557 warn_for_collisions (tmp_nosp
);
2558 merge_tlist (pbefore_sp
, tmp_before
, 0);
2559 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
2560 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
2561 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2565 tmp_before
= tmp_list2
= 0;
2566 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
2567 warn_for_collisions (tmp_list2
);
2568 merge_tlist (pbefore_sp
, tmp_before
, 0);
2569 merge_tlist (pbefore_sp
, tmp_list2
, 1);
2571 tmp_list3
= tmp_nosp
= 0;
2572 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
2573 warn_for_collisions (tmp_nosp
);
2574 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2576 tmp_list3
= tmp_list2
= 0;
2577 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
2578 warn_for_collisions (tmp_list2
);
2579 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2580 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2581 two first, to avoid warning for (a ? b++ : b++). */
2582 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
2583 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2586 case PREDECREMENT_EXPR
:
2587 case PREINCREMENT_EXPR
:
2588 case POSTDECREMENT_EXPR
:
2589 case POSTINCREMENT_EXPR
:
2590 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
2594 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2595 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2596 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
2597 /* Expressions inside the LHS are not ordered wrt. the sequence points
2598 in the RHS. Example:
2600 Despite the fact that the modification of "a" is in the before_sp
2601 list (tmp_before), it conflicts with the use of "a" in the LHS.
2602 We can handle this by adding the contents of tmp_list3
2603 to those of tmp_before, and redoing the collision warnings for that
2605 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
2606 warn_for_collisions (tmp_before
);
2607 /* Exclude the LHS itself here; we first have to merge it into the
2608 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2609 didn't exclude the LHS, we'd get it twice, once as a read and once
2611 add_tlist (pno_sp
, tmp_list3
, x
, 0);
2612 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
2614 merge_tlist (pbefore_sp
, tmp_before
, 0);
2615 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
2616 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
2617 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
2621 /* We need to warn about conflicts among arguments and conflicts between
2622 args and the function address. Side effects of the function address,
2623 however, are not ordered by the sequence point of the call. */
2625 call_expr_arg_iterator iter
;
2627 tmp_before
= tmp_nosp
= 0;
2628 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2629 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
2631 tmp_list2
= tmp_list3
= 0;
2632 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
2633 merge_tlist (&tmp_list3
, tmp_list2
, 0);
2634 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
2636 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
2637 warn_for_collisions (tmp_before
);
2638 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
2643 /* Scan all the list, e.g. indices of multi dimensional array. */
2646 tmp_before
= tmp_nosp
= 0;
2647 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2648 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2649 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2656 struct tlist_cache
*t
;
2657 for (t
= save_expr_cache
; t
; t
= t
->next
)
2663 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
2664 t
->next
= save_expr_cache
;
2666 save_expr_cache
= t
;
2668 tmp_before
= tmp_nosp
= 0;
2669 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2670 warn_for_collisions (tmp_nosp
);
2675 struct tlist
*t
= tmp_nosp
;
2677 merge_tlist (&tmp_list3
, t
, 0);
2679 t
->cache_before_sp
= tmp_before
;
2680 t
->cache_after_sp
= tmp_list3
;
2682 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
2683 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
2688 x
= TREE_OPERAND (x
, 0);
2695 /* For other expressions, simply recurse on their operands.
2696 Manual tail recursion for unary expressions.
2697 Other non-expressions need not be processed. */
2698 if (cl
== tcc_unary
)
2700 x
= TREE_OPERAND (x
, 0);
2704 else if (IS_EXPR_CODE_CLASS (cl
))
2707 int max
= TREE_OPERAND_LENGTH (x
);
2708 for (lp
= 0; lp
< max
; lp
++)
2710 tmp_before
= tmp_nosp
= 0;
2711 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
2712 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2713 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2720 /* Try to warn for undefined behavior in EXPR due to missing sequence
2724 verify_sequence_points (tree expr
)
2726 struct tlist
*before_sp
= 0, *after_sp
= 0;
2729 save_expr_cache
= 0;
2730 if (tlist_firstobj
== 0)
2732 gcc_obstack_init (&tlist_obstack
);
2733 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
2736 verify_tree (expr
, &before_sp
, &after_sp
, 0);
2737 warn_for_collisions (after_sp
);
2738 obstack_free (&tlist_obstack
, tlist_firstobj
);
2741 /* Validate the expression after `case' and apply default promotions. */
2744 check_case_value (tree value
)
2746 if (value
== NULL_TREE
)
2749 /* ??? Can we ever get nops here for a valid case value? We
2751 STRIP_TYPE_NOPS (value
);
2752 /* In C++, the following is allowed:
2755 switch (...) { case i: ... }
2757 So, we try to reduce the VALUE to a constant that way. */
2758 if (c_dialect_cxx ())
2760 value
= decl_constant_value (value
);
2761 STRIP_TYPE_NOPS (value
);
2762 value
= fold (value
);
2765 if (TREE_CODE (value
) == INTEGER_CST
)
2766 /* Promote char or short to int. */
2767 value
= perform_integral_promotions (value
);
2768 else if (value
!= error_mark_node
)
2770 error ("case label does not reduce to an integer constant");
2771 value
= error_mark_node
;
2774 constant_expression_warning (value
);
2779 /* See if the case values LOW and HIGH are in the range of the original
2780 type (i.e. before the default conversion to int) of the switch testing
2782 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2783 the type before promoting it. CASE_LOW_P is a pointer to the lower
2784 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2785 if the case is not a case range.
2786 The caller has to make sure that we are not called with NULL for
2787 CASE_LOW_P (i.e. the default case).
2788 Returns true if the case label is in range of ORIG_TYPE (saturated or
2789 untouched) or false if the label is out of range. */
2792 check_case_bounds (tree type
, tree orig_type
,
2793 tree
*case_low_p
, tree
*case_high_p
)
2795 tree min_value
, max_value
;
2796 tree case_low
= *case_low_p
;
2797 tree case_high
= case_high_p
? *case_high_p
: case_low
;
2799 /* If there was a problem with the original type, do nothing. */
2800 if (orig_type
== error_mark_node
)
2803 min_value
= TYPE_MIN_VALUE (orig_type
);
2804 max_value
= TYPE_MAX_VALUE (orig_type
);
2806 /* Case label is less than minimum for type. */
2807 if (tree_int_cst_compare (case_low
, min_value
) < 0
2808 && tree_int_cst_compare (case_high
, min_value
) < 0)
2810 warning (0, "case label value is less than minimum value for type");
2814 /* Case value is greater than maximum for type. */
2815 if (tree_int_cst_compare (case_low
, max_value
) > 0
2816 && tree_int_cst_compare (case_high
, max_value
) > 0)
2818 warning (0, "case label value exceeds maximum value for type");
2822 /* Saturate lower case label value to minimum. */
2823 if (tree_int_cst_compare (case_high
, min_value
) >= 0
2824 && tree_int_cst_compare (case_low
, min_value
) < 0)
2826 warning (0, "lower value in case label range"
2827 " less than minimum value for type");
2828 case_low
= min_value
;
2831 /* Saturate upper case label value to maximum. */
2832 if (tree_int_cst_compare (case_low
, max_value
) <= 0
2833 && tree_int_cst_compare (case_high
, max_value
) > 0)
2835 warning (0, "upper value in case label range"
2836 " exceeds maximum value for type");
2837 case_high
= max_value
;
2840 if (*case_low_p
!= case_low
)
2841 *case_low_p
= convert (type
, case_low
);
2842 if (case_high_p
&& *case_high_p
!= case_high
)
2843 *case_high_p
= convert (type
, case_high
);
2848 /* Return an integer type with BITS bits of precision,
2849 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2852 c_common_type_for_size (unsigned int bits
, int unsignedp
)
2854 if (bits
== TYPE_PRECISION (integer_type_node
))
2855 return unsignedp
? unsigned_type_node
: integer_type_node
;
2857 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2858 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2860 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2861 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2863 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2864 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2866 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2867 return (unsignedp
? long_long_unsigned_type_node
2868 : long_long_integer_type_node
);
2870 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2871 return (unsignedp
? widest_unsigned_literal_type_node
2872 : widest_integer_literal_type_node
);
2874 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2875 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2877 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2878 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2880 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2881 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2883 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2884 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2889 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2890 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2891 and saturating if SATP is nonzero, otherwise not saturating. */
2894 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
2895 int unsignedp
, int satp
)
2897 enum machine_mode mode
;
2899 mode
= unsignedp
? UQQmode
: QQmode
;
2901 mode
= unsignedp
? UHAmode
: HAmode
;
2903 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
2904 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2907 if (mode
== VOIDmode
|| !targetm
.scalar_mode_supported_p (mode
))
2909 sorry ("GCC cannot support operators with integer types and "
2910 "fixed-point types that have too many integral and "
2911 "fractional bits together");
2915 return c_common_type_for_mode (mode
, satp
);
2918 /* Used for communication between c_common_type_for_mode and
2919 c_register_builtin_type. */
2920 static GTY(()) tree registered_builtin_types
;
2922 /* Return a data type that has machine mode MODE.
2923 If the mode is an integer,
2924 then UNSIGNEDP selects between signed and unsigned types.
2925 If the mode is a fixed-point mode,
2926 then UNSIGNEDP selects between saturating and nonsaturating types. */
2929 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
2933 if (mode
== TYPE_MODE (integer_type_node
))
2934 return unsignedp
? unsigned_type_node
: integer_type_node
;
2936 if (mode
== TYPE_MODE (signed_char_type_node
))
2937 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2939 if (mode
== TYPE_MODE (short_integer_type_node
))
2940 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2942 if (mode
== TYPE_MODE (long_integer_type_node
))
2943 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2945 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2946 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2948 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2949 return unsignedp
? widest_unsigned_literal_type_node
2950 : widest_integer_literal_type_node
;
2953 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2956 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2959 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2962 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2964 #if HOST_BITS_PER_WIDE_INT >= 64
2965 if (mode
== TYPE_MODE (intTI_type_node
))
2966 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2969 if (mode
== TYPE_MODE (float_type_node
))
2970 return float_type_node
;
2972 if (mode
== TYPE_MODE (double_type_node
))
2973 return double_type_node
;
2975 if (mode
== TYPE_MODE (long_double_type_node
))
2976 return long_double_type_node
;
2978 if (mode
== TYPE_MODE (void_type_node
))
2979 return void_type_node
;
2981 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2983 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2984 : make_signed_type (GET_MODE_PRECISION (mode
)));
2986 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2988 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2989 : make_signed_type (GET_MODE_PRECISION (mode
)));
2991 if (COMPLEX_MODE_P (mode
))
2993 enum machine_mode inner_mode
;
2996 if (mode
== TYPE_MODE (complex_float_type_node
))
2997 return complex_float_type_node
;
2998 if (mode
== TYPE_MODE (complex_double_type_node
))
2999 return complex_double_type_node
;
3000 if (mode
== TYPE_MODE (complex_long_double_type_node
))
3001 return complex_long_double_type_node
;
3003 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
3004 return complex_integer_type_node
;
3006 inner_mode
= GET_MODE_INNER (mode
);
3007 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
3008 if (inner_type
!= NULL_TREE
)
3009 return build_complex_type (inner_type
);
3011 else if (VECTOR_MODE_P (mode
))
3013 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
3014 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
3015 if (inner_type
!= NULL_TREE
)
3016 return build_vector_type_for_mode (inner_type
, mode
);
3019 if (mode
== TYPE_MODE (dfloat32_type_node
))
3020 return dfloat32_type_node
;
3021 if (mode
== TYPE_MODE (dfloat64_type_node
))
3022 return dfloat64_type_node
;
3023 if (mode
== TYPE_MODE (dfloat128_type_node
))
3024 return dfloat128_type_node
;
3026 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
3028 if (mode
== TYPE_MODE (short_fract_type_node
))
3029 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
3030 if (mode
== TYPE_MODE (fract_type_node
))
3031 return unsignedp
? sat_fract_type_node
: fract_type_node
;
3032 if (mode
== TYPE_MODE (long_fract_type_node
))
3033 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
3034 if (mode
== TYPE_MODE (long_long_fract_type_node
))
3035 return unsignedp
? sat_long_long_fract_type_node
3036 : long_long_fract_type_node
;
3038 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
3039 return unsignedp
? sat_unsigned_short_fract_type_node
3040 : unsigned_short_fract_type_node
;
3041 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
3042 return unsignedp
? sat_unsigned_fract_type_node
3043 : unsigned_fract_type_node
;
3044 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
3045 return unsignedp
? sat_unsigned_long_fract_type_node
3046 : unsigned_long_fract_type_node
;
3047 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
3048 return unsignedp
? sat_unsigned_long_long_fract_type_node
3049 : unsigned_long_long_fract_type_node
;
3051 if (mode
== TYPE_MODE (short_accum_type_node
))
3052 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
3053 if (mode
== TYPE_MODE (accum_type_node
))
3054 return unsignedp
? sat_accum_type_node
: accum_type_node
;
3055 if (mode
== TYPE_MODE (long_accum_type_node
))
3056 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
3057 if (mode
== TYPE_MODE (long_long_accum_type_node
))
3058 return unsignedp
? sat_long_long_accum_type_node
3059 : long_long_accum_type_node
;
3061 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
3062 return unsignedp
? sat_unsigned_short_accum_type_node
3063 : unsigned_short_accum_type_node
;
3064 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
3065 return unsignedp
? sat_unsigned_accum_type_node
3066 : unsigned_accum_type_node
;
3067 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
3068 return unsignedp
? sat_unsigned_long_accum_type_node
3069 : unsigned_long_accum_type_node
;
3070 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
3071 return unsignedp
? sat_unsigned_long_long_accum_type_node
3072 : unsigned_long_long_accum_type_node
;
3075 return unsignedp
? sat_qq_type_node
: qq_type_node
;
3077 return unsignedp
? sat_hq_type_node
: hq_type_node
;
3079 return unsignedp
? sat_sq_type_node
: sq_type_node
;
3081 return unsignedp
? sat_dq_type_node
: dq_type_node
;
3083 return unsignedp
? sat_tq_type_node
: tq_type_node
;
3085 if (mode
== UQQmode
)
3086 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
3087 if (mode
== UHQmode
)
3088 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
3089 if (mode
== USQmode
)
3090 return unsignedp
? sat_usq_type_node
: usq_type_node
;
3091 if (mode
== UDQmode
)
3092 return unsignedp
? sat_udq_type_node
: udq_type_node
;
3093 if (mode
== UTQmode
)
3094 return unsignedp
? sat_utq_type_node
: utq_type_node
;
3097 return unsignedp
? sat_ha_type_node
: ha_type_node
;
3099 return unsignedp
? sat_sa_type_node
: sa_type_node
;
3101 return unsignedp
? sat_da_type_node
: da_type_node
;
3103 return unsignedp
? sat_ta_type_node
: ta_type_node
;
3105 if (mode
== UHAmode
)
3106 return unsignedp
? sat_uha_type_node
: uha_type_node
;
3107 if (mode
== USAmode
)
3108 return unsignedp
? sat_usa_type_node
: usa_type_node
;
3109 if (mode
== UDAmode
)
3110 return unsignedp
? sat_uda_type_node
: uda_type_node
;
3111 if (mode
== UTAmode
)
3112 return unsignedp
? sat_uta_type_node
: uta_type_node
;
3115 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
3116 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
3117 return TREE_VALUE (t
);
3123 c_common_unsigned_type (tree type
)
3125 return c_common_signed_or_unsigned_type (1, type
);
3128 /* Return a signed type the same as TYPE in other respects. */
3131 c_common_signed_type (tree type
)
3133 return c_common_signed_or_unsigned_type (0, type
);
3136 /* Return a type the same as TYPE except unsigned or
3137 signed according to UNSIGNEDP. */
3140 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
3144 /* This block of code emulates the behavior of the old
3145 c_common_unsigned_type. In particular, it returns
3146 long_unsigned_type_node if passed a long, even when a int would
3147 have the same size. This is necessary for warnings to work
3148 correctly in archs where sizeof(int) == sizeof(long) */
3150 type1
= TYPE_MAIN_VARIANT (type
);
3151 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
3152 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3153 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
3154 return unsignedp
? unsigned_type_node
: integer_type_node
;
3155 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
3156 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3157 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
3158 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3159 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
3160 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
3161 if (type1
== widest_integer_literal_type_node
|| type1
== widest_unsigned_literal_type_node
)
3162 return unsignedp
? widest_unsigned_literal_type_node
: widest_integer_literal_type_node
;
3163 #if HOST_BITS_PER_WIDE_INT >= 64
3164 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
3165 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3167 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
3168 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3169 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
3170 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3171 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
3172 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3173 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
3174 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3176 #define C_COMMON_FIXED_TYPES(NAME) \
3177 if (type1 == short_ ## NAME ## _type_node \
3178 || type1 == unsigned_short_ ## NAME ## _type_node) \
3179 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3180 : short_ ## NAME ## _type_node; \
3181 if (type1 == NAME ## _type_node \
3182 || type1 == unsigned_ ## NAME ## _type_node) \
3183 return unsignedp ? unsigned_ ## NAME ## _type_node \
3184 : NAME ## _type_node; \
3185 if (type1 == long_ ## NAME ## _type_node \
3186 || type1 == unsigned_long_ ## NAME ## _type_node) \
3187 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3188 : long_ ## NAME ## _type_node; \
3189 if (type1 == long_long_ ## NAME ## _type_node \
3190 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3191 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3192 : long_long_ ## NAME ## _type_node;
3194 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3195 if (type1 == NAME ## _type_node \
3196 || type1 == u ## NAME ## _type_node) \
3197 return unsignedp ? u ## NAME ## _type_node \
3198 : NAME ## _type_node;
3200 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3201 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3202 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3203 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3204 : sat_ ## short_ ## NAME ## _type_node; \
3205 if (type1 == sat_ ## NAME ## _type_node \
3206 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3207 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3208 : sat_ ## NAME ## _type_node; \
3209 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3210 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3211 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3212 : sat_ ## long_ ## NAME ## _type_node; \
3213 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3214 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3215 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3216 : sat_ ## long_long_ ## NAME ## _type_node;
3218 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3219 if (type1 == sat_ ## NAME ## _type_node \
3220 || type1 == sat_ ## u ## NAME ## _type_node) \
3221 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3222 : sat_ ## NAME ## _type_node;
3224 C_COMMON_FIXED_TYPES (fract
);
3225 C_COMMON_FIXED_TYPES_SAT (fract
);
3226 C_COMMON_FIXED_TYPES (accum
);
3227 C_COMMON_FIXED_TYPES_SAT (accum
);
3229 C_COMMON_FIXED_MODE_TYPES (qq
);
3230 C_COMMON_FIXED_MODE_TYPES (hq
);
3231 C_COMMON_FIXED_MODE_TYPES (sq
);
3232 C_COMMON_FIXED_MODE_TYPES (dq
);
3233 C_COMMON_FIXED_MODE_TYPES (tq
);
3234 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
3235 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
3236 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
3237 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
3238 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
3239 C_COMMON_FIXED_MODE_TYPES (ha
);
3240 C_COMMON_FIXED_MODE_TYPES (sa
);
3241 C_COMMON_FIXED_MODE_TYPES (da
);
3242 C_COMMON_FIXED_MODE_TYPES (ta
);
3243 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
3244 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
3245 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
3246 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
3248 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3249 the precision; they have precision set to match their range, but
3250 may use a wider mode to match an ABI. If we change modes, we may
3251 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3252 the precision as well, so as to yield correct results for
3253 bit-field types. C++ does not have these separate bit-field
3254 types, and producing a signed or unsigned variant of an
3255 ENUMERAL_TYPE may cause other problems as well. */
3257 if (!INTEGRAL_TYPE_P (type
)
3258 || TYPE_UNSIGNED (type
) == unsignedp
)
3261 #define TYPE_OK(node) \
3262 (TYPE_MODE (type) == TYPE_MODE (node) \
3263 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3264 if (TYPE_OK (signed_char_type_node
))
3265 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3266 if (TYPE_OK (integer_type_node
))
3267 return unsignedp
? unsigned_type_node
: integer_type_node
;
3268 if (TYPE_OK (short_integer_type_node
))
3269 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3270 if (TYPE_OK (long_integer_type_node
))
3271 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3272 if (TYPE_OK (long_long_integer_type_node
))
3273 return (unsignedp
? long_long_unsigned_type_node
3274 : long_long_integer_type_node
);
3275 if (TYPE_OK (widest_integer_literal_type_node
))
3276 return (unsignedp
? widest_unsigned_literal_type_node
3277 : widest_integer_literal_type_node
);
3279 #if HOST_BITS_PER_WIDE_INT >= 64
3280 if (TYPE_OK (intTI_type_node
))
3281 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3283 if (TYPE_OK (intDI_type_node
))
3284 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3285 if (TYPE_OK (intSI_type_node
))
3286 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3287 if (TYPE_OK (intHI_type_node
))
3288 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3289 if (TYPE_OK (intQI_type_node
))
3290 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3293 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
3296 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3299 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
3301 /* Extended integer types of the same width as a standard type have
3302 lesser rank, so those of the same width as int promote to int or
3303 unsigned int and are valid for printf formats expecting int or
3304 unsigned int. To avoid such special cases, avoid creating
3305 extended integer types for bit-fields if a standard integer type
3307 if (width
== TYPE_PRECISION (integer_type_node
))
3308 return unsignedp
? unsigned_type_node
: integer_type_node
;
3309 if (width
== TYPE_PRECISION (signed_char_type_node
))
3310 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3311 if (width
== TYPE_PRECISION (short_integer_type_node
))
3312 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3313 if (width
== TYPE_PRECISION (long_integer_type_node
))
3314 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3315 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
3316 return (unsignedp
? long_long_unsigned_type_node
3317 : long_long_integer_type_node
);
3318 return build_nonstandard_integer_type (width
, unsignedp
);
3321 /* The C version of the register_builtin_type langhook. */
3324 c_register_builtin_type (tree type
, const char* name
)
3328 decl
= build_decl (TYPE_DECL
, get_identifier (name
), type
);
3329 DECL_ARTIFICIAL (decl
) = 1;
3330 if (!TYPE_NAME (type
))
3331 TYPE_NAME (type
) = decl
;
3334 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
3337 /* Print an error message for invalid operands to arith operation
3338 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3339 LOCATION is the location of the message. */
3342 binary_op_error (location_t location
, enum tree_code code
,
3343 tree type0
, tree type1
)
3350 opname
= "+"; break;
3352 opname
= "-"; break;
3354 opname
= "*"; break;
3356 opname
= "max"; break;
3358 opname
= "min"; break;
3360 opname
= "=="; break;
3362 opname
= "!="; break;
3364 opname
= "<="; break;
3366 opname
= ">="; break;
3368 opname
= "<"; break;
3370 opname
= ">"; break;
3372 opname
= "<<"; break;
3374 opname
= ">>"; break;
3375 case TRUNC_MOD_EXPR
:
3376 case FLOOR_MOD_EXPR
:
3377 opname
= "%"; break;
3378 case TRUNC_DIV_EXPR
:
3379 case FLOOR_DIV_EXPR
:
3380 opname
= "/"; break;
3382 opname
= "&"; break;
3384 opname
= "|"; break;
3385 case TRUTH_ANDIF_EXPR
:
3386 opname
= "&&"; break;
3387 case TRUTH_ORIF_EXPR
:
3388 opname
= "||"; break;
3390 opname
= "^"; break;
3395 "invalid operands to binary %s (have %qT and %qT)", opname
,
3399 /* Subroutine of build_binary_op, used for comparison operations.
3400 See if the operands have both been converted from subword integer types
3401 and, if so, perhaps change them both back to their original type.
3402 This function is also responsible for converting the two operands
3403 to the proper common type for comparison.
3405 The arguments of this function are all pointers to local variables
3406 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3407 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3409 If this function returns nonzero, it means that the comparison has
3410 a constant value. What this function returns is an expression for
3414 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
3415 enum tree_code
*rescode_ptr
)
3418 tree op0
= *op0_ptr
;
3419 tree op1
= *op1_ptr
;
3420 int unsignedp0
, unsignedp1
;
3422 tree primop0
, primop1
;
3423 enum tree_code code
= *rescode_ptr
;
3425 /* Throw away any conversions to wider types
3426 already present in the operands. */
3428 primop0
= get_narrower (op0
, &unsignedp0
);
3429 primop1
= get_narrower (op1
, &unsignedp1
);
3431 /* Handle the case that OP0 does not *contain* a conversion
3432 but it *requires* conversion to FINAL_TYPE. */
3434 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
3435 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
3436 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
3437 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
3439 /* If one of the operands must be floated, we cannot optimize. */
3440 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
3441 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
3443 /* If first arg is constant, swap the args (changing operation
3444 so value is preserved), for canonicalization. Don't do this if
3445 the second arg is 0. */
3447 if (TREE_CONSTANT (primop0
)
3448 && !integer_zerop (primop1
) && !real_zerop (primop1
)
3449 && !fixed_zerop (primop1
))
3452 int temi
= unsignedp0
;
3460 unsignedp0
= unsignedp1
;
3483 *rescode_ptr
= code
;
3486 /* If comparing an integer against a constant more bits wide,
3487 maybe we can deduce a value of 1 or 0 independent of the data.
3488 Or else truncate the constant now
3489 rather than extend the variable at run time.
3491 This is only interesting if the constant is the wider arg.
3492 Also, it is not safe if the constant is unsigned and the
3493 variable arg is signed, since in this case the variable
3494 would be sign-extended and then regarded as unsigned.
3495 Our technique fails in this case because the lowest/highest
3496 possible unsigned results don't follow naturally from the
3497 lowest/highest possible values of the variable operand.
3498 For just EQ_EXPR and NE_EXPR there is another technique that
3499 could be used: see if the constant can be faithfully represented
3500 in the other operand's type, by truncating it and reextending it
3501 and see if that preserves the constant's value. */
3503 if (!real1
&& !real2
3504 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
3505 && TREE_CODE (primop1
) == INTEGER_CST
3506 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
3508 int min_gt
, max_gt
, min_lt
, max_lt
;
3509 tree maxval
, minval
;
3510 /* 1 if comparison is nominally unsigned. */
3511 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
3514 type
= c_common_signed_or_unsigned_type (unsignedp0
,
3515 TREE_TYPE (primop0
));
3517 maxval
= TYPE_MAX_VALUE (type
);
3518 minval
= TYPE_MIN_VALUE (type
);
3520 if (unsignedp
&& !unsignedp0
)
3521 *restype_ptr
= c_common_signed_type (*restype_ptr
);
3523 if (TREE_TYPE (primop1
) != *restype_ptr
)
3525 /* Convert primop1 to target type, but do not introduce
3526 additional overflow. We know primop1 is an int_cst. */
3527 primop1
= force_fit_type_double (*restype_ptr
,
3528 TREE_INT_CST_LOW (primop1
),
3529 TREE_INT_CST_HIGH (primop1
), 0,
3530 TREE_OVERFLOW (primop1
));
3532 if (type
!= *restype_ptr
)
3534 minval
= convert (*restype_ptr
, minval
);
3535 maxval
= convert (*restype_ptr
, maxval
);
3538 if (unsignedp
&& unsignedp0
)
3540 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
3541 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
3542 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
3543 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
3547 min_gt
= INT_CST_LT (primop1
, minval
);
3548 max_gt
= INT_CST_LT (primop1
, maxval
);
3549 min_lt
= INT_CST_LT (minval
, primop1
);
3550 max_lt
= INT_CST_LT (maxval
, primop1
);
3554 /* This used to be a switch, but Genix compiler can't handle that. */
3555 if (code
== NE_EXPR
)
3557 if (max_lt
|| min_gt
)
3558 val
= truthvalue_true_node
;
3560 else if (code
== EQ_EXPR
)
3562 if (max_lt
|| min_gt
)
3563 val
= truthvalue_false_node
;
3565 else if (code
== LT_EXPR
)
3568 val
= truthvalue_true_node
;
3570 val
= truthvalue_false_node
;
3572 else if (code
== GT_EXPR
)
3575 val
= truthvalue_true_node
;
3577 val
= truthvalue_false_node
;
3579 else if (code
== LE_EXPR
)
3582 val
= truthvalue_true_node
;
3584 val
= truthvalue_false_node
;
3586 else if (code
== GE_EXPR
)
3589 val
= truthvalue_true_node
;
3591 val
= truthvalue_false_node
;
3594 /* If primop0 was sign-extended and unsigned comparison specd,
3595 we did a signed comparison above using the signed type bounds.
3596 But the comparison we output must be unsigned.
3598 Also, for inequalities, VAL is no good; but if the signed
3599 comparison had *any* fixed result, it follows that the
3600 unsigned comparison just tests the sign in reverse
3601 (positive values are LE, negative ones GE).
3602 So we can generate an unsigned comparison
3603 against an extreme value of the signed type. */
3605 if (unsignedp
&& !unsignedp0
)
3612 primop1
= TYPE_MIN_VALUE (type
);
3618 primop1
= TYPE_MAX_VALUE (type
);
3625 type
= c_common_unsigned_type (type
);
3628 if (TREE_CODE (primop0
) != INTEGER_CST
)
3630 if (val
== truthvalue_false_node
)
3631 warning (OPT_Wtype_limits
, "comparison is always false due to limited range of data type");
3632 if (val
== truthvalue_true_node
)
3633 warning (OPT_Wtype_limits
, "comparison is always true due to limited range of data type");
3638 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3639 if (TREE_SIDE_EFFECTS (primop0
))
3640 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
3644 /* Value is not predetermined, but do the comparison
3645 in the type of the operand that is not constant.
3646 TYPE is already properly set. */
3649 /* If either arg is decimal float and the other is float, find the
3650 proper common type to use for comparison. */
3651 else if (real1
&& real2
3652 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3653 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
3654 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3656 else if (real1
&& real2
3657 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3658 == TYPE_PRECISION (TREE_TYPE (primop1
))))
3659 type
= TREE_TYPE (primop0
);
3661 /* If args' natural types are both narrower than nominal type
3662 and both extend in the same manner, compare them
3663 in the type of the wider arg.
3664 Otherwise must actually extend both to the nominal
3665 common type lest different ways of extending
3667 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3669 else if (unsignedp0
== unsignedp1
&& real1
== real2
3670 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
3671 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
3673 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3674 type
= c_common_signed_or_unsigned_type (unsignedp0
3675 || TYPE_UNSIGNED (*restype_ptr
),
3677 /* Make sure shorter operand is extended the right way
3678 to match the longer operand. */
3680 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
3681 TREE_TYPE (primop0
)),
3684 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
3685 TREE_TYPE (primop1
)),
3690 /* Here we must do the comparison on the nominal type
3691 using the args exactly as we received them. */
3692 type
= *restype_ptr
;
3696 if (!real1
&& !real2
&& integer_zerop (primop1
)
3697 && TYPE_UNSIGNED (*restype_ptr
))
3703 /* All unsigned values are >= 0, so we warn. However,
3704 if OP0 is a constant that is >= 0, the signedness of
3705 the comparison isn't an issue, so suppress the
3707 if (warn_type_limits
&& !in_system_header
3708 && !(TREE_CODE (primop0
) == INTEGER_CST
3709 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3711 warning (OPT_Wtype_limits
,
3712 "comparison of unsigned expression >= 0 is always true");
3713 value
= truthvalue_true_node
;
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 false");
3723 value
= truthvalue_false_node
;
3732 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3733 if (TREE_SIDE_EFFECTS (primop0
))
3734 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3741 *op0_ptr
= convert (type
, primop0
);
3742 *op1_ptr
= convert (type
, primop1
);
3744 *restype_ptr
= truthvalue_type_node
;
3749 /* Return a tree for the sum or difference (RESULTCODE says which)
3750 of pointer PTROP and integer INTOP. */
3753 pointer_int_sum (location_t location
, enum tree_code resultcode
,
3754 tree ptrop
, tree intop
)
3758 /* The result is a pointer of the same type that is being added. */
3759 tree result_type
= TREE_TYPE (ptrop
);
3761 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3763 pedwarn (location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3764 "pointer of type %<void *%> used in arithmetic");
3765 size_exp
= integer_one_node
;
3767 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3769 pedwarn (location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3770 "pointer to a function used in arithmetic");
3771 size_exp
= integer_one_node
;
3773 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3775 pedwarn (location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3776 "pointer to member function used in arithmetic");
3777 size_exp
= integer_one_node
;
3780 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3782 /* We are manipulating pointer values, so we don't need to warn
3783 about relying on undefined signed overflow. We disable the
3784 warning here because we use integer types so fold won't know that
3785 they are really pointers. */
3786 fold_defer_overflow_warnings ();
3788 /* If what we are about to multiply by the size of the elements
3789 contains a constant term, apply distributive law
3790 and multiply that constant term separately.
3791 This helps produce common subexpressions. */
3792 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3793 && !TREE_CONSTANT (intop
)
3794 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3795 && TREE_CONSTANT (size_exp
)
3796 /* If the constant comes from pointer subtraction,
3797 skip this optimization--it would cause an error. */
3798 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
3799 /* If the constant is unsigned, and smaller than the pointer size,
3800 then we must skip this optimization. This is because it could cause
3801 an overflow error if the constant is negative but INTOP is not. */
3802 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
3803 || (TYPE_PRECISION (TREE_TYPE (intop
))
3804 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
3806 enum tree_code subcode
= resultcode
;
3807 tree int_type
= TREE_TYPE (intop
);
3808 if (TREE_CODE (intop
) == MINUS_EXPR
)
3809 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3810 /* Convert both subexpression types to the type of intop,
3811 because weird cases involving pointer arithmetic
3812 can result in a sum or difference with different type args. */
3813 ptrop
= build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop
, 1)),
3815 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
3816 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
3819 /* Convert the integer argument to a type the same size as sizetype
3820 so the multiply won't overflow spuriously. */
3821 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
3822 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
3823 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
3824 TYPE_UNSIGNED (sizetype
)), intop
);
3826 /* Replace the integer argument with a suitable product by the object size.
3827 Do this multiplication as signed, then convert to the appropriate
3828 type for the pointer operation. */
3829 intop
= convert (sizetype
,
3830 build_binary_op (EXPR_LOCATION (intop
),
3832 convert (TREE_TYPE (intop
), size_exp
), 1));
3834 /* Create the sum or difference. */
3835 if (resultcode
== MINUS_EXPR
)
3836 intop
= fold_build1 (NEGATE_EXPR
, sizetype
, intop
);
3838 if (TREE_CODE (intop
) == INTEGER_CST
)
3841 tree string_cst
= string_constant (ptrop
, &offset_node
);
3844 && !(offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
))
3846 HOST_WIDE_INT max
= TREE_STRING_LENGTH (string_cst
);
3847 HOST_WIDE_INT offset
;
3848 if (offset_node
== 0)
3850 else if (! host_integerp (offset_node
, 0))
3853 offset
= tree_low_cst (offset_node
, 0);
3855 offset
= offset
+ tree_low_cst (intop
, 0);
3856 if (offset
< 0 || offset
> max
)
3857 warning_at (location
, 0,
3858 "offset %<%wd%> outside bounds of constant string",
3859 tree_low_cst (intop
, 0));
3863 ret
= fold_build2 (POINTER_PLUS_EXPR
, result_type
, ptrop
, intop
);
3865 fold_undefer_and_ignore_overflow_warnings ();
3870 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3871 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3872 around the SAVE_EXPR if needed so that c_fully_fold does not need
3873 to look inside SAVE_EXPRs. */
3876 c_save_expr (tree expr
)
3878 bool maybe_const
= true;
3879 if (c_dialect_cxx ())
3880 return save_expr (expr
);
3881 expr
= c_fully_fold (expr
, false, &maybe_const
);
3882 expr
= save_expr (expr
);
3885 expr
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL
, expr
);
3886 C_MAYBE_CONST_EXPR_NON_CONST (expr
) = 1;
3891 /* Return whether EXPR is a declaration whose address can never be
3895 decl_with_nonnull_addr_p (const_tree expr
)
3897 return (DECL_P (expr
)
3898 && (TREE_CODE (expr
) == PARM_DECL
3899 || TREE_CODE (expr
) == LABEL_DECL
3900 || !DECL_WEAK (expr
)));
3903 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3904 or for an `if' or `while' statement or ?..: exp. It should already
3905 have been validated to be of suitable type; otherwise, a bad
3906 diagnostic may result.
3908 The EXPR is located at LOCATION.
3910 This preparation consists of taking the ordinary
3911 representation of an expression expr and producing a valid tree
3912 boolean expression describing whether expr is nonzero. We could
3913 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3914 but we optimize comparisons, &&, ||, and !.
3916 The resulting type should always be `truthvalue_type_node'. */
3919 c_common_truthvalue_conversion (location_t location
, tree expr
)
3921 switch (TREE_CODE (expr
))
3923 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
3924 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3925 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
3926 case ORDERED_EXPR
: case UNORDERED_EXPR
:
3927 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3929 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
3930 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
3932 case TRUTH_ANDIF_EXPR
:
3933 case TRUTH_ORIF_EXPR
:
3934 case TRUTH_AND_EXPR
:
3936 case TRUTH_XOR_EXPR
:
3937 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3939 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
3940 c_common_truthvalue_conversion (location
,
3941 TREE_OPERAND (expr
, 0)),
3942 c_common_truthvalue_conversion (location
,
3943 TREE_OPERAND (expr
, 1)));
3945 case TRUTH_NOT_EXPR
:
3946 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3948 return build1 (TREE_CODE (expr
), truthvalue_type_node
,
3949 c_common_truthvalue_conversion (location
,
3950 TREE_OPERAND (expr
, 0)));
3956 return integer_zerop (expr
) ? truthvalue_false_node
3957 : truthvalue_true_node
;
3960 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3961 ? truthvalue_true_node
3962 : truthvalue_false_node
;
3965 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3966 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3967 ? truthvalue_true_node
3968 : truthvalue_false_node
;
3971 expr
= build_unary_op (location
, ADDR_EXPR
, expr
, 0);
3976 tree inner
= TREE_OPERAND (expr
, 0);
3977 if (decl_with_nonnull_addr_p (inner
))
3979 /* Common Ada/Pascal programmer's mistake. */
3980 warning_at (location
,
3982 "the address of %qD will always evaluate as %<true%>",
3984 return truthvalue_true_node
;
3987 /* If we still have a decl, it is possible for its address to
3988 be NULL, so we cannot optimize. */
3991 gcc_assert (DECL_WEAK (inner
));
3995 if (TREE_SIDE_EFFECTS (inner
))
3996 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3997 inner
, truthvalue_true_node
);
3999 return truthvalue_true_node
;
4003 return build_binary_op (EXPR_LOCATION (expr
),
4004 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
4005 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
4006 c_common_truthvalue_conversion (location
,
4007 TREE_OPERAND (expr
, 0)),
4008 c_common_truthvalue_conversion (location
,
4009 TREE_OPERAND (expr
, 1)),
4015 case EXCESS_PRECISION_EXPR
:
4016 /* These don't change whether an object is nonzero or zero. */
4017 return c_common_truthvalue_conversion (location
, TREE_OPERAND (expr
, 0));
4021 /* These don't change whether an object is zero or nonzero, but
4022 we can't ignore them if their second arg has side-effects. */
4023 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
4024 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
4025 TREE_OPERAND (expr
, 1),
4026 c_common_truthvalue_conversion
4027 (location
, TREE_OPERAND (expr
, 0)));
4029 return c_common_truthvalue_conversion (location
,
4030 TREE_OPERAND (expr
, 0));
4033 /* Distribute the conversion into the arms of a COND_EXPR. */
4034 if (c_dialect_cxx ())
4035 return fold_build3 (COND_EXPR
, truthvalue_type_node
,
4036 TREE_OPERAND (expr
, 0),
4037 c_common_truthvalue_conversion (location
,
4040 c_common_truthvalue_conversion (location
,
4044 /* Folding will happen later for C. */
4045 return build3 (COND_EXPR
, truthvalue_type_node
,
4046 TREE_OPERAND (expr
, 0),
4047 c_common_truthvalue_conversion (location
,
4048 TREE_OPERAND (expr
, 1)),
4049 c_common_truthvalue_conversion (location
,
4050 TREE_OPERAND (expr
, 2)));
4053 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4054 since that affects how `default_conversion' will behave. */
4055 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
4056 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
4058 /* If this is widening the argument, we can ignore it. */
4059 if (TYPE_PRECISION (TREE_TYPE (expr
))
4060 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
4061 return c_common_truthvalue_conversion (location
,
4062 TREE_OPERAND (expr
, 0));
4066 if (!TREE_NO_WARNING (expr
)
4067 && warn_parentheses
)
4069 warning (OPT_Wparentheses
,
4070 "suggest parentheses around assignment used as truth value");
4071 TREE_NO_WARNING (expr
) = 1;
4079 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
4081 tree t
= c_save_expr (expr
);
4082 return (build_binary_op
4083 (EXPR_LOCATION (expr
),
4084 (TREE_SIDE_EFFECTS (expr
)
4085 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
4086 c_common_truthvalue_conversion
4088 build_unary_op (location
, REALPART_EXPR
, t
, 0)),
4089 c_common_truthvalue_conversion
4091 build_unary_op (location
, IMAGPART_EXPR
, t
, 0)),
4095 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
4097 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
4099 (TREE_TYPE (expr
))));
4100 return build_binary_op (EXPR_LOCATION (expr
),
4101 NE_EXPR
, expr
, fixed_zero_node
, 1);
4104 return build_binary_op (EXPR_LOCATION (expr
),
4105 NE_EXPR
, expr
, integer_zero_node
, 1);
4108 static void def_builtin_1 (enum built_in_function fncode
,
4110 enum built_in_class fnclass
,
4111 tree fntype
, tree libtype
,
4112 bool both_p
, bool fallback_p
, bool nonansi_p
,
4113 tree fnattrs
, bool implicit_p
);
4116 /* Apply the TYPE_QUALS to the new DECL. */
4119 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
4121 tree type
= TREE_TYPE (decl
);
4123 if (type
== error_mark_node
)
4126 if (((type_quals
& TYPE_QUAL_CONST
)
4127 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
4128 /* An object declared 'const' is only readonly after it is
4129 initialized. We don't have any way of expressing this currently,
4130 so we need to be conservative and unset TREE_READONLY for types
4131 with constructors. Otherwise aliasing code will ignore stores in
4132 an inline constructor. */
4133 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
4134 TREE_READONLY (decl
) = 1;
4135 if (type_quals
& TYPE_QUAL_VOLATILE
)
4137 TREE_SIDE_EFFECTS (decl
) = 1;
4138 TREE_THIS_VOLATILE (decl
) = 1;
4140 if (type_quals
& TYPE_QUAL_RESTRICT
)
4142 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
4143 /* Allow 'restrict' on arrays of pointers.
4144 FIXME currently we just ignore it. */
4145 type
= TREE_TYPE (type
);
4147 || !POINTER_TYPE_P (type
)
4148 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
4149 error ("invalid use of %<restrict%>");
4150 else if (flag_strict_aliasing
&& type
== TREE_TYPE (decl
))
4151 /* Indicate we need to make a unique alias set for this pointer.
4152 We can't do it here because it might be pointing to an
4154 DECL_POINTER_ALIAS_SET (decl
) = -2;
4158 /* Hash function for the problem of multiple type definitions in
4159 different files. This must hash all types that will compare
4160 equal via comptypes to the same value. In practice it hashes
4161 on some of the simple stuff and leaves the details to comptypes. */
4164 c_type_hash (const void *p
)
4168 const_tree
const t
= (const_tree
) p
;
4170 switch (TREE_CODE (t
))
4172 /* For pointers, hash on pointee type plus some swizzling. */
4174 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
4175 /* Hash on number of elements and total size. */
4178 t2
= TYPE_VALUES (t
);
4182 t2
= TYPE_FIELDS (t
);
4184 case QUAL_UNION_TYPE
:
4186 t2
= TYPE_FIELDS (t
);
4190 t2
= TYPE_FIELDS (t
);
4195 for (; t2
; t2
= TREE_CHAIN (t2
))
4197 /* We might have a VLA here. */
4198 if (TREE_CODE (TYPE_SIZE (t
)) != INTEGER_CST
)
4201 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
4202 return ((size
<< 24) | (i
<< shift
));
4205 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
4207 /* Return the typed-based alias set for T, which may be an expression
4208 or a type. Return -1 if we don't do anything special. */
4211 c_common_get_alias_set (tree t
)
4216 /* Permit type-punning when accessing a union, provided the access
4217 is directly through the union. For example, this code does not
4218 permit taking the address of a union member and then storing
4219 through it. Even the type-punning allowed here is a GCC
4220 extension, albeit a common and useful one; the C standard says
4221 that such accesses have implementation-defined behavior. */
4223 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
4224 u
= TREE_OPERAND (u
, 0))
4225 if (TREE_CODE (u
) == COMPONENT_REF
4226 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
4229 /* That's all the expressions we handle specially. */
4233 /* The C standard guarantees that any object may be accessed via an
4234 lvalue that has character type. */
4235 if (t
== char_type_node
4236 || t
== signed_char_type_node
4237 || t
== unsigned_char_type_node
)
4240 /* The C standard specifically allows aliasing between signed and
4241 unsigned variants of the same type. We treat the signed
4242 variant as canonical. */
4243 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
4245 tree t1
= c_common_signed_type (t
);
4247 /* t1 == t can happen for boolean nodes which are always unsigned. */
4249 return get_alias_set (t1
);
4251 else if (POINTER_TYPE_P (t
))
4255 /* Unfortunately, there is no canonical form of a pointer type.
4256 In particular, if we have `typedef int I', then `int *', and
4257 `I *' are different types. So, we have to pick a canonical
4258 representative. We do this below.
4260 Technically, this approach is actually more conservative that
4261 it needs to be. In particular, `const int *' and `int *'
4262 should be in different alias sets, according to the C and C++
4263 standard, since their types are not the same, and so,
4264 technically, an `int **' and `const int **' cannot point at
4267 But, the standard is wrong. In particular, this code is
4272 const int* const* cipp = ipp;
4274 And, it doesn't make sense for that to be legal unless you
4275 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4276 the pointed-to types. This issue has been reported to the
4278 t1
= build_type_no_quals (t
);
4280 return get_alias_set (t1
);
4283 /* Handle the case of multiple type nodes referring to "the same" type,
4284 which occurs with IMA. These share an alias set. FIXME: Currently only
4285 C90 is handled. (In C99 type compatibility is not transitive, which
4286 complicates things mightily. The alias set splay trees can theoretically
4287 represent this, but insertion is tricky when you consider all the
4288 different orders things might arrive in.) */
4290 if (c_language
!= clk_c
|| flag_isoc99
)
4293 /* Save time if there's only one input file. */
4294 if (num_in_fnames
== 1)
4297 /* Pointers need special handling if they point to any type that
4298 needs special handling (below). */
4299 if (TREE_CODE (t
) == POINTER_TYPE
)
4302 /* Find bottom type under any nested POINTERs. */
4303 for (t2
= TREE_TYPE (t
);
4304 TREE_CODE (t2
) == POINTER_TYPE
;
4305 t2
= TREE_TYPE (t2
))
4307 if (TREE_CODE (t2
) != RECORD_TYPE
4308 && TREE_CODE (t2
) != ENUMERAL_TYPE
4309 && TREE_CODE (t2
) != QUAL_UNION_TYPE
4310 && TREE_CODE (t2
) != UNION_TYPE
)
4312 if (TYPE_SIZE (t2
) == 0)
4315 /* These are the only cases that need special handling. */
4316 if (TREE_CODE (t
) != RECORD_TYPE
4317 && TREE_CODE (t
) != ENUMERAL_TYPE
4318 && TREE_CODE (t
) != QUAL_UNION_TYPE
4319 && TREE_CODE (t
) != UNION_TYPE
4320 && TREE_CODE (t
) != POINTER_TYPE
)
4323 if (TYPE_SIZE (t
) == 0)
4326 /* Look up t in hash table. Only one of the compatible types within each
4327 alias set is recorded in the table. */
4328 if (!type_hash_table
)
4329 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
4330 (htab_eq
) lang_hooks
.types_compatible_p
,
4332 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
4335 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
4336 return TYPE_ALIAS_SET ((tree
)*slot
);
4339 /* Our caller will assign and record (in t) a new alias set; all we need
4340 to do is remember t in the hash table. */
4346 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
4347 second parameter indicates which OPERATOR is being applied. The COMPLAIN
4348 flag controls whether we should diagnose possibly ill-formed
4349 constructs or not. */
4352 c_sizeof_or_alignof_type (tree type
, bool is_sizeof
, int complain
)
4354 const char *op_name
;
4356 enum tree_code type_code
= TREE_CODE (type
);
4358 op_name
= is_sizeof
? "sizeof" : "__alignof__";
4360 if (type_code
== FUNCTION_TYPE
)
4364 if (complain
&& (pedantic
|| warn_pointer_arith
))
4365 pedwarn (input_location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4366 "invalid application of %<sizeof%> to a function type");
4368 return error_mark_node
;
4369 value
= size_one_node
;
4372 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
4374 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
4376 if (type_code
== VOID_TYPE
4377 && complain
&& (pedantic
|| warn_pointer_arith
))
4378 pedwarn (input_location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4379 "invalid application of %qs to a void type", op_name
);
4381 return error_mark_node
;
4382 value
= size_one_node
;
4384 else if (!COMPLETE_TYPE_P (type
))
4387 error ("invalid application of %qs to incomplete type %qT ",
4389 value
= size_zero_node
;
4394 /* Convert in case a char is more than one unit. */
4395 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
4396 size_int (TYPE_PRECISION (char_type_node
)
4399 value
= size_int (TYPE_ALIGN_UNIT (type
));
4402 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4403 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4404 never happen. However, this node should really have type
4405 `size_t', which is just a typedef for an ordinary integer type. */
4406 value
= fold_convert (size_type_node
, value
);
4407 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)));
4412 /* Implement the __alignof keyword: Return the minimum required
4413 alignment of EXPR, measured in bytes. For VAR_DECLs,
4414 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4415 from an "aligned" __attribute__ specification). */
4418 c_alignof_expr (tree expr
)
4422 if (VAR_OR_FUNCTION_DECL_P (expr
))
4423 t
= size_int (DECL_ALIGN_UNIT (expr
));
4425 else if (TREE_CODE (expr
) == COMPONENT_REF
4426 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
4428 error ("%<__alignof%> applied to a bit-field");
4431 else if (TREE_CODE (expr
) == COMPONENT_REF
4432 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
4433 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
4435 else if (TREE_CODE (expr
) == INDIRECT_REF
)
4437 tree t
= TREE_OPERAND (expr
, 0);
4439 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4441 while (CONVERT_EXPR_P (t
)
4442 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
4446 t
= TREE_OPERAND (t
, 0);
4447 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4448 if (thisalign
> bestalign
)
4449 best
= t
, bestalign
= thisalign
;
4451 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
4454 return c_alignof (TREE_TYPE (expr
));
4456 return fold_convert (size_type_node
, t
);
4459 /* Handle C and C++ default attributes. */
4461 enum built_in_attribute
4463 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4464 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4465 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4466 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4467 #include "builtin-attrs.def"
4468 #undef DEF_ATTR_NULL_TREE
4470 #undef DEF_ATTR_IDENT
4471 #undef DEF_ATTR_TREE_LIST
4475 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
4477 static void c_init_attributes (void);
4481 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4482 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4483 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4484 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4485 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4486 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4487 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4488 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4489 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4490 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4491 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4492 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4493 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4494 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4495 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4497 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4498 #include "builtin-types.def"
4499 #undef DEF_PRIMITIVE_TYPE
4500 #undef DEF_FUNCTION_TYPE_0
4501 #undef DEF_FUNCTION_TYPE_1
4502 #undef DEF_FUNCTION_TYPE_2
4503 #undef DEF_FUNCTION_TYPE_3
4504 #undef DEF_FUNCTION_TYPE_4
4505 #undef DEF_FUNCTION_TYPE_5
4506 #undef DEF_FUNCTION_TYPE_6
4507 #undef DEF_FUNCTION_TYPE_7
4508 #undef DEF_FUNCTION_TYPE_VAR_0
4509 #undef DEF_FUNCTION_TYPE_VAR_1
4510 #undef DEF_FUNCTION_TYPE_VAR_2
4511 #undef DEF_FUNCTION_TYPE_VAR_3
4512 #undef DEF_FUNCTION_TYPE_VAR_4
4513 #undef DEF_FUNCTION_TYPE_VAR_5
4514 #undef DEF_POINTER_TYPE
4518 typedef enum c_builtin_type builtin_type
;
4520 /* A temporary array for c_common_nodes_and_builtins. Used in
4521 communication with def_fn_type. */
4522 static tree builtin_types
[(int) BT_LAST
+ 1];
4524 /* A helper function for c_common_nodes_and_builtins. Build function type
4525 for DEF with return type RET and N arguments. If VAR is true, then the
4526 function should be variadic after those N arguments.
4528 Takes special care not to ICE if any of the types involved are
4529 error_mark_node, which indicates that said type is not in fact available
4530 (see builtin_type_for_size). In which case the function type as a whole
4531 should be error_mark_node. */
4534 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
4536 tree args
= NULL
, t
;
4541 for (i
= 0; i
< n
; ++i
)
4543 builtin_type a
= (builtin_type
) va_arg (list
, int);
4544 t
= builtin_types
[a
];
4545 if (t
== error_mark_node
)
4547 args
= tree_cons (NULL_TREE
, t
, args
);
4551 args
= nreverse (args
);
4553 args
= chainon (args
, void_list_node
);
4555 t
= builtin_types
[ret
];
4556 if (t
== error_mark_node
)
4558 t
= build_function_type (t
, args
);
4561 builtin_types
[def
] = t
;
4564 /* Build builtin functions common to both C and C++ language
4568 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
4570 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4571 builtin_types[ENUM] = VALUE;
4572 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4573 def_fn_type (ENUM, RETURN, 0, 0);
4574 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4575 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4576 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4577 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4578 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4579 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4580 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4581 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4582 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4583 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4584 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4586 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4587 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4589 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4590 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4591 def_fn_type (ENUM, RETURN, 1, 0);
4592 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4593 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4594 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4595 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4596 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4597 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4598 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4599 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4600 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4601 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4602 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4603 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4605 #include "builtin-types.def"
4607 #undef DEF_PRIMITIVE_TYPE
4608 #undef DEF_FUNCTION_TYPE_1
4609 #undef DEF_FUNCTION_TYPE_2
4610 #undef DEF_FUNCTION_TYPE_3
4611 #undef DEF_FUNCTION_TYPE_4
4612 #undef DEF_FUNCTION_TYPE_5
4613 #undef DEF_FUNCTION_TYPE_6
4614 #undef DEF_FUNCTION_TYPE_VAR_0
4615 #undef DEF_FUNCTION_TYPE_VAR_1
4616 #undef DEF_FUNCTION_TYPE_VAR_2
4617 #undef DEF_FUNCTION_TYPE_VAR_3
4618 #undef DEF_FUNCTION_TYPE_VAR_4
4619 #undef DEF_FUNCTION_TYPE_VAR_5
4620 #undef DEF_POINTER_TYPE
4621 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
4623 c_init_attributes ();
4625 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4626 NONANSI_P, ATTRS, IMPLICIT, COND) \
4628 def_builtin_1 (ENUM, NAME, CLASS, \
4629 builtin_types[(int) TYPE], \
4630 builtin_types[(int) LIBTYPE], \
4631 BOTH_P, FALLBACK_P, NONANSI_P, \
4632 built_in_attributes[(int) ATTRS], IMPLICIT);
4633 #include "builtins.def"
4636 targetm
.init_builtins ();
4638 build_common_builtin_nodes ();
4644 /* Like get_identifier, but avoid warnings about null arguments when
4645 the argument may be NULL for targets where GCC lacks stdint.h type
4649 c_get_ident (const char *id
)
4651 return get_identifier (id
);
4654 /* Build tree nodes and builtin functions common to both C and C++ language
4658 c_common_nodes_and_builtins (void)
4660 int char16_type_size
;
4661 int char32_type_size
;
4662 int wchar_type_size
;
4663 tree array_domain_type
;
4664 tree va_list_ref_type_node
;
4665 tree va_list_arg_type_node
;
4667 /* Define `int' and `char' first so that dbx will output them first. */
4668 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
4669 record_builtin_type (RID_CHAR
, "char", char_type_node
);
4671 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4672 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4673 but not C. Are the conditionals here needed? */
4674 if (c_dialect_cxx ())
4675 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
4676 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
4677 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
4678 record_builtin_type (RID_MAX
, "long unsigned int",
4679 long_unsigned_type_node
);
4680 if (c_dialect_cxx ())
4681 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
4682 record_builtin_type (RID_MAX
, "long long int",
4683 long_long_integer_type_node
);
4684 record_builtin_type (RID_MAX
, "long long unsigned int",
4685 long_long_unsigned_type_node
);
4686 if (c_dialect_cxx ())
4687 record_builtin_type (RID_MAX
, "long long unsigned",
4688 long_long_unsigned_type_node
);
4689 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
4690 record_builtin_type (RID_MAX
, "short unsigned int",
4691 short_unsigned_type_node
);
4692 if (c_dialect_cxx ())
4693 record_builtin_type (RID_MAX
, "unsigned short",
4694 short_unsigned_type_node
);
4696 /* Define both `signed char' and `unsigned char'. */
4697 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
4698 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
4700 /* These are types that c_common_type_for_size and
4701 c_common_type_for_mode use. */
4702 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4704 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4706 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4708 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4710 #if HOST_BITS_PER_WIDE_INT >= 64
4711 if (targetm
.scalar_mode_supported_p (TImode
))
4712 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4713 get_identifier ("__int128_t"),
4716 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4717 unsigned_intQI_type_node
));
4718 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4719 unsigned_intHI_type_node
));
4720 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4721 unsigned_intSI_type_node
));
4722 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4723 unsigned_intDI_type_node
));
4724 #if HOST_BITS_PER_WIDE_INT >= 64
4725 if (targetm
.scalar_mode_supported_p (TImode
))
4726 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4727 get_identifier ("__uint128_t"),
4728 unsigned_intTI_type_node
));
4731 /* Create the widest literal types. */
4732 widest_integer_literal_type_node
4733 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
4734 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4735 widest_integer_literal_type_node
));
4737 widest_unsigned_literal_type_node
4738 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
4739 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4740 widest_unsigned_literal_type_node
));
4742 /* `unsigned long' is the standard type for sizeof.
4743 Note that stddef.h uses `unsigned long',
4744 and this must agree, even if long and int are the same size. */
4746 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
4747 signed_size_type_node
= c_common_signed_type (size_type_node
);
4748 set_sizetype (size_type_node
);
4751 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
4753 build_common_tree_nodes_2 (flag_short_double
);
4755 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
4756 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
4757 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
4759 /* Only supported decimal floating point extension if the target
4760 actually supports underlying modes. */
4761 if (targetm
.scalar_mode_supported_p (SDmode
)
4762 && targetm
.scalar_mode_supported_p (DDmode
)
4763 && targetm
.scalar_mode_supported_p (TDmode
))
4765 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
4766 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
4767 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
4770 if (targetm
.fixed_point_supported_p ())
4772 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
4773 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
4774 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
4775 record_builtin_type (RID_MAX
, "long long _Fract",
4776 long_long_fract_type_node
);
4777 record_builtin_type (RID_MAX
, "unsigned short _Fract",
4778 unsigned_short_fract_type_node
);
4779 record_builtin_type (RID_MAX
, "unsigned _Fract",
4780 unsigned_fract_type_node
);
4781 record_builtin_type (RID_MAX
, "unsigned long _Fract",
4782 unsigned_long_fract_type_node
);
4783 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
4784 unsigned_long_long_fract_type_node
);
4785 record_builtin_type (RID_MAX
, "_Sat short _Fract",
4786 sat_short_fract_type_node
);
4787 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
4788 record_builtin_type (RID_MAX
, "_Sat long _Fract",
4789 sat_long_fract_type_node
);
4790 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
4791 sat_long_long_fract_type_node
);
4792 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
4793 sat_unsigned_short_fract_type_node
);
4794 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
4795 sat_unsigned_fract_type_node
);
4796 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
4797 sat_unsigned_long_fract_type_node
);
4798 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
4799 sat_unsigned_long_long_fract_type_node
);
4800 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
4801 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
4802 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
4803 record_builtin_type (RID_MAX
, "long long _Accum",
4804 long_long_accum_type_node
);
4805 record_builtin_type (RID_MAX
, "unsigned short _Accum",
4806 unsigned_short_accum_type_node
);
4807 record_builtin_type (RID_MAX
, "unsigned _Accum",
4808 unsigned_accum_type_node
);
4809 record_builtin_type (RID_MAX
, "unsigned long _Accum",
4810 unsigned_long_accum_type_node
);
4811 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
4812 unsigned_long_long_accum_type_node
);
4813 record_builtin_type (RID_MAX
, "_Sat short _Accum",
4814 sat_short_accum_type_node
);
4815 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
4816 record_builtin_type (RID_MAX
, "_Sat long _Accum",
4817 sat_long_accum_type_node
);
4818 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
4819 sat_long_long_accum_type_node
);
4820 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
4821 sat_unsigned_short_accum_type_node
);
4822 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
4823 sat_unsigned_accum_type_node
);
4824 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
4825 sat_unsigned_long_accum_type_node
);
4826 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
4827 sat_unsigned_long_long_accum_type_node
);
4831 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4832 get_identifier ("complex int"),
4833 complex_integer_type_node
));
4834 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4835 get_identifier ("complex float"),
4836 complex_float_type_node
));
4837 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4838 get_identifier ("complex double"),
4839 complex_double_type_node
));
4840 lang_hooks
.decls
.pushdecl
4841 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
4842 complex_long_double_type_node
));
4844 if (c_dialect_cxx ())
4845 /* For C++, make fileptr_type_node a distinct void * type until
4846 FILE type is defined. */
4847 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
4849 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
4851 /* Set the TYPE_NAME for any variants that were built before
4852 record_builtin_type gave names to the built-in types. */
4854 tree void_name
= TYPE_NAME (void_type_node
);
4855 TYPE_NAME (void_type_node
) = NULL_TREE
;
4856 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
4858 TYPE_NAME (void_type_node
) = void_name
;
4861 /* This node must not be shared. */
4862 void_zero_node
= make_node (INTEGER_CST
);
4863 TREE_TYPE (void_zero_node
) = void_type_node
;
4865 void_list_node
= build_void_list_node ();
4867 /* Make a type to be the domain of a few array types
4868 whose domains don't really matter.
4869 200 is small enough that it always fits in size_t
4870 and large enough that it can hold most function names for the
4871 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4872 array_domain_type
= build_index_type (size_int (200));
4874 /* Make a type for arrays of characters.
4875 With luck nothing will ever really depend on the length of this
4877 char_array_type_node
4878 = build_array_type (char_type_node
, array_domain_type
);
4880 /* Likewise for arrays of ints. */
4882 = build_array_type (integer_type_node
, array_domain_type
);
4884 string_type_node
= build_pointer_type (char_type_node
);
4885 const_string_type_node
4886 = build_pointer_type (build_qualified_type
4887 (char_type_node
, TYPE_QUAL_CONST
));
4889 /* This is special for C++ so functions can be overloaded. */
4890 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
4891 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
4892 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
4893 underlying_wchar_type_node
= wchar_type_node
;
4894 if (c_dialect_cxx ())
4896 if (TYPE_UNSIGNED (wchar_type_node
))
4897 wchar_type_node
= make_unsigned_type (wchar_type_size
);
4899 wchar_type_node
= make_signed_type (wchar_type_size
);
4900 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
4903 /* This is for wide string constants. */
4904 wchar_array_type_node
4905 = build_array_type (wchar_type_node
, array_domain_type
);
4907 /* Define 'char16_t'. */
4908 char16_type_node
= get_identifier (CHAR16_TYPE
);
4909 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
4910 char16_type_size
= TYPE_PRECISION (char16_type_node
);
4911 if (c_dialect_cxx ())
4913 char16_type_node
= make_unsigned_type (char16_type_size
);
4915 if (cxx_dialect
== cxx0x
)
4916 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
4919 /* This is for UTF-16 string constants. */
4920 char16_array_type_node
4921 = build_array_type (char16_type_node
, array_domain_type
);
4923 /* Define 'char32_t'. */
4924 char32_type_node
= get_identifier (CHAR32_TYPE
);
4925 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
4926 char32_type_size
= TYPE_PRECISION (char32_type_node
);
4927 if (c_dialect_cxx ())
4929 char32_type_node
= make_unsigned_type (char32_type_size
);
4931 if (cxx_dialect
== cxx0x
)
4932 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
4935 /* This is for UTF-32 string constants. */
4936 char32_array_type_node
4937 = build_array_type (char32_type_node
, array_domain_type
);
4940 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
4943 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
4945 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
4947 if (SIG_ATOMIC_TYPE
)
4948 sig_atomic_type_node
=
4949 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE
)));
4952 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE
)));
4955 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE
)));
4958 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE
)));
4961 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE
)));
4964 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE
)));
4967 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE
)));
4969 c_uint32_type_node
=
4970 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE
)));
4972 c_uint64_type_node
=
4973 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE
)));
4974 if (INT_LEAST8_TYPE
)
4975 int_least8_type_node
=
4976 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE
)));
4977 if (INT_LEAST16_TYPE
)
4978 int_least16_type_node
=
4979 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE
)));
4980 if (INT_LEAST32_TYPE
)
4981 int_least32_type_node
=
4982 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE
)));
4983 if (INT_LEAST64_TYPE
)
4984 int_least64_type_node
=
4985 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE
)));
4986 if (UINT_LEAST8_TYPE
)
4987 uint_least8_type_node
=
4988 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE
)));
4989 if (UINT_LEAST16_TYPE
)
4990 uint_least16_type_node
=
4991 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE
)));
4992 if (UINT_LEAST32_TYPE
)
4993 uint_least32_type_node
=
4994 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE
)));
4995 if (UINT_LEAST64_TYPE
)
4996 uint_least64_type_node
=
4997 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE
)));
4999 int_fast8_type_node
=
5000 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE
)));
5001 if (INT_FAST16_TYPE
)
5002 int_fast16_type_node
=
5003 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE
)));
5004 if (INT_FAST32_TYPE
)
5005 int_fast32_type_node
=
5006 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE
)));
5007 if (INT_FAST64_TYPE
)
5008 int_fast64_type_node
=
5009 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE
)));
5010 if (UINT_FAST8_TYPE
)
5011 uint_fast8_type_node
=
5012 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE
)));
5013 if (UINT_FAST16_TYPE
)
5014 uint_fast16_type_node
=
5015 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE
)));
5016 if (UINT_FAST32_TYPE
)
5017 uint_fast32_type_node
=
5018 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE
)));
5019 if (UINT_FAST64_TYPE
)
5020 uint_fast64_type_node
=
5021 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE
)));
5024 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE
)));
5027 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE
)));
5029 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
5031 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
5032 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
5034 lang_hooks
.decls
.pushdecl
5035 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
5036 va_list_type_node
));
5037 #ifdef TARGET_ENUM_VA_LIST
5042 for (l
= 0; TARGET_ENUM_VA_LIST (l
, &pname
, &ptype
); ++l
)
5044 lang_hooks
.decls
.pushdecl
5045 (build_decl (TYPE_DECL
, get_identifier (pname
),
5052 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
5054 va_list_arg_type_node
= va_list_ref_type_node
=
5055 build_pointer_type (TREE_TYPE (va_list_type_node
));
5059 va_list_arg_type_node
= va_list_type_node
;
5060 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
5063 if (!flag_preprocess_only
)
5064 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
5066 main_identifier_node
= get_identifier ("main");
5068 /* Create the built-in __null node. It is important that this is
5070 null_node
= make_node (INTEGER_CST
);
5071 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
5073 /* Since builtin_types isn't gc'ed, don't export these nodes. */
5074 memset (builtin_types
, 0, sizeof (builtin_types
));
5077 /* Look up the function in built_in_decls that corresponds to DECL
5078 and set ASMSPEC as its user assembler name. DECL must be a
5079 function decl that declares a builtin. */
5082 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
5085 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
5086 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
5089 builtin
= built_in_decls
[DECL_FUNCTION_CODE (decl
)];
5090 set_user_assembler_name (builtin
, asmspec
);
5091 switch (DECL_FUNCTION_CODE (decl
))
5093 case BUILT_IN_MEMCPY
:
5094 init_block_move_fn (asmspec
);
5095 memcpy_libfunc
= set_user_assembler_libfunc ("memcpy", asmspec
);
5097 case BUILT_IN_MEMSET
:
5098 init_block_clear_fn (asmspec
);
5099 memset_libfunc
= set_user_assembler_libfunc ("memset", asmspec
);
5101 case BUILT_IN_MEMMOVE
:
5102 memmove_libfunc
= set_user_assembler_libfunc ("memmove", asmspec
);
5104 case BUILT_IN_MEMCMP
:
5105 memcmp_libfunc
= set_user_assembler_libfunc ("memcmp", asmspec
);
5107 case BUILT_IN_ABORT
:
5108 abort_libfunc
= set_user_assembler_libfunc ("abort", asmspec
);
5115 /* The number of named compound-literals generated thus far. */
5116 static GTY(()) int compound_literal_number
;
5118 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
5121 set_compound_literal_name (tree decl
)
5124 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
5125 compound_literal_number
);
5126 compound_literal_number
++;
5127 DECL_NAME (decl
) = get_identifier (name
);
5131 build_va_arg (tree expr
, tree type
)
5133 return build1 (VA_ARG_EXPR
, type
, expr
);
5137 /* Linked list of disabled built-in functions. */
5139 typedef struct disabled_builtin
5142 struct disabled_builtin
*next
;
5144 static disabled_builtin
*disabled_builtins
= NULL
;
5146 static bool builtin_function_disabled_p (const char *);
5148 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5149 begins with "__builtin_", give an error. */
5152 disable_builtin_function (const char *name
)
5154 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
5155 error ("cannot disable built-in function %qs", name
);
5158 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
5159 new_disabled_builtin
->name
= name
;
5160 new_disabled_builtin
->next
= disabled_builtins
;
5161 disabled_builtins
= new_disabled_builtin
;
5166 /* Return true if the built-in function NAME has been disabled, false
5170 builtin_function_disabled_p (const char *name
)
5172 disabled_builtin
*p
;
5173 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
5175 if (strcmp (name
, p
->name
) == 0)
5182 /* Worker for DEF_BUILTIN.
5183 Possibly define a builtin function with one or two names.
5184 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5185 nonansi_p and flag_no_nonansi_builtin. */
5188 def_builtin_1 (enum built_in_function fncode
,
5190 enum built_in_class fnclass
,
5191 tree fntype
, tree libtype
,
5192 bool both_p
, bool fallback_p
, bool nonansi_p
,
5193 tree fnattrs
, bool implicit_p
)
5196 const char *libname
;
5198 if (fntype
== error_mark_node
)
5201 gcc_assert ((!both_p
&& !fallback_p
)
5202 || !strncmp (name
, "__builtin_",
5203 strlen ("__builtin_")));
5205 libname
= name
+ strlen ("__builtin_");
5206 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
5207 (fallback_p
? libname
: NULL
),
5210 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
5211 && !(nonansi_p
&& flag_no_nonansi_builtin
))
5212 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
5215 built_in_decls
[(int) fncode
] = decl
;
5217 implicit_built_in_decls
[(int) fncode
] = decl
;
5220 /* Nonzero if the type T promotes to int. This is (nearly) the
5221 integral promotions defined in ISO C99 6.3.1.1/2. */
5224 c_promoting_integer_type_p (const_tree t
)
5226 switch (TREE_CODE (t
))
5229 return (TYPE_MAIN_VARIANT (t
) == char_type_node
5230 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
5231 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
5232 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
5233 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
5234 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
5237 /* ??? Technically all enumerations not larger than an int
5238 promote to an int. But this is used along code paths
5239 that only want to notice a size change. */
5240 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
5250 /* Return 1 if PARMS specifies a fixed number of parameters
5251 and none of their types is affected by default promotions. */
5254 self_promoting_args_p (const_tree parms
)
5257 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
5259 tree type
= TREE_VALUE (t
);
5261 if (type
== error_mark_node
)
5264 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
5270 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
5273 if (c_promoting_integer_type_p (type
))
5279 /* Recursively remove any '*' or '&' operator from TYPE. */
5281 strip_pointer_operator (tree t
)
5283 while (POINTER_TYPE_P (t
))
5288 /* Recursively remove pointer or array type from TYPE. */
5290 strip_pointer_or_array_types (tree t
)
5292 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
5297 /* Used to compare case labels. K1 and K2 are actually tree nodes
5298 representing case labels, or NULL_TREE for a `default' label.
5299 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5300 K2, and 0 if K1 and K2 are equal. */
5303 case_compare (splay_tree_key k1
, splay_tree_key k2
)
5305 /* Consider a NULL key (such as arises with a `default' label) to be
5306 smaller than anything else. */
5312 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5315 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
5316 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
5317 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
5318 case label was declared using the usual C/C++ syntax, rather than
5319 the GNU case range extension. CASES is a tree containing all the
5320 case ranges processed so far; COND is the condition for the
5321 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
5322 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
5325 c_add_case_label (splay_tree cases
, tree cond
, tree orig_type
,
5326 tree low_value
, tree high_value
)
5331 splay_tree_node node
;
5333 /* Create the LABEL_DECL itself. */
5334 label
= create_artificial_label ();
5336 /* If there was an error processing the switch condition, bail now
5337 before we get more confused. */
5338 if (!cond
|| cond
== error_mark_node
)
5341 if ((low_value
&& TREE_TYPE (low_value
)
5342 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
5343 || (high_value
&& TREE_TYPE (high_value
)
5344 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
5346 error ("pointers are not permitted as case values");
5350 /* Case ranges are a GNU extension. */
5352 pedwarn (input_location
, OPT_pedantic
,
5353 "range expressions in switch statements are non-standard");
5355 type
= TREE_TYPE (cond
);
5358 low_value
= check_case_value (low_value
);
5359 low_value
= convert_and_check (type
, low_value
);
5360 if (low_value
== error_mark_node
)
5365 high_value
= check_case_value (high_value
);
5366 high_value
= convert_and_check (type
, high_value
);
5367 if (high_value
== error_mark_node
)
5371 if (low_value
&& high_value
)
5373 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5374 really a case range, even though it was written that way.
5375 Remove the HIGH_VALUE to simplify later processing. */
5376 if (tree_int_cst_equal (low_value
, high_value
))
5377 high_value
= NULL_TREE
;
5378 else if (!tree_int_cst_lt (low_value
, high_value
))
5379 warning (0, "empty range specified");
5382 /* See if the case is in range of the type of the original testing
5383 expression. If both low_value and high_value are out of range,
5384 don't insert the case label and return NULL_TREE. */
5386 && !check_case_bounds (type
, orig_type
,
5387 &low_value
, high_value
? &high_value
: NULL
))
5390 /* Look up the LOW_VALUE in the table of case labels we already
5392 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
5393 /* If there was not an exact match, check for overlapping ranges.
5394 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5395 that's a `default' label and the only overlap is an exact match. */
5396 if (!node
&& (low_value
|| high_value
))
5398 splay_tree_node low_bound
;
5399 splay_tree_node high_bound
;
5401 /* Even though there wasn't an exact match, there might be an
5402 overlap between this case range and another case range.
5403 Since we've (inductively) not allowed any overlapping case
5404 ranges, we simply need to find the greatest low case label
5405 that is smaller that LOW_VALUE, and the smallest low case
5406 label that is greater than LOW_VALUE. If there is an overlap
5407 it will occur in one of these two ranges. */
5408 low_bound
= splay_tree_predecessor (cases
,
5409 (splay_tree_key
) low_value
);
5410 high_bound
= splay_tree_successor (cases
,
5411 (splay_tree_key
) low_value
);
5413 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5414 the LOW_VALUE, so there is no need to check unless the
5415 LOW_BOUND is in fact itself a case range. */
5417 && CASE_HIGH ((tree
) low_bound
->value
)
5418 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
5421 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5422 range is bigger than the low end of the current range, so we
5423 are only interested if the current range is a real range, and
5424 not an ordinary case label. */
5427 && (tree_int_cst_compare ((tree
) high_bound
->key
,
5432 /* If there was an overlap, issue an error. */
5435 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
5439 error ("duplicate (or overlapping) case value");
5440 error ("%Jthis is the first entry overlapping that value", duplicate
);
5444 error ("duplicate case value") ;
5445 error ("%Jpreviously used here", duplicate
);
5449 error ("multiple default labels in one switch");
5450 error ("%Jthis is the first default label", duplicate
);
5455 /* Add a CASE_LABEL to the statement-tree. */
5456 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
5457 /* Register this case label in the splay tree. */
5458 splay_tree_insert (cases
,
5459 (splay_tree_key
) low_value
,
5460 (splay_tree_value
) case_label
);
5465 /* Add a label so that the back-end doesn't think that the beginning of
5466 the switch is unreachable. Note that we do not add a case label, as
5467 that just leads to duplicates and thence to failure later on. */
5470 tree t
= create_artificial_label ();
5471 add_stmt (build_stmt (LABEL_EXPR
, t
));
5473 return error_mark_node
;
5476 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5477 Used to verify that case values match up with enumerator values. */
5480 match_case_to_enum_1 (tree key
, tree type
, tree label
)
5482 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
5484 /* ??? Not working too hard to print the double-word value.
5485 Should perhaps be done with %lwd in the diagnostic routines? */
5486 if (TREE_INT_CST_HIGH (key
) == 0)
5487 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
5488 TREE_INT_CST_LOW (key
));
5489 else if (!TYPE_UNSIGNED (type
)
5490 && TREE_INT_CST_HIGH (key
) == -1
5491 && TREE_INT_CST_LOW (key
) != 0)
5492 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
5493 -TREE_INT_CST_LOW (key
));
5495 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
5496 (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (key
),
5497 (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (key
));
5499 if (TYPE_NAME (type
) == 0)
5500 warning (warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5501 "%Jcase value %qs not in enumerated type",
5502 CASE_LABEL (label
), buf
);
5504 warning (warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5505 "%Jcase value %qs not in enumerated type %qT",
5506 CASE_LABEL (label
), buf
, type
);
5509 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5510 Used to verify that case values match up with enumerator values. */
5513 match_case_to_enum (splay_tree_node node
, void *data
)
5515 tree label
= (tree
) node
->value
;
5516 tree type
= (tree
) data
;
5518 /* Skip default case. */
5519 if (!CASE_LOW (label
))
5522 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5523 when we did our enum->case scan. Reset our scratch bit after. */
5524 if (!CASE_LOW_SEEN (label
))
5525 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
5527 CASE_LOW_SEEN (label
) = 0;
5529 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5530 not set, that means that CASE_HIGH did not appear when we did our
5531 enum->case scan. Reset our scratch bit after. */
5532 if (CASE_HIGH (label
))
5534 if (!CASE_HIGH_SEEN (label
))
5535 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
5537 CASE_HIGH_SEEN (label
) = 0;
5543 /* Handle -Wswitch*. Called from the front end after parsing the
5544 switch construct. */
5545 /* ??? Should probably be somewhere generic, since other languages
5546 besides C and C++ would want this. At the moment, however, C/C++
5547 are the only tree-ssa languages that support enumerations at all,
5548 so the point is moot. */
5551 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
5552 tree type
, tree cond
)
5554 splay_tree_node default_node
;
5555 splay_tree_node node
;
5557 int saved_warn_switch
;
5559 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
5562 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
5564 warning (OPT_Wswitch_default
, "%Hswitch missing default case",
5567 /* From here on, we only care about about enumerated types. */
5568 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
5571 /* If the switch expression was an enumerated type, check that
5572 exactly all enumeration literals are covered by the cases.
5573 The check is made when -Wswitch was specified and there is no
5574 default case, or when -Wswitch-enum was specified. */
5576 if (!warn_switch_enum
5577 && !(warn_switch
&& !default_node
))
5580 /* Clearing COND if it is not an integer constant simplifies
5581 the tests inside the loop below. */
5582 if (TREE_CODE (cond
) != INTEGER_CST
)
5585 /* The time complexity here is O(N*lg(N)) worst case, but for the
5586 common case of monotonically increasing enumerators, it is
5587 O(N), since the nature of the splay tree will keep the next
5588 element adjacent to the root at all times. */
5590 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
5592 tree value
= TREE_VALUE (chain
);
5593 if (TREE_CODE (value
) == CONST_DECL
)
5594 value
= DECL_INITIAL (value
);
5595 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
5598 /* Mark the CASE_LOW part of the case entry as seen. */
5599 tree label
= (tree
) node
->value
;
5600 CASE_LOW_SEEN (label
) = 1;
5604 /* Even though there wasn't an exact match, there might be a
5605 case range which includes the enumerator's value. */
5606 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
5607 if (node
&& CASE_HIGH ((tree
) node
->value
))
5609 tree label
= (tree
) node
->value
;
5610 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
5613 /* If we match the upper bound exactly, mark the CASE_HIGH
5614 part of the case entry as seen. */
5616 CASE_HIGH_SEEN (label
) = 1;
5621 /* We've now determined that this enumerated literal isn't
5622 handled by the case labels of the switch statement. */
5624 /* If the switch expression is a constant, we only really care
5625 about whether that constant is handled by the switch. */
5626 if (cond
&& tree_int_cst_compare (cond
, value
))
5629 /* If there is a default_node, the only relevant option is
5630 Wswitch-enum. Otherwise, if both are enabled then we prefer
5631 to warn using -Wswitch because -Wswitch is enabled by -Wall
5632 while -Wswitch-enum is explicit. */
5633 warning ((default_node
|| !warn_switch
)
5634 ? OPT_Wswitch_enum
: OPT_Wswitch
,
5635 "%Henumeration value %qE not handled in switch",
5636 &switch_location
, TREE_PURPOSE (chain
));
5639 /* Warn if there are case expressions that don't correspond to
5640 enumerators. This can occur since C and C++ don't enforce
5641 type-checking of assignments to enumeration variables.
5643 The time complexity here is now always O(N) worst case, since
5644 we should have marked both the lower bound and upper bound of
5645 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5646 above. This scan also resets those fields. */
5648 /* If there is a default_node, the only relevant option is
5649 Wswitch-enum. Otherwise, if both are enabled then we prefer
5650 to warn using -Wswitch because -Wswitch is enabled by -Wall
5651 while -Wswitch-enum is explicit. */
5652 saved_warn_switch
= warn_switch
;
5655 splay_tree_foreach (cases
, match_case_to_enum
, type
);
5656 warn_switch
= saved_warn_switch
;
5660 /* Finish an expression taking the address of LABEL (an
5661 IDENTIFIER_NODE). Returns an expression for the address.
5663 LOC is the location for the expression returned. */
5666 finish_label_address_expr (tree label
, location_t loc
)
5670 pedwarn (input_location
, OPT_pedantic
, "taking the address of a label is non-standard");
5672 if (label
== error_mark_node
)
5673 return error_mark_node
;
5675 label
= lookup_label (label
);
5676 if (label
== NULL_TREE
)
5677 result
= null_pointer_node
;
5680 TREE_USED (label
) = 1;
5681 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
5682 /* The current function in not necessarily uninlinable.
5683 Computed gotos are incompatible with inlining, but the value
5684 here could be used only in a diagnostic, for example. */
5685 protected_set_expr_location (result
, loc
);
5692 /* Given a boolean expression ARG, return a tree representing an increment
5693 or decrement (as indicated by CODE) of ARG. The front end must check for
5694 invalid cases (e.g., decrement in C++). */
5696 boolean_increment (enum tree_code code
, tree arg
)
5699 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
5701 arg
= stabilize_reference (arg
);
5704 case PREINCREMENT_EXPR
:
5705 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5707 case POSTINCREMENT_EXPR
:
5708 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5709 arg
= save_expr (arg
);
5710 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5711 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5713 case PREDECREMENT_EXPR
:
5714 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5715 invert_truthvalue (arg
));
5717 case POSTDECREMENT_EXPR
:
5718 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5719 invert_truthvalue (arg
));
5720 arg
= save_expr (arg
);
5721 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5722 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5727 TREE_SIDE_EFFECTS (val
) = 1;
5731 /* Built-in macros for stddef.h and stdint.h, that require macros
5732 defined in this file. */
5734 c_stddef_cpp_builtins(void)
5736 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
5737 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
5738 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
5739 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
5740 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
5741 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
5742 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
5743 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
5744 if (SIG_ATOMIC_TYPE
)
5745 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE
, 0);
5747 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE
, 0);
5749 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE
, 0);
5751 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE
, 0);
5753 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE
, 0);
5755 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE
, 0);
5757 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE
, 0);
5759 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE
, 0);
5761 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE
, 0);
5762 if (INT_LEAST8_TYPE
)
5763 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE
, 0);
5764 if (INT_LEAST16_TYPE
)
5765 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE
, 0);
5766 if (INT_LEAST32_TYPE
)
5767 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE
, 0);
5768 if (INT_LEAST64_TYPE
)
5769 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE
, 0);
5770 if (UINT_LEAST8_TYPE
)
5771 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE
, 0);
5772 if (UINT_LEAST16_TYPE
)
5773 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE
, 0);
5774 if (UINT_LEAST32_TYPE
)
5775 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE
, 0);
5776 if (UINT_LEAST64_TYPE
)
5777 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE
, 0);
5779 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE
, 0);
5780 if (INT_FAST16_TYPE
)
5781 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE
, 0);
5782 if (INT_FAST32_TYPE
)
5783 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE
, 0);
5784 if (INT_FAST64_TYPE
)
5785 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE
, 0);
5786 if (UINT_FAST8_TYPE
)
5787 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE
, 0);
5788 if (UINT_FAST16_TYPE
)
5789 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE
, 0);
5790 if (UINT_FAST32_TYPE
)
5791 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE
, 0);
5792 if (UINT_FAST64_TYPE
)
5793 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE
, 0);
5795 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE
, 0);
5797 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE
, 0);
5801 c_init_attributes (void)
5803 /* Fill in the built_in_attributes array. */
5804 #define DEF_ATTR_NULL_TREE(ENUM) \
5805 built_in_attributes[(int) ENUM] = NULL_TREE;
5806 #define DEF_ATTR_INT(ENUM, VALUE) \
5807 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5808 #define DEF_ATTR_IDENT(ENUM, STRING) \
5809 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5810 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5811 built_in_attributes[(int) ENUM] \
5812 = tree_cons (built_in_attributes[(int) PURPOSE], \
5813 built_in_attributes[(int) VALUE], \
5814 built_in_attributes[(int) CHAIN]);
5815 #include "builtin-attrs.def"
5816 #undef DEF_ATTR_NULL_TREE
5818 #undef DEF_ATTR_IDENT
5819 #undef DEF_ATTR_TREE_LIST
5822 /* Attribute handlers common to C front ends. */
5824 /* Handle a "packed" attribute; arguments as in
5825 struct attribute_spec.handler. */
5828 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5829 int flags
, bool *no_add_attrs
)
5833 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5834 *node
= build_variant_type_copy (*node
);
5835 TYPE_PACKED (*node
) = 1;
5837 else if (TREE_CODE (*node
) == FIELD_DECL
)
5839 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
5840 /* Still pack bitfields. */
5841 && ! DECL_INITIAL (*node
))
5842 warning (OPT_Wattributes
,
5843 "%qE attribute ignored for field of type %qT",
5844 name
, TREE_TYPE (*node
));
5846 DECL_PACKED (*node
) = 1;
5848 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5849 used for DECL_REGISTER. It wouldn't mean anything anyway.
5850 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5851 that changes what the typedef is typing. */
5854 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5855 *no_add_attrs
= true;
5861 /* Handle a "nocommon" attribute; arguments as in
5862 struct attribute_spec.handler. */
5865 handle_nocommon_attribute (tree
*node
, tree name
,
5866 tree
ARG_UNUSED (args
),
5867 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5869 if (TREE_CODE (*node
) == VAR_DECL
)
5870 DECL_COMMON (*node
) = 0;
5873 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5874 *no_add_attrs
= true;
5880 /* Handle a "common" attribute; arguments as in
5881 struct attribute_spec.handler. */
5884 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5885 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5887 if (TREE_CODE (*node
) == VAR_DECL
)
5888 DECL_COMMON (*node
) = 1;
5891 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5892 *no_add_attrs
= true;
5898 /* Handle a "noreturn" attribute; arguments as in
5899 struct attribute_spec.handler. */
5902 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5903 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5905 tree type
= TREE_TYPE (*node
);
5907 /* See FIXME comment in c_common_attribute_table. */
5908 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5909 TREE_THIS_VOLATILE (*node
) = 1;
5910 else if (TREE_CODE (type
) == POINTER_TYPE
5911 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5913 = build_pointer_type
5914 (build_type_variant (TREE_TYPE (type
),
5915 TYPE_READONLY (TREE_TYPE (type
)), 1));
5918 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5919 *no_add_attrs
= true;
5925 /* Handle a "hot" and attribute; arguments as in
5926 struct attribute_spec.handler. */
5929 handle_hot_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5930 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5932 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5934 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node
)) != NULL
)
5936 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5938 *no_add_attrs
= true;
5940 /* Most of the rest of the hot processing is done later with
5941 lookup_attribute. */
5945 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5946 *no_add_attrs
= true;
5951 /* Handle a "cold" and attribute; arguments as in
5952 struct attribute_spec.handler. */
5955 handle_cold_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5956 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5958 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5960 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node
)) != NULL
)
5962 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5964 *no_add_attrs
= true;
5966 /* Most of the rest of the cold processing is done later with
5967 lookup_attribute. */
5971 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5972 *no_add_attrs
= true;
5978 /* Handle a "noinline" attribute; arguments as in
5979 struct attribute_spec.handler. */
5982 handle_noinline_attribute (tree
*node
, tree name
,
5983 tree
ARG_UNUSED (args
),
5984 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5986 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5987 DECL_UNINLINABLE (*node
) = 1;
5990 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5991 *no_add_attrs
= true;
5997 /* Handle a "always_inline" attribute; arguments as in
5998 struct attribute_spec.handler. */
6001 handle_always_inline_attribute (tree
*node
, tree name
,
6002 tree
ARG_UNUSED (args
),
6003 int ARG_UNUSED (flags
),
6006 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6008 /* Set the attribute and mark it for disregarding inline
6010 DECL_DISREGARD_INLINE_LIMITS (*node
) = 1;
6014 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6015 *no_add_attrs
= true;
6021 /* Handle a "gnu_inline" attribute; arguments as in
6022 struct attribute_spec.handler. */
6025 handle_gnu_inline_attribute (tree
*node
, tree name
,
6026 tree
ARG_UNUSED (args
),
6027 int ARG_UNUSED (flags
),
6030 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
6032 /* Do nothing else, just set the attribute. We'll get at
6033 it later with lookup_attribute. */
6037 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6038 *no_add_attrs
= true;
6044 /* Handle an "artificial" attribute; arguments as in
6045 struct attribute_spec.handler. */
6048 handle_artificial_attribute (tree
*node
, tree name
,
6049 tree
ARG_UNUSED (args
),
6050 int ARG_UNUSED (flags
),
6053 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
6055 /* Do nothing else, just set the attribute. We'll get at
6056 it later with lookup_attribute. */
6060 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6061 *no_add_attrs
= true;
6067 /* Handle a "flatten" attribute; arguments as in
6068 struct attribute_spec.handler. */
6071 handle_flatten_attribute (tree
*node
, tree name
,
6072 tree args ATTRIBUTE_UNUSED
,
6073 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
6075 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6076 /* Do nothing else, just set the attribute. We'll get at
6077 it later with lookup_attribute. */
6081 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6082 *no_add_attrs
= true;
6088 /* Handle a "warning" or "error" attribute; arguments as in
6089 struct attribute_spec.handler. */
6092 handle_error_attribute (tree
*node
, tree name
, tree args
,
6093 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6095 if (TREE_CODE (*node
) == FUNCTION_DECL
6096 || TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
6097 /* Do nothing else, just set the attribute. We'll get at
6098 it later with lookup_attribute. */
6102 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6103 *no_add_attrs
= true;
6109 /* Handle a "used" attribute; arguments as in
6110 struct attribute_spec.handler. */
6113 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
6114 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6118 if (TREE_CODE (node
) == FUNCTION_DECL
6119 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
6121 TREE_USED (node
) = 1;
6122 DECL_PRESERVE_P (node
) = 1;
6126 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6127 *no_add_attrs
= true;
6133 /* Handle a "unused" attribute; arguments as in
6134 struct attribute_spec.handler. */
6137 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6138 int flags
, bool *no_add_attrs
)
6144 if (TREE_CODE (decl
) == PARM_DECL
6145 || TREE_CODE (decl
) == VAR_DECL
6146 || TREE_CODE (decl
) == FUNCTION_DECL
6147 || TREE_CODE (decl
) == LABEL_DECL
6148 || TREE_CODE (decl
) == TYPE_DECL
)
6149 TREE_USED (decl
) = 1;
6152 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6153 *no_add_attrs
= true;
6158 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6159 *node
= build_variant_type_copy (*node
);
6160 TREE_USED (*node
) = 1;
6166 /* Handle a "externally_visible" attribute; arguments as in
6167 struct attribute_spec.handler. */
6170 handle_externally_visible_attribute (tree
*pnode
, tree name
,
6171 tree
ARG_UNUSED (args
),
6172 int ARG_UNUSED (flags
),
6177 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
6179 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
6180 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
6182 warning (OPT_Wattributes
,
6183 "%qE attribute have effect only on public objects", name
);
6184 *no_add_attrs
= true;
6189 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6190 *no_add_attrs
= true;
6196 /* Handle a "const" attribute; arguments as in
6197 struct attribute_spec.handler. */
6200 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6201 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6203 tree type
= TREE_TYPE (*node
);
6205 /* See FIXME comment on noreturn in c_common_attribute_table. */
6206 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6207 TREE_READONLY (*node
) = 1;
6208 else if (TREE_CODE (type
) == POINTER_TYPE
6209 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
6211 = build_pointer_type
6212 (build_type_variant (TREE_TYPE (type
), 1,
6213 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
6216 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6217 *no_add_attrs
= true;
6223 /* Handle a "transparent_union" attribute; arguments as in
6224 struct attribute_spec.handler. */
6227 handle_transparent_union_attribute (tree
*node
, tree name
,
6228 tree
ARG_UNUSED (args
), int flags
,
6233 *no_add_attrs
= true;
6235 if (TREE_CODE (*node
) == TYPE_DECL
)
6236 node
= &TREE_TYPE (*node
);
6239 if (TREE_CODE (type
) == UNION_TYPE
)
6241 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6242 the code in finish_struct. */
6243 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6245 if (TYPE_FIELDS (type
) == NULL_TREE
6246 || TYPE_MODE (type
) != DECL_MODE (TYPE_FIELDS (type
)))
6249 /* A type variant isn't good enough, since we don't a cast
6250 to such a type removed as a no-op. */
6251 *node
= type
= build_duplicate_type (type
);
6254 TYPE_TRANSPARENT_UNION (type
) = 1;
6259 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6263 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6264 get the requested priority for a constructor or destructor,
6265 possibly issuing diagnostics for invalid or reserved
6268 static priority_type
6269 get_priority (tree args
, bool is_destructor
)
6275 return DEFAULT_INIT_PRIORITY
;
6277 if (!SUPPORTS_INIT_PRIORITY
)
6280 error ("destructor priorities are not supported");
6282 error ("constructor priorities are not supported");
6283 return DEFAULT_INIT_PRIORITY
;
6286 arg
= TREE_VALUE (args
);
6287 if (!host_integerp (arg
, /*pos=*/0)
6288 || !INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
6291 pri
= tree_low_cst (TREE_VALUE (args
), /*pos=*/0);
6292 if (pri
< 0 || pri
> MAX_INIT_PRIORITY
)
6295 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
6299 "destructor priorities from 0 to %d are reserved "
6300 "for the implementation",
6301 MAX_RESERVED_INIT_PRIORITY
);
6304 "constructor priorities from 0 to %d are reserved "
6305 "for the implementation",
6306 MAX_RESERVED_INIT_PRIORITY
);
6312 error ("destructor priorities must be integers from 0 to %d inclusive",
6315 error ("constructor priorities must be integers from 0 to %d inclusive",
6317 return DEFAULT_INIT_PRIORITY
;
6320 /* Handle a "constructor" attribute; arguments as in
6321 struct attribute_spec.handler. */
6324 handle_constructor_attribute (tree
*node
, tree name
, tree args
,
6325 int ARG_UNUSED (flags
),
6329 tree type
= TREE_TYPE (decl
);
6331 if (TREE_CODE (decl
) == FUNCTION_DECL
6332 && TREE_CODE (type
) == FUNCTION_TYPE
6333 && decl_function_context (decl
) == 0)
6335 priority_type priority
;
6336 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
6337 priority
= get_priority (args
, /*is_destructor=*/false);
6338 SET_DECL_INIT_PRIORITY (decl
, priority
);
6339 TREE_USED (decl
) = 1;
6343 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6344 *no_add_attrs
= true;
6350 /* Handle a "destructor" attribute; arguments as in
6351 struct attribute_spec.handler. */
6354 handle_destructor_attribute (tree
*node
, tree name
, tree args
,
6355 int ARG_UNUSED (flags
),
6359 tree type
= TREE_TYPE (decl
);
6361 if (TREE_CODE (decl
) == FUNCTION_DECL
6362 && TREE_CODE (type
) == FUNCTION_TYPE
6363 && decl_function_context (decl
) == 0)
6365 priority_type priority
;
6366 DECL_STATIC_DESTRUCTOR (decl
) = 1;
6367 priority
= get_priority (args
, /*is_destructor=*/true);
6368 SET_DECL_FINI_PRIORITY (decl
, priority
);
6369 TREE_USED (decl
) = 1;
6373 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6374 *no_add_attrs
= true;
6380 /* Handle a "mode" attribute; arguments as in
6381 struct attribute_spec.handler. */
6384 handle_mode_attribute (tree
*node
, tree name
, tree args
,
6385 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6389 *no_add_attrs
= true;
6391 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
6392 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6396 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
6397 int len
= strlen (p
);
6398 enum machine_mode mode
= VOIDmode
;
6402 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
6403 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
6405 char *newp
= (char *) alloca (len
- 1);
6407 strcpy (newp
, &p
[2]);
6408 newp
[len
- 4] = '\0';
6412 /* Change this type to have a type with the specified mode.
6413 First check for the special modes. */
6414 if (!strcmp (p
, "byte"))
6416 else if (!strcmp (p
, "word"))
6418 else if (!strcmp (p
, "pointer"))
6420 else if (!strcmp (p
, "libgcc_cmp_return"))
6421 mode
= targetm
.libgcc_cmp_return_mode ();
6422 else if (!strcmp (p
, "libgcc_shift_count"))
6423 mode
= targetm
.libgcc_shift_count_mode ();
6424 else if (!strcmp (p
, "unwind_word"))
6425 mode
= targetm
.unwind_word_mode ();
6427 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
6428 if (!strcmp (p
, GET_MODE_NAME (j
)))
6430 mode
= (enum machine_mode
) j
;
6434 if (mode
== VOIDmode
)
6436 error ("unknown machine mode %qs", p
);
6441 switch (GET_MODE_CLASS (mode
))
6444 case MODE_PARTIAL_INT
:
6446 case MODE_DECIMAL_FLOAT
:
6451 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
6454 case MODE_COMPLEX_INT
:
6455 case MODE_COMPLEX_FLOAT
:
6456 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
6459 case MODE_VECTOR_INT
:
6460 case MODE_VECTOR_FLOAT
:
6461 case MODE_VECTOR_FRACT
:
6462 case MODE_VECTOR_UFRACT
:
6463 case MODE_VECTOR_ACCUM
:
6464 case MODE_VECTOR_UACCUM
:
6465 warning (OPT_Wattributes
, "specifying vector types with "
6466 "__attribute__ ((mode)) is deprecated");
6467 warning (OPT_Wattributes
,
6468 "use __attribute__ ((vector_size)) instead");
6469 valid_mode
= vector_mode_valid_p (mode
);
6477 error ("unable to emulate %qs", p
);
6481 if (POINTER_TYPE_P (type
))
6483 tree (*fn
)(tree
, enum machine_mode
, bool);
6485 if (!targetm
.valid_pointer_mode (mode
))
6487 error ("invalid pointer mode %qs", p
);
6491 if (TREE_CODE (type
) == POINTER_TYPE
)
6492 fn
= build_pointer_type_for_mode
;
6494 fn
= build_reference_type_for_mode
;
6495 typefm
= fn (TREE_TYPE (type
), mode
, false);
6499 /* For fixed-point modes, we need to test if the signness of type
6500 and the machine mode are consistent. */
6501 if (ALL_FIXED_POINT_MODE_P (mode
)
6502 && TYPE_UNSIGNED (type
) != UNSIGNED_FIXED_POINT_MODE_P (mode
))
6504 error ("signness of type and machine mode %qs don't match", p
);
6507 /* For fixed-point modes, we need to pass saturating info. */
6508 typefm
= lang_hooks
.types
.type_for_mode (mode
,
6509 ALL_FIXED_POINT_MODE_P (mode
) ? TYPE_SATURATING (type
)
6510 : TYPE_UNSIGNED (type
));
6513 if (typefm
== NULL_TREE
)
6515 error ("no data type for mode %qs", p
);
6518 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
6520 /* For enumeral types, copy the precision from the integer
6521 type returned above. If not an INTEGER_TYPE, we can't use
6522 this mode for this type. */
6523 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
6525 error ("cannot use mode %qs for enumeral types", p
);
6529 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
6531 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
6536 /* We cannot build a type variant, as there's code that assumes
6537 that TYPE_MAIN_VARIANT has the same mode. This includes the
6538 debug generators. Instead, create a subrange type. This
6539 results in all of the enumeral values being emitted only once
6540 in the original, and the subtype gets them by reference. */
6541 if (TYPE_UNSIGNED (type
))
6542 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
6544 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
6545 TREE_TYPE (typefm
) = type
;
6548 else if (VECTOR_MODE_P (mode
)
6549 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
6550 : TREE_CODE (type
) != TREE_CODE (typefm
))
6552 error ("mode %qs applied to inappropriate type", p
);
6562 /* Handle a "section" attribute; arguments as in
6563 struct attribute_spec.handler. */
6566 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6567 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6571 if (targetm
.have_named_sections
)
6573 user_defined_section_attribute
= true;
6575 if ((TREE_CODE (decl
) == FUNCTION_DECL
6576 || TREE_CODE (decl
) == VAR_DECL
)
6577 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
6579 if (TREE_CODE (decl
) == VAR_DECL
6580 && current_function_decl
!= NULL_TREE
6581 && !TREE_STATIC (decl
))
6583 error ("%Jsection attribute cannot be specified for "
6584 "local variables", decl
);
6585 *no_add_attrs
= true;
6588 /* The decl may have already been given a section attribute
6589 from a previous declaration. Ensure they match. */
6590 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
6591 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
6592 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
6594 error ("section of %q+D conflicts with previous declaration",
6596 *no_add_attrs
= true;
6598 else if (TREE_CODE (decl
) == VAR_DECL
6599 && !targetm
.have_tls
&& targetm
.emutls
.tmpl_section
6600 && DECL_THREAD_LOCAL_P (decl
))
6602 error ("section of %q+D cannot be overridden", *node
);
6603 *no_add_attrs
= true;
6606 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
6610 error ("section attribute not allowed for %q+D", *node
);
6611 *no_add_attrs
= true;
6616 error ("%Jsection attributes are not supported for this target", *node
);
6617 *no_add_attrs
= true;
6623 /* Handle a "aligned" attribute; arguments as in
6624 struct attribute_spec.handler. */
6627 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6628 int flags
, bool *no_add_attrs
)
6630 tree decl
= NULL_TREE
;
6633 tree align_expr
= (args
? TREE_VALUE (args
)
6634 : size_int (ATTRIBUTE_ALIGNED_VALUE
/ BITS_PER_UNIT
));
6640 type
= &TREE_TYPE (decl
);
6641 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
6643 else if (TYPE_P (*node
))
6644 type
= node
, is_type
= 1;
6646 if (TREE_CODE (align_expr
) != INTEGER_CST
)
6648 error ("requested alignment is not a constant");
6649 *no_add_attrs
= true;
6651 else if ((i
= tree_log2 (align_expr
)) == -1)
6653 error ("requested alignment is not a power of 2");
6654 *no_add_attrs
= true;
6656 else if (i
>= HOST_BITS_PER_INT
- BITS_PER_UNIT_LOG
)
6658 error ("requested alignment is too large");
6659 *no_add_attrs
= true;
6663 /* If we have a TYPE_DECL, then copy the type, so that we
6664 don't accidentally modify a builtin type. See pushdecl. */
6665 if (decl
&& TREE_TYPE (decl
) != error_mark_node
6666 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
6668 tree tt
= TREE_TYPE (decl
);
6669 *type
= build_variant_type_copy (*type
);
6670 DECL_ORIGINAL_TYPE (decl
) = tt
;
6671 TYPE_NAME (*type
) = decl
;
6672 TREE_USED (*type
) = TREE_USED (decl
);
6673 TREE_TYPE (decl
) = *type
;
6675 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6676 *type
= build_variant_type_copy (*type
);
6678 TYPE_ALIGN (*type
) = (1U << i
) * BITS_PER_UNIT
;
6679 TYPE_USER_ALIGN (*type
) = 1;
6681 else if (! VAR_OR_FUNCTION_DECL_P (decl
)
6682 && TREE_CODE (decl
) != FIELD_DECL
)
6684 error ("alignment may not be specified for %q+D", decl
);
6685 *no_add_attrs
= true;
6687 else if (TREE_CODE (decl
) == FUNCTION_DECL
6688 && DECL_ALIGN (decl
) > (1U << i
) * BITS_PER_UNIT
)
6690 if (DECL_USER_ALIGN (decl
))
6691 error ("alignment for %q+D was previously specified as %d "
6692 "and may not be decreased", decl
,
6693 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6695 error ("alignment for %q+D must be at least %d", decl
,
6696 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6697 *no_add_attrs
= true;
6701 DECL_ALIGN (decl
) = (1U << i
) * BITS_PER_UNIT
;
6702 DECL_USER_ALIGN (decl
) = 1;
6708 /* Handle a "weak" attribute; arguments as in
6709 struct attribute_spec.handler. */
6712 handle_weak_attribute (tree
*node
, tree name
,
6713 tree
ARG_UNUSED (args
),
6714 int ARG_UNUSED (flags
),
6715 bool * ARG_UNUSED (no_add_attrs
))
6717 if (TREE_CODE (*node
) == FUNCTION_DECL
6718 && DECL_DECLARED_INLINE_P (*node
))
6720 error ("inline function %q+D cannot be declared weak", *node
);
6721 *no_add_attrs
= true;
6723 else if (TREE_CODE (*node
) == FUNCTION_DECL
6724 || TREE_CODE (*node
) == VAR_DECL
)
6725 declare_weak (*node
);
6727 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6732 /* Handle an "alias" attribute; arguments as in
6733 struct attribute_spec.handler. */
6736 handle_alias_attribute (tree
*node
, tree name
, tree args
,
6737 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6741 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
6743 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6744 *no_add_attrs
= true;
6746 else if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
6747 || (TREE_CODE (decl
) != FUNCTION_DECL
6748 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
6749 /* A static variable declaration is always a tentative definition,
6750 but the alias is a non-tentative definition which overrides. */
6751 || (TREE_CODE (decl
) != FUNCTION_DECL
6752 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
6754 error ("%q+D defined both normally and as an alias", decl
);
6755 *no_add_attrs
= true;
6758 /* Note that the very first time we process a nested declaration,
6759 decl_function_context will not be set. Indeed, *would* never
6760 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6761 we do below. After such frobbery, pushdecl would set the context.
6762 In any case, this is never what we want. */
6763 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
6767 id
= TREE_VALUE (args
);
6768 if (TREE_CODE (id
) != STRING_CST
)
6770 error ("alias argument not a string");
6771 *no_add_attrs
= true;
6774 id
= get_identifier (TREE_STRING_POINTER (id
));
6775 /* This counts as a use of the object pointed to. */
6778 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6779 DECL_INITIAL (decl
) = error_mark_node
;
6782 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
6783 DECL_EXTERNAL (decl
) = 1;
6785 DECL_EXTERNAL (decl
) = 0;
6786 TREE_STATIC (decl
) = 1;
6791 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6792 *no_add_attrs
= true;
6798 /* Handle a "weakref" attribute; arguments as in struct
6799 attribute_spec.handler. */
6802 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6803 int flags
, bool *no_add_attrs
)
6805 tree attr
= NULL_TREE
;
6807 /* We must ignore the attribute when it is associated with
6808 local-scoped decls, since attribute alias is ignored and many
6809 such symbols do not even have a DECL_WEAK field. */
6810 if (decl_function_context (*node
)
6811 || current_function_decl
6812 || (TREE_CODE (*node
) != VAR_DECL
&& TREE_CODE (*node
) != FUNCTION_DECL
))
6814 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6815 *no_add_attrs
= true;
6819 /* The idea here is that `weakref("name")' mutates into `weakref,
6820 alias("name")', and weakref without arguments, in turn,
6821 implicitly adds weak. */
6825 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
6826 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
6828 *no_add_attrs
= true;
6830 decl_attributes (node
, attr
, flags
);
6834 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
6835 error ("%Jweakref attribute must appear before alias attribute",
6838 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6839 and that isn't supported; and because it wants to add it to
6840 the list of weak decls, which isn't helpful. */
6841 DECL_WEAK (*node
) = 1;
6847 /* Handle an "visibility" attribute; arguments as in
6848 struct attribute_spec.handler. */
6851 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
6852 int ARG_UNUSED (flags
),
6853 bool *ARG_UNUSED (no_add_attrs
))
6856 tree id
= TREE_VALUE (args
);
6857 enum symbol_visibility vis
;
6861 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
6863 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
6865 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
6869 else if (TYPE_FIELDS (*node
))
6871 error ("%qE attribute ignored because %qT is already defined",
6876 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
6878 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6882 if (TREE_CODE (id
) != STRING_CST
)
6884 error ("visibility argument not a string");
6888 /* If this is a type, set the visibility on the type decl. */
6891 decl
= TYPE_NAME (decl
);
6894 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6896 warning (OPT_Wattributes
, "%qE attribute ignored on types",
6902 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
6903 vis
= VISIBILITY_DEFAULT
;
6904 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
6905 vis
= VISIBILITY_INTERNAL
;
6906 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
6907 vis
= VISIBILITY_HIDDEN
;
6908 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
6909 vis
= VISIBILITY_PROTECTED
;
6912 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6913 vis
= VISIBILITY_DEFAULT
;
6916 if (DECL_VISIBILITY_SPECIFIED (decl
)
6917 && vis
!= DECL_VISIBILITY (decl
))
6919 tree attributes
= (TYPE_P (*node
)
6920 ? TYPE_ATTRIBUTES (*node
)
6921 : DECL_ATTRIBUTES (decl
));
6922 if (lookup_attribute ("visibility", attributes
))
6923 error ("%qD redeclared with different visibility", decl
);
6924 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6925 && lookup_attribute ("dllimport", attributes
))
6926 error ("%qD was declared %qs which implies default visibility",
6928 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6929 && lookup_attribute ("dllexport", attributes
))
6930 error ("%qD was declared %qs which implies default visibility",
6934 DECL_VISIBILITY (decl
) = vis
;
6935 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
6937 /* Go ahead and attach the attribute to the node as well. This is needed
6938 so we can determine whether we have VISIBILITY_DEFAULT because the
6939 visibility was not specified, or because it was explicitly overridden
6940 from the containing scope. */
6945 /* Determine the ELF symbol visibility for DECL, which is either a
6946 variable or a function. It is an error to use this function if a
6947 definition of DECL is not available in this translation unit.
6948 Returns true if the final visibility has been determined by this
6949 function; false if the caller is free to make additional
6953 c_determine_visibility (tree decl
)
6955 gcc_assert (TREE_CODE (decl
) == VAR_DECL
6956 || TREE_CODE (decl
) == FUNCTION_DECL
);
6958 /* If the user explicitly specified the visibility with an
6959 attribute, honor that. DECL_VISIBILITY will have been set during
6960 the processing of the attribute. We check for an explicit
6961 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6962 to distinguish the use of an attribute from the use of a "#pragma
6963 GCC visibility push(...)"; in the latter case we still want other
6964 considerations to be able to overrule the #pragma. */
6965 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
6966 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6967 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
6968 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
6971 /* Set default visibility to whatever the user supplied with
6972 visibility_specified depending on #pragma GCC visibility. */
6973 if (!DECL_VISIBILITY_SPECIFIED (decl
))
6975 if (visibility_options
.inpragma
6976 || DECL_VISIBILITY (decl
) != default_visibility
)
6978 DECL_VISIBILITY (decl
) = default_visibility
;
6979 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
6980 /* If visibility changed and DECL already has DECL_RTL, ensure
6981 symbol flags are updated. */
6982 if (((TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
6983 || TREE_CODE (decl
) == FUNCTION_DECL
)
6984 && DECL_RTL_SET_P (decl
))
6985 make_decl_rtl (decl
);
6991 /* Handle an "tls_model" attribute; arguments as in
6992 struct attribute_spec.handler. */
6995 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
6996 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7000 enum tls_model kind
;
7002 *no_add_attrs
= true;
7004 if (TREE_CODE (decl
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (decl
))
7006 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7010 kind
= DECL_TLS_MODEL (decl
);
7011 id
= TREE_VALUE (args
);
7012 if (TREE_CODE (id
) != STRING_CST
)
7014 error ("tls_model argument not a string");
7018 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
7019 kind
= TLS_MODEL_LOCAL_EXEC
;
7020 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
7021 kind
= TLS_MODEL_INITIAL_EXEC
;
7022 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
7023 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
7024 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
7025 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
7027 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7029 DECL_TLS_MODEL (decl
) = kind
;
7033 /* Handle a "no_instrument_function" attribute; arguments as in
7034 struct attribute_spec.handler. */
7037 handle_no_instrument_function_attribute (tree
*node
, tree name
,
7038 tree
ARG_UNUSED (args
),
7039 int ARG_UNUSED (flags
),
7044 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7046 error ("%J%qE attribute applies only to functions", decl
, name
);
7047 *no_add_attrs
= true;
7049 else if (DECL_INITIAL (decl
))
7051 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
7052 *no_add_attrs
= true;
7055 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
7060 /* Handle a "malloc" attribute; arguments as in
7061 struct attribute_spec.handler. */
7064 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7065 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7067 if (TREE_CODE (*node
) == FUNCTION_DECL
7068 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
7069 DECL_IS_MALLOC (*node
) = 1;
7072 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7073 *no_add_attrs
= true;
7079 /* Handle a "alloc_size" attribute; arguments as in
7080 struct attribute_spec.handler. */
7083 handle_alloc_size_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
7084 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7086 unsigned arg_count
= type_num_arguments (*node
);
7087 for (; args
; args
= TREE_CHAIN (args
))
7089 tree position
= TREE_VALUE (args
);
7091 if (TREE_CODE (position
) != INTEGER_CST
7092 || TREE_INT_CST_HIGH (position
)
7093 || TREE_INT_CST_LOW (position
) < 1
7094 || TREE_INT_CST_LOW (position
) > arg_count
)
7096 warning (OPT_Wattributes
,
7097 "alloc_size parameter outside range");
7098 *no_add_attrs
= true;
7105 /* Handle a "returns_twice" attribute; arguments as in
7106 struct attribute_spec.handler. */
7109 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7110 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7112 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7113 DECL_IS_RETURNS_TWICE (*node
) = 1;
7116 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7117 *no_add_attrs
= true;
7123 /* Handle a "no_limit_stack" attribute; arguments as in
7124 struct attribute_spec.handler. */
7127 handle_no_limit_stack_attribute (tree
*node
, tree name
,
7128 tree
ARG_UNUSED (args
),
7129 int ARG_UNUSED (flags
),
7134 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7136 error ("%J%qE attribute applies only to functions", decl
, name
);
7137 *no_add_attrs
= true;
7139 else if (DECL_INITIAL (decl
))
7141 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
7142 *no_add_attrs
= true;
7145 DECL_NO_LIMIT_STACK (decl
) = 1;
7150 /* Handle a "pure" attribute; arguments as in
7151 struct attribute_spec.handler. */
7154 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7155 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7157 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7158 DECL_PURE_P (*node
) = 1;
7159 /* ??? TODO: Support types. */
7162 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7163 *no_add_attrs
= true;
7169 /* Handle a "no vops" attribute; arguments as in
7170 struct attribute_spec.handler. */
7173 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7174 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
7175 bool *ARG_UNUSED (no_add_attrs
))
7177 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
7178 DECL_IS_NOVOPS (*node
) = 1;
7182 /* Handle a "deprecated" attribute; arguments as in
7183 struct attribute_spec.handler. */
7186 handle_deprecated_attribute (tree
*node
, tree name
,
7187 tree
ARG_UNUSED (args
), int flags
,
7190 tree type
= NULL_TREE
;
7192 tree what
= NULL_TREE
;
7197 type
= TREE_TYPE (decl
);
7199 if (TREE_CODE (decl
) == TYPE_DECL
7200 || TREE_CODE (decl
) == PARM_DECL
7201 || TREE_CODE (decl
) == VAR_DECL
7202 || TREE_CODE (decl
) == FUNCTION_DECL
7203 || TREE_CODE (decl
) == FIELD_DECL
)
7204 TREE_DEPRECATED (decl
) = 1;
7208 else if (TYPE_P (*node
))
7210 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
7211 *node
= build_variant_type_copy (*node
);
7212 TREE_DEPRECATED (*node
) = 1;
7220 *no_add_attrs
= true;
7221 if (type
&& TYPE_NAME (type
))
7223 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
7224 what
= TYPE_NAME (*node
);
7225 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
7226 && DECL_NAME (TYPE_NAME (type
)))
7227 what
= DECL_NAME (TYPE_NAME (type
));
7230 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
7232 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7238 /* Handle a "vector_size" attribute; arguments as in
7239 struct attribute_spec.handler. */
7242 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
7243 int ARG_UNUSED (flags
),
7246 unsigned HOST_WIDE_INT vecsize
, nunits
;
7247 enum machine_mode orig_mode
;
7248 tree type
= *node
, new_type
, size
;
7250 *no_add_attrs
= true;
7252 size
= TREE_VALUE (args
);
7254 if (!host_integerp (size
, 1))
7256 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7260 /* Get the vector size (in bytes). */
7261 vecsize
= tree_low_cst (size
, 1);
7263 /* We need to provide for vector pointers, vector arrays, and
7264 functions returning vectors. For example:
7266 __attribute__((vector_size(16))) short *foo;
7268 In this case, the mode is SI, but the type being modified is
7269 HI, so we need to look further. */
7271 while (POINTER_TYPE_P (type
)
7272 || TREE_CODE (type
) == FUNCTION_TYPE
7273 || TREE_CODE (type
) == METHOD_TYPE
7274 || TREE_CODE (type
) == ARRAY_TYPE
7275 || TREE_CODE (type
) == OFFSET_TYPE
)
7276 type
= TREE_TYPE (type
);
7278 /* Get the mode of the type being modified. */
7279 orig_mode
= TYPE_MODE (type
);
7281 if ((!INTEGRAL_TYPE_P (type
)
7282 && !SCALAR_FLOAT_TYPE_P (type
)
7283 && !FIXED_POINT_TYPE_P (type
))
7284 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
7285 && GET_MODE_CLASS (orig_mode
) != MODE_INT
7286 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode
))
7287 || !host_integerp (TYPE_SIZE_UNIT (type
), 1)
7288 || TREE_CODE (type
) == BOOLEAN_TYPE
)
7290 error ("invalid vector type for attribute %qE", name
);
7294 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
7296 error ("vector size not an integral multiple of component size");
7302 error ("zero vector size");
7306 /* Calculate how many units fit in the vector. */
7307 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
7308 if (nunits
& (nunits
- 1))
7310 error ("number of components of the vector not a power of two");
7314 new_type
= build_vector_type (type
, nunits
);
7316 /* Build back pointers if needed. */
7317 *node
= lang_hooks
.types
.reconstruct_complex_type (*node
, new_type
);
7322 /* Handle the "nonnull" attribute. */
7324 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7325 tree args
, int ARG_UNUSED (flags
),
7329 unsigned HOST_WIDE_INT attr_arg_num
;
7331 /* If no arguments are specified, all pointer arguments should be
7332 non-null. Verify a full prototype is given so that the arguments
7333 will have the correct types when we actually check them later. */
7336 if (!TYPE_ARG_TYPES (type
))
7338 error ("nonnull attribute without arguments on a non-prototype");
7339 *no_add_attrs
= true;
7344 /* Argument list specified. Verify that each argument number references
7345 a pointer argument. */
7346 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
7349 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
7351 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
7353 error ("nonnull argument has invalid operand number (argument %lu)",
7354 (unsigned long) attr_arg_num
);
7355 *no_add_attrs
= true;
7359 argument
= TYPE_ARG_TYPES (type
);
7362 for (ck_num
= 1; ; ck_num
++)
7364 if (!argument
|| ck_num
== arg_num
)
7366 argument
= TREE_CHAIN (argument
);
7370 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
7372 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7373 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7374 *no_add_attrs
= true;
7378 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
7380 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7381 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7382 *no_add_attrs
= true;
7391 /* Check the argument list of a function call for null in argument slots
7392 that are marked as requiring a non-null pointer argument. The NARGS
7393 arguments are passed in the array ARGARRAY.
7397 check_function_nonnull (tree attrs
, int nargs
, tree
*argarray
)
7402 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
7404 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
7406 args
= TREE_VALUE (a
);
7408 /* Walk the argument list. If we encounter an argument number we
7409 should check for non-null, do it. If the attribute has no args,
7410 then every pointer argument is checked (in which case the check
7411 for pointer type is done in check_nonnull_arg). */
7412 for (i
= 0; i
< nargs
; i
++)
7414 if (!args
|| nonnull_check_p (args
, i
+ 1))
7415 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
7423 /* Check that the Nth argument of a function call (counting backwards
7424 from the end) is a (pointer)0. The NARGS arguments are passed in the
7428 check_function_sentinel (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7430 tree attr
= lookup_attribute ("sentinel", attrs
);
7438 /* Skip over the named arguments. */
7439 while (typelist
&& len
< nargs
)
7441 typelist
= TREE_CHAIN (typelist
);
7445 if (TREE_VALUE (attr
))
7447 tree p
= TREE_VALUE (TREE_VALUE (attr
));
7448 pos
= TREE_INT_CST_LOW (p
);
7451 /* The sentinel must be one of the varargs, i.e.
7452 in position >= the number of fixed arguments. */
7453 if ((nargs
- 1 - pos
) < len
)
7455 warning (OPT_Wformat
,
7456 "not enough variable arguments to fit a sentinel");
7460 /* Validate the sentinel. */
7461 sentinel
= argarray
[nargs
- 1 - pos
];
7462 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
7463 || !integer_zerop (sentinel
))
7464 /* Although __null (in C++) is only an integer we allow it
7465 nevertheless, as we are guaranteed that it's exactly
7466 as wide as a pointer, and we don't want to force
7467 users to cast the NULL they have written there.
7468 We warn with -Wstrict-null-sentinel, though. */
7469 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
7470 warning (OPT_Wformat
, "missing sentinel in function call");
7474 /* Helper for check_function_nonnull; given a list of operands which
7475 must be non-null in ARGS, determine if operand PARAM_NUM should be
7479 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
7481 unsigned HOST_WIDE_INT arg_num
= 0;
7483 for (; args
; args
= TREE_CHAIN (args
))
7485 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
7489 if (arg_num
== param_num
)
7495 /* Check that the function argument PARAM (which is operand number
7496 PARAM_NUM) is non-null. This is called by check_function_nonnull
7497 via check_function_arguments_recurse. */
7500 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
7501 unsigned HOST_WIDE_INT param_num
)
7503 /* Just skip checking the argument if it's not a pointer. This can
7504 happen if the "nonnull" attribute was given without an operand
7505 list (which means to check every pointer argument). */
7507 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
7510 if (integer_zerop (param
))
7511 warning (OPT_Wnonnull
, "null argument where non-null required "
7512 "(argument %lu)", (unsigned long) param_num
);
7515 /* Helper for nonnull attribute handling; fetch the operand number
7516 from the attribute argument list. */
7519 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
7521 /* Verify the arg number is a constant. */
7522 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
7523 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
7526 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
7530 /* Handle a "nothrow" attribute; arguments as in
7531 struct attribute_spec.handler. */
7534 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7535 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7537 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7538 TREE_NOTHROW (*node
) = 1;
7539 /* ??? TODO: Support types. */
7542 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7543 *no_add_attrs
= true;
7549 /* Handle a "cleanup" attribute; arguments as in
7550 struct attribute_spec.handler. */
7553 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
7554 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7557 tree cleanup_id
, cleanup_decl
;
7559 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7560 for global destructors in C++. This requires infrastructure that
7561 we don't have generically at the moment. It's also not a feature
7562 we'd be missing too much, since we do have attribute constructor. */
7563 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
7565 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7566 *no_add_attrs
= true;
7570 /* Verify that the argument is a function in scope. */
7571 /* ??? We could support pointers to functions here as well, if
7572 that was considered desirable. */
7573 cleanup_id
= TREE_VALUE (args
);
7574 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
7576 error ("cleanup argument not an identifier");
7577 *no_add_attrs
= true;
7580 cleanup_decl
= lookup_name (cleanup_id
);
7581 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
7583 error ("cleanup argument not a function");
7584 *no_add_attrs
= true;
7588 /* That the function has proper type is checked with the
7589 eventual call to build_function_call. */
7594 /* Handle a "warn_unused_result" attribute. No special handling. */
7597 handle_warn_unused_result_attribute (tree
*node
, tree name
,
7598 tree
ARG_UNUSED (args
),
7599 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7601 /* Ignore the attribute for functions not returning any value. */
7602 if (VOID_TYPE_P (TREE_TYPE (*node
)))
7604 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7605 *no_add_attrs
= true;
7611 /* Handle a "sentinel" attribute. */
7614 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
7615 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7617 tree params
= TYPE_ARG_TYPES (*node
);
7621 warning (OPT_Wattributes
,
7622 "%qE attribute requires prototypes with named arguments", name
);
7623 *no_add_attrs
= true;
7627 while (TREE_CHAIN (params
))
7628 params
= TREE_CHAIN (params
);
7630 if (VOID_TYPE_P (TREE_VALUE (params
)))
7632 warning (OPT_Wattributes
,
7633 "%qE attribute only applies to variadic functions", name
);
7634 *no_add_attrs
= true;
7640 tree position
= TREE_VALUE (args
);
7642 if (TREE_CODE (position
) != INTEGER_CST
)
7644 warning (OPT_Wattributes
,
7645 "requested position is not an integer constant");
7646 *no_add_attrs
= true;
7650 if (tree_int_cst_lt (position
, integer_zero_node
))
7652 warning (OPT_Wattributes
,
7653 "requested position is less than zero");
7654 *no_add_attrs
= true;
7662 /* Handle a "type_generic" attribute. */
7665 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7666 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
7667 bool * ARG_UNUSED (no_add_attrs
))
7671 /* Ensure we have a function type. */
7672 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
7674 params
= TYPE_ARG_TYPES (*node
);
7675 while (params
&& ! VOID_TYPE_P (TREE_VALUE (params
)))
7676 params
= TREE_CHAIN (params
);
7678 /* Ensure we have a variadic function. */
7679 gcc_assert (!params
);
7684 /* Handle a "target" attribute. */
7687 handle_target_attribute (tree
*node
, tree name
, tree args
, int flags
,
7690 /* Ensure we have a function type. */
7691 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7693 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7694 *no_add_attrs
= true;
7696 else if (! targetm
.target_option
.valid_attribute_p (*node
, name
, args
,
7698 *no_add_attrs
= true;
7703 /* Arguments being collected for optimization. */
7704 typedef const char *const_char_p
; /* For DEF_VEC_P. */
7705 DEF_VEC_P(const_char_p
);
7706 DEF_VEC_ALLOC_P(const_char_p
, gc
);
7707 static GTY(()) VEC(const_char_p
, gc
) *optimize_args
;
7710 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7711 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7712 false for #pragma GCC optimize. */
7715 parse_optimize_options (tree args
, bool attr_p
)
7720 int saved_flag_strict_aliasing
;
7721 const char **opt_argv
;
7724 /* Build up argv vector. Just in case the string is stored away, use garbage
7725 collected strings. */
7726 VEC_truncate (const_char_p
, optimize_args
, 0);
7727 VEC_safe_push (const_char_p
, gc
, optimize_args
, NULL
);
7729 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
7731 tree value
= TREE_VALUE (ap
);
7733 if (TREE_CODE (value
) == INTEGER_CST
)
7736 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
7737 VEC_safe_push (const_char_p
, gc
, optimize_args
, ggc_strdup (buffer
));
7740 else if (TREE_CODE (value
) == STRING_CST
)
7742 /* Split string into multiple substrings. */
7743 size_t len
= TREE_STRING_LENGTH (value
);
7744 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
7745 char *end
= p
+ len
;
7749 while (next_p
!= NULL
)
7755 comma
= strchr (p
, ',');
7768 r
= q
= (char *) ggc_alloc (len2
+ 3);
7770 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7772 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
7776 warning (OPT_Wattributes
,
7777 "Bad option %s to optimize attribute.", p
);
7779 warning (OPT_Wpragmas
,
7780 "Bad option %s to pragma attribute", p
);
7788 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7789 itself is -Os, and any other switch begins with a -f. */
7790 if ((*p
>= '0' && *p
<= '9')
7791 || (p
[0] == 's' && p
[1] == '\0'))
7797 memcpy (r
, p
, len2
);
7799 VEC_safe_push (const_char_p
, gc
, optimize_args
, q
);
7805 opt_argc
= VEC_length (const_char_p
, optimize_args
);
7806 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
7808 for (i
= 1; i
< opt_argc
; i
++)
7809 opt_argv
[i
] = VEC_index (const_char_p
, optimize_args
, i
);
7811 saved_flag_strict_aliasing
= flag_strict_aliasing
;
7813 /* Now parse the options. */
7814 decode_options (opt_argc
, opt_argv
);
7816 /* Don't allow changing -fstrict-aliasing. */
7817 flag_strict_aliasing
= saved_flag_strict_aliasing
;
7819 VEC_truncate (const_char_p
, optimize_args
, 0);
7823 /* For handling "optimize" attribute. arguments as in
7824 struct attribute_spec.handler. */
7827 handle_optimize_attribute (tree
*node
, tree name
, tree args
,
7828 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7830 /* Ensure we have a function type. */
7831 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7833 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7834 *no_add_attrs
= true;
7838 struct cl_optimization cur_opts
;
7839 tree old_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
);
7841 /* Save current options. */
7842 cl_optimization_save (&cur_opts
);
7844 /* If we previously had some optimization options, use them as the
7847 cl_optimization_restore (TREE_OPTIMIZATION (old_opts
));
7849 /* Parse options, and update the vector. */
7850 parse_optimize_options (args
, true);
7851 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
)
7852 = build_optimization_node ();
7854 /* Restore current options. */
7855 cl_optimization_restore (&cur_opts
);
7861 /* Check for valid arguments being passed to a function.
7862 ATTRS is a list of attributes. There are NARGS arguments in the array
7863 ARGARRAY. TYPELIST is the list of argument types for the function.
7866 check_function_arguments (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7868 /* Check for null being passed in a pointer argument that must be
7869 non-null. We also need to do this if format checking is enabled. */
7872 check_function_nonnull (attrs
, nargs
, argarray
);
7874 /* Check for errors in format strings. */
7876 if (warn_format
|| warn_missing_format_attribute
)
7877 check_function_format (attrs
, nargs
, argarray
);
7880 check_function_sentinel (attrs
, nargs
, argarray
, typelist
);
7883 /* Generic argument checking recursion routine. PARAM is the argument to
7884 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7885 once the argument is resolved. CTX is context for the callback. */
7887 check_function_arguments_recurse (void (*callback
)
7888 (void *, tree
, unsigned HOST_WIDE_INT
),
7889 void *ctx
, tree param
,
7890 unsigned HOST_WIDE_INT param_num
)
7892 if (CONVERT_EXPR_P (param
)
7893 && (TYPE_PRECISION (TREE_TYPE (param
))
7894 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
7896 /* Strip coercion. */
7897 check_function_arguments_recurse (callback
, ctx
,
7898 TREE_OPERAND (param
, 0), param_num
);
7902 if (TREE_CODE (param
) == CALL_EXPR
)
7904 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
7906 bool found_format_arg
= false;
7908 /* See if this is a call to a known internationalization function
7909 that modifies a format arg. Such a function may have multiple
7910 format_arg attributes (for example, ngettext). */
7912 for (attrs
= TYPE_ATTRIBUTES (type
);
7914 attrs
= TREE_CHAIN (attrs
))
7915 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
7918 tree format_num_expr
;
7921 call_expr_arg_iterator iter
;
7923 /* Extract the argument number, which was previously checked
7925 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
7927 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
7928 && !TREE_INT_CST_HIGH (format_num_expr
));
7930 format_num
= TREE_INT_CST_LOW (format_num_expr
);
7932 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
7934 inner_arg
= next_call_expr_arg (&iter
), i
++)
7935 if (i
== format_num
)
7937 check_function_arguments_recurse (callback
, ctx
,
7938 inner_arg
, param_num
);
7939 found_format_arg
= true;
7944 /* If we found a format_arg attribute and did a recursive check,
7945 we are done with checking this argument. Otherwise, we continue
7946 and this will be considered a non-literal. */
7947 if (found_format_arg
)
7951 if (TREE_CODE (param
) == COND_EXPR
)
7953 /* Check both halves of the conditional expression. */
7954 check_function_arguments_recurse (callback
, ctx
,
7955 TREE_OPERAND (param
, 1), param_num
);
7956 check_function_arguments_recurse (callback
, ctx
,
7957 TREE_OPERAND (param
, 2), param_num
);
7961 (*callback
) (ctx
, param
, param_num
);
7964 /* Checks the number of arguments NARGS against the required number
7965 REQUIRED and issues an error if there is a mismatch. Returns true
7966 if the number of arguments is correct, otherwise false. */
7969 validate_nargs (tree fndecl
, int nargs
, int required
)
7971 if (nargs
< required
)
7973 error ("not enough arguments to function %qE", fndecl
);
7976 else if (nargs
> required
)
7978 error ("too many arguments to function %qE", fndecl
);
7984 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7985 Returns false if there was an error, otherwise true. */
7988 check_builtin_function_arguments (tree fndecl
, int nargs
, tree
*args
)
7990 if (!DECL_BUILT_IN (fndecl
)
7991 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
7994 switch (DECL_FUNCTION_CODE (fndecl
))
7996 case BUILT_IN_CONSTANT_P
:
7997 return validate_nargs (fndecl
, nargs
, 1);
7999 case BUILT_IN_ISFINITE
:
8000 case BUILT_IN_ISINF
:
8001 case BUILT_IN_ISINF_SIGN
:
8002 case BUILT_IN_ISNAN
:
8003 case BUILT_IN_ISNORMAL
:
8004 if (validate_nargs (fndecl
, nargs
, 1))
8006 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
8008 error ("non-floating-point argument in call to "
8009 "function %qE", fndecl
);
8016 case BUILT_IN_ISGREATER
:
8017 case BUILT_IN_ISGREATEREQUAL
:
8018 case BUILT_IN_ISLESS
:
8019 case BUILT_IN_ISLESSEQUAL
:
8020 case BUILT_IN_ISLESSGREATER
:
8021 case BUILT_IN_ISUNORDERED
:
8022 if (validate_nargs (fndecl
, nargs
, 2))
8024 enum tree_code code0
, code1
;
8025 code0
= TREE_CODE (TREE_TYPE (args
[0]));
8026 code1
= TREE_CODE (TREE_TYPE (args
[1]));
8027 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
8028 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
8029 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
8031 error ("non-floating-point arguments in call to "
8032 "function %qE", fndecl
);
8039 case BUILT_IN_FPCLASSIFY
:
8040 if (validate_nargs (fndecl
, nargs
, 6))
8045 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
8047 error ("non-const integer argument %u in call to function %qE",
8052 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
8054 error ("non-floating-point argument in call to function %qE",
8067 /* Function to help qsort sort FIELD_DECLs by name order. */
8070 field_decl_cmp (const void *x_p
, const void *y_p
)
8072 const tree
*const x
= (const tree
*const) x_p
;
8073 const tree
*const y
= (const tree
*const) y_p
;
8075 if (DECL_NAME (*x
) == DECL_NAME (*y
))
8076 /* A nontype is "greater" than a type. */
8077 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
8078 if (DECL_NAME (*x
) == NULL_TREE
)
8080 if (DECL_NAME (*y
) == NULL_TREE
)
8082 if (DECL_NAME (*x
) < DECL_NAME (*y
))
8088 gt_pointer_operator new_value
;
8092 /* This routine compares two fields like field_decl_cmp but using the
8093 pointer operator in resort_data. */
8096 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
8098 const tree
*const x
= (const tree
*const) x_p
;
8099 const tree
*const y
= (const tree
*const) y_p
;
8101 if (DECL_NAME (*x
) == DECL_NAME (*y
))
8102 /* A nontype is "greater" than a type. */
8103 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
8104 if (DECL_NAME (*x
) == NULL_TREE
)
8106 if (DECL_NAME (*y
) == NULL_TREE
)
8109 tree d1
= DECL_NAME (*x
);
8110 tree d2
= DECL_NAME (*y
);
8111 resort_data
.new_value (&d1
, resort_data
.cookie
);
8112 resort_data
.new_value (&d2
, resort_data
.cookie
);
8119 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8122 resort_sorted_fields (void *obj
,
8123 void * ARG_UNUSED (orig_obj
),
8124 gt_pointer_operator new_value
,
8127 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
8128 resort_data
.new_value
= new_value
;
8129 resort_data
.cookie
= cookie
;
8130 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
8131 resort_field_decl_cmp
);
8134 /* Subroutine of c_parse_error.
8135 Return the result of concatenating LHS and RHS. RHS is really
8136 a string literal, its first character is indicated by RHS_START and
8137 RHS_SIZE is its length (including the terminating NUL character).
8139 The caller is responsible for deleting the returned pointer. */
8142 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
8144 const int lhs_size
= strlen (lhs
);
8145 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
8146 strncpy (result
, lhs
, lhs_size
);
8147 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
8151 /* Issue the error given by GMSGID, indicating that it occurred before
8152 TOKEN, which had the associated VALUE. */
8155 c_parse_error (const char *gmsgid
, enum cpp_ttype token
, tree value
)
8157 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8159 char *message
= NULL
;
8161 if (token
== CPP_EOF
)
8162 message
= catenate_messages (gmsgid
, " at end of input");
8163 else if (token
== CPP_CHAR
|| token
== CPP_WCHAR
|| token
== CPP_CHAR16
8164 || token
== CPP_CHAR32
)
8166 unsigned int val
= TREE_INT_CST_LOW (value
);
8185 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
8186 message
= catenate_messages (gmsgid
, " before %s'%c'");
8188 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
8190 error (message
, prefix
, val
);
8194 else if (token
== CPP_STRING
|| token
== CPP_WSTRING
|| token
== CPP_STRING16
8195 || token
== CPP_STRING32
)
8196 message
= catenate_messages (gmsgid
, " before string constant");
8197 else if (token
== CPP_NUMBER
)
8198 message
= catenate_messages (gmsgid
, " before numeric constant");
8199 else if (token
== CPP_NAME
)
8201 message
= catenate_messages (gmsgid
, " before %qE");
8202 error (message
, value
);
8206 else if (token
== CPP_PRAGMA
)
8207 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
8208 else if (token
== CPP_PRAGMA_EOL
)
8209 message
= catenate_messages (gmsgid
, " before end of line");
8210 else if (token
< N_TTYPES
)
8212 message
= catenate_messages (gmsgid
, " before %qs token");
8213 error (message
, cpp_type2name (token
));
8225 #undef catenate_messages
8228 /* Callback from cpp_error for PFILE to print diagnostics from the
8229 preprocessor. The diagnostic is of type LEVEL, at location
8230 LOCATION unless this is after lexing and the compiler's location
8231 should be used instead, with column number possibly overridden by
8232 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8233 the arguments. Returns true if a diagnostic was emitted, false
8237 c_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
,
8238 location_t location
, unsigned int column_override
,
8239 const char *msg
, va_list *ap
)
8241 diagnostic_info diagnostic
;
8242 diagnostic_t dlevel
;
8243 int save_warn_system_headers
= warn_system_headers
;
8248 case CPP_DL_WARNING_SYSHDR
:
8251 warn_system_headers
= 1;
8253 case CPP_DL_WARNING
:
8256 dlevel
= DK_WARNING
;
8258 case CPP_DL_PEDWARN
:
8259 if (flag_no_output
&& !flag_pedantic_errors
)
8261 dlevel
= DK_PEDWARN
;
8279 location
= input_location
;
8280 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
8282 if (column_override
)
8283 diagnostic_override_column (&diagnostic
, column_override
);
8284 ret
= report_diagnostic (&diagnostic
);
8285 if (level
== CPP_DL_WARNING_SYSHDR
)
8286 warn_system_headers
= save_warn_system_headers
;
8290 /* Walk a gimplified function and warn for functions whose return value is
8291 ignored and attribute((warn_unused_result)) is set. This is done before
8292 inlining, so we don't have to worry about that. */
8295 c_warn_unused_result (gimple_seq seq
)
8298 gimple_stmt_iterator i
;
8300 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
8302 gimple g
= gsi_stmt (i
);
8304 switch (gimple_code (g
))
8307 c_warn_unused_result (gimple_bind_body (g
));
8310 c_warn_unused_result (gimple_try_eval (g
));
8311 c_warn_unused_result (gimple_try_cleanup (g
));
8314 c_warn_unused_result (gimple_catch_handler (g
));
8316 case GIMPLE_EH_FILTER
:
8317 c_warn_unused_result (gimple_eh_filter_failure (g
));
8321 if (gimple_call_lhs (g
))
8324 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8325 LHS. All calls whose value is ignored should be
8326 represented like this. Look for the attribute. */
8327 fdecl
= gimple_call_fndecl (g
);
8328 ftype
= TREE_TYPE (TREE_TYPE (gimple_call_fn (g
)));
8330 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
8332 location_t loc
= gimple_location (g
);
8335 warning (0, "%Hignoring return value of %qD, "
8336 "declared with attribute warn_unused_result",
8339 warning (0, "%Hignoring return value of function "
8340 "declared with attribute warn_unused_result",
8346 /* Not a container, not a call, or a call whose value is used. */
8352 /* Convert a character from the host to the target execution character
8353 set. cpplib handles this, mostly. */
8356 c_common_to_target_charset (HOST_WIDE_INT c
)
8358 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8359 zero-extended under -fno-signed-char. cpplib insists that characters
8360 and character constants are always unsigned. Hence we must convert
8362 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
8364 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
8366 if (flag_signed_char
)
8367 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
8368 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
8373 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8374 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8375 NULL, at the bottom; much like the traditional rendering of offsetof as a
8376 macro. Returns the folded and properly cast result. */
8379 fold_offsetof_1 (tree expr
, tree stop_ref
)
8381 enum tree_code code
= PLUS_EXPR
;
8384 if (expr
== stop_ref
&& TREE_CODE (expr
) != ERROR_MARK
)
8385 return size_zero_node
;
8387 switch (TREE_CODE (expr
))
8393 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
8394 return error_mark_node
;
8398 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8399 return error_mark_node
;
8402 gcc_assert (integer_zerop (expr
));
8403 return size_zero_node
;
8407 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8408 gcc_assert (base
== error_mark_node
|| base
== size_zero_node
);
8412 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8413 if (base
== error_mark_node
)
8416 t
= TREE_OPERAND (expr
, 1);
8417 if (DECL_C_BIT_FIELD (t
))
8419 error ("attempt to take address of bit-field structure "
8421 return error_mark_node
;
8423 off
= size_binop (PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
8424 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
), 1)
8429 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8430 if (base
== error_mark_node
)
8433 t
= TREE_OPERAND (expr
, 1);
8434 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) < 0)
8437 t
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (t
), t
);
8439 t
= convert (sizetype
, t
);
8440 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
8444 /* Handle static members of volatile structs. */
8445 t
= TREE_OPERAND (expr
, 1);
8446 gcc_assert (TREE_CODE (t
) == VAR_DECL
);
8447 return fold_offsetof_1 (t
, stop_ref
);
8453 return size_binop (code
, base
, off
);
8457 fold_offsetof (tree expr
, tree stop_ref
)
8459 /* Convert back from the internal sizetype to size_t. */
8460 return convert (size_type_node
, fold_offsetof_1 (expr
, stop_ref
));
8463 /* Print an error message for an invalid lvalue. USE says
8464 how the lvalue is being used and so selects the error message. */
8467 lvalue_error (enum lvalue_use use
)
8472 error ("lvalue required as left operand of assignment");
8475 error ("lvalue required as increment operand");
8478 error ("lvalue required as decrement operand");
8481 error ("lvalue required as unary %<&%> operand");
8484 error ("lvalue required in asm statement");
8491 /* *PTYPE is an incomplete array. Complete it with a domain based on
8492 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8493 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8494 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8497 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8499 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
8500 int failure
= 0, quals
;
8501 hashval_t hashcode
= 0;
8503 maxindex
= size_zero_node
;
8506 if (TREE_CODE (initial_value
) == STRING_CST
)
8509 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8510 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
8512 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8514 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
8516 if (VEC_empty (constructor_elt
, v
))
8520 maxindex
= integer_minus_one_node
;
8525 unsigned HOST_WIDE_INT cnt
;
8526 constructor_elt
*ce
;
8527 bool fold_p
= false;
8529 if (VEC_index (constructor_elt
, v
, 0)->index
)
8530 maxindex
= fold_convert (sizetype
,
8531 VEC_index (constructor_elt
,
8533 curindex
= maxindex
;
8536 VEC_iterate (constructor_elt
, v
, cnt
, ce
);
8539 bool curfold_p
= false;
8541 curindex
= ce
->index
, curfold_p
= true;
8545 curindex
= fold_convert (sizetype
, curindex
);
8546 curindex
= size_binop (PLUS_EXPR
, curindex
, size_one_node
);
8548 if (tree_int_cst_lt (maxindex
, curindex
))
8549 maxindex
= curindex
, fold_p
= curfold_p
;
8552 maxindex
= fold_convert (sizetype
, maxindex
);
8557 /* Make an error message unless that happened already. */
8558 if (initial_value
!= error_mark_node
)
8570 elt
= TREE_TYPE (type
);
8571 quals
= TYPE_QUALS (strip_array_types (elt
));
8575 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
8577 /* Using build_distinct_type_copy and modifying things afterward instead
8578 of using build_array_type to create a new type preserves all of the
8579 TYPE_LANG_FLAG_? bits that the front end may have set. */
8580 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
8581 TREE_TYPE (main_type
) = unqual_elt
;
8582 TYPE_DOMAIN (main_type
) = build_index_type (maxindex
);
8583 layout_type (main_type
);
8585 /* Make sure we have the canonical MAIN_TYPE. */
8586 hashcode
= iterative_hash_object (TYPE_HASH (unqual_elt
), hashcode
);
8587 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type
)),
8589 main_type
= type_hash_canon (hashcode
, main_type
);
8591 /* Fix the canonical type. */
8592 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
8593 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
8594 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
8595 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
8596 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
8597 != TYPE_DOMAIN (main_type
)))
8598 TYPE_CANONICAL (main_type
)
8599 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
8600 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)));
8602 TYPE_CANONICAL (main_type
) = main_type
;
8607 type
= c_build_qualified_type (main_type
, quals
);
8609 if (COMPLETE_TYPE_P (type
)
8610 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
8611 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
8613 error ("size of array is too large");
8614 /* If we proceed with the array type as it is, we'll eventually
8615 crash in tree_low_cst(). */
8616 type
= error_mark_node
;
8624 /* Used to help initialize the builtin-types.def table. When a type of
8625 the correct size doesn't exist, use error_mark_node instead of NULL.
8626 The later results in segfaults even when a decl using the type doesn't
8630 builtin_type_for_size (int size
, bool unsignedp
)
8632 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
8633 return type
? type
: error_mark_node
;
8636 /* A helper function for resolve_overloaded_builtin in resolving the
8637 overloaded __sync_ builtins. Returns a positive power of 2 if the
8638 first operand of PARAMS is a pointer to a supported data type.
8639 Returns 0 if an error is encountered. */
8642 sync_resolve_size (tree function
, tree params
)
8649 error ("too few arguments to function %qE", function
);
8653 type
= TREE_TYPE (TREE_VALUE (params
));
8654 if (TREE_CODE (type
) != POINTER_TYPE
)
8657 type
= TREE_TYPE (type
);
8658 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
8661 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
8662 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
8666 error ("incompatible type for argument %d of %qE", 1, function
);
8670 /* A helper function for resolve_overloaded_builtin. Adds casts to
8671 PARAMS to make arguments match up with those of FUNCTION. Drops
8672 the variadic arguments at the end. Returns false if some error
8673 was encountered; true on success. */
8676 sync_resolve_params (tree orig_function
, tree function
, tree params
)
8678 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
8682 /* We've declared the implementation functions to use "volatile void *"
8683 as the pointer parameter, so we shouldn't get any complaints from the
8684 call to check_function_arguments what ever type the user used. */
8685 arg_types
= TREE_CHAIN (arg_types
);
8686 ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
8689 /* For the rest of the values, we need to cast these to FTYPE, so that we
8690 don't get warnings for passing pointer types, etc. */
8691 while (arg_types
!= void_list_node
)
8695 params
= TREE_CHAIN (params
);
8698 error ("too few arguments to function %qE", orig_function
);
8702 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8703 so that we get warnings for anything that doesn't match the pointer
8704 type. This isn't portable across the C and C++ front ends atm. */
8705 val
= TREE_VALUE (params
);
8706 val
= convert (ptype
, val
);
8707 val
= convert (TREE_VALUE (arg_types
), val
);
8708 TREE_VALUE (params
) = val
;
8710 arg_types
= TREE_CHAIN (arg_types
);
8714 /* The definition of these primitives is variadic, with the remaining
8715 being "an optional list of variables protected by the memory barrier".
8716 No clue what that's supposed to mean, precisely, but we consider all
8717 call-clobbered variables to be protected so we're safe. */
8718 TREE_CHAIN (params
) = NULL
;
8723 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8724 RESULT to make it match the type of the first pointer argument in
8728 sync_resolve_return (tree params
, tree result
)
8730 tree ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
8731 ptype
= TYPE_MAIN_VARIANT (ptype
);
8732 return convert (ptype
, result
);
8735 /* Some builtin functions are placeholders for other expressions. This
8736 function should be called immediately after parsing the call expression
8737 before surrounding code has committed to the type of the expression.
8739 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8740 PARAMS is the argument list for the call. The return value is non-null
8741 when expansion is complete, and null if normal processing should
8745 resolve_overloaded_builtin (tree function
, tree params
)
8747 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
8748 switch (DECL_BUILT_IN_CLASS (function
))
8750 case BUILT_IN_NORMAL
:
8753 if (targetm
.resolve_overloaded_builtin
)
8754 return targetm
.resolve_overloaded_builtin (function
, params
);
8761 /* Handle BUILT_IN_NORMAL here. */
8764 case BUILT_IN_FETCH_AND_ADD_N
:
8765 case BUILT_IN_FETCH_AND_SUB_N
:
8766 case BUILT_IN_FETCH_AND_OR_N
:
8767 case BUILT_IN_FETCH_AND_AND_N
:
8768 case BUILT_IN_FETCH_AND_XOR_N
:
8769 case BUILT_IN_FETCH_AND_NAND_N
:
8770 case BUILT_IN_ADD_AND_FETCH_N
:
8771 case BUILT_IN_SUB_AND_FETCH_N
:
8772 case BUILT_IN_OR_AND_FETCH_N
:
8773 case BUILT_IN_AND_AND_FETCH_N
:
8774 case BUILT_IN_XOR_AND_FETCH_N
:
8775 case BUILT_IN_NAND_AND_FETCH_N
:
8776 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N
:
8777 case BUILT_IN_VAL_COMPARE_AND_SWAP_N
:
8778 case BUILT_IN_LOCK_TEST_AND_SET_N
:
8779 case BUILT_IN_LOCK_RELEASE_N
:
8781 int n
= sync_resolve_size (function
, params
);
8782 tree new_function
, result
;
8785 return error_mark_node
;
8787 new_function
= built_in_decls
[orig_code
+ exact_log2 (n
) + 1];
8788 if (!sync_resolve_params (function
, new_function
, params
))
8789 return error_mark_node
;
8791 result
= build_function_call (new_function
, params
);
8792 if (orig_code
!= BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8793 && orig_code
!= BUILT_IN_LOCK_RELEASE_N
)
8794 result
= sync_resolve_return (params
, result
);
8804 /* Ignoring their sign, return true if two scalar types are the same. */
8806 same_scalar_type_ignoring_signedness (tree t1
, tree t2
)
8808 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
8810 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
|| c1
== FIXED_POINT_TYPE
)
8811 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
8812 || c2
== FIXED_POINT_TYPE
));
8814 /* Equality works here because c_common_signed_type uses
8815 TYPE_MAIN_VARIANT. */
8816 return c_common_signed_type (t1
)
8817 == c_common_signed_type (t2
);
8820 /* Check for missing format attributes on function pointers. LTYPE is
8821 the new type or left-hand side type. RTYPE is the old type or
8822 right-hand side type. Returns TRUE if LTYPE is missing the desired
8826 check_missing_format_attribute (tree ltype
, tree rtype
)
8828 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
8831 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
8832 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
8837 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
8838 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
8846 /* Subscripting with type char is likely to lose on a machine where
8847 chars are signed. So warn on any machine, but optionally. Don't
8848 warn for unsigned char since that type is safe. Don't warn for
8849 signed char because anyone who uses that must have done so
8850 deliberately. Furthermore, we reduce the false positive load by
8851 warning only for non-constant value of type char. */
8854 warn_array_subscript_with_type_char (tree index
)
8856 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
8857 && TREE_CODE (index
) != INTEGER_CST
)
8858 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
8861 /* Implement -Wparentheses for the unexpected C precedence rules, to
8862 cover cases like x + y << z which readers are likely to
8863 misinterpret. We have seen an expression in which CODE is a binary
8864 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8865 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8866 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8867 expression was not formed using a binary or unary operator, or it
8868 was enclosed in parentheses. */
8871 warn_about_parentheses (enum tree_code code
,
8872 enum tree_code code_left
, tree arg_left
,
8873 enum tree_code code_right
, tree arg_right
)
8875 if (!warn_parentheses
)
8878 /* This macro tests that the expression ARG with original tree code
8879 CODE appears to be a boolean expression. or the result of folding a
8880 boolean expression. */
8881 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8882 (truth_value_p (TREE_CODE (ARG)) \
8883 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8884 /* Folding may create 0 or 1 integers from other expressions. */ \
8885 || ((CODE) != INTEGER_CST \
8886 && (integer_onep (ARG) || integer_zerop (ARG))))
8891 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8892 warning (OPT_Wparentheses
,
8893 "suggest parentheses around %<+%> inside %<<<%>");
8894 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8895 warning (OPT_Wparentheses
,
8896 "suggest parentheses around %<-%> inside %<<<%>");
8900 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8901 warning (OPT_Wparentheses
,
8902 "suggest parentheses around %<+%> inside %<>>%>");
8903 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8904 warning (OPT_Wparentheses
,
8905 "suggest parentheses around %<-%> inside %<>>%>");
8908 case TRUTH_ORIF_EXPR
:
8909 if (code_left
== TRUTH_ANDIF_EXPR
|| code_right
== TRUTH_ANDIF_EXPR
)
8910 warning (OPT_Wparentheses
,
8911 "suggest parentheses around %<&&%> within %<||%>");
8915 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
8916 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8917 || code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
8918 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8919 warning (OPT_Wparentheses
,
8920 "suggest parentheses around arithmetic in operand of %<|%>");
8921 /* Check cases like x|y==z */
8922 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8923 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8924 warning (OPT_Wparentheses
,
8925 "suggest parentheses around comparison in operand of %<|%>");
8926 /* Check cases like !x | y */
8927 else if (code_left
== TRUTH_NOT_EXPR
8928 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
8929 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
8930 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8934 if (code_left
== BIT_AND_EXPR
8935 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8936 || code_right
== BIT_AND_EXPR
8937 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8938 warning (OPT_Wparentheses
,
8939 "suggest parentheses around arithmetic in operand of %<^%>");
8940 /* Check cases like x^y==z */
8941 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8942 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8943 warning (OPT_Wparentheses
,
8944 "suggest parentheses around comparison in operand of %<^%>");
8948 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8949 warning (OPT_Wparentheses
,
8950 "suggest parentheses around %<+%> in operand of %<&%>");
8951 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8952 warning (OPT_Wparentheses
,
8953 "suggest parentheses around %<-%> in operand of %<&%>");
8954 /* Check cases like x&y==z */
8955 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8956 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8957 warning (OPT_Wparentheses
,
8958 "suggest parentheses around comparison in operand of %<&%>");
8959 /* Check cases like !x & y */
8960 else if (code_left
== TRUTH_NOT_EXPR
8961 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
8962 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
8963 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8967 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8968 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8969 warning (OPT_Wparentheses
,
8970 "suggest parentheses around comparison in operand of %<==%>");
8973 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8974 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8975 warning (OPT_Wparentheses
,
8976 "suggest parentheses around comparison in operand of %<!=%>");
8980 if (TREE_CODE_CLASS (code
) == tcc_comparison
8981 && ((TREE_CODE_CLASS (code_left
) == tcc_comparison
8982 && code_left
!= NE_EXPR
&& code_left
!= EQ_EXPR
8983 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left
)))
8984 || (TREE_CODE_CLASS (code_right
) == tcc_comparison
8985 && code_right
!= NE_EXPR
&& code_right
!= EQ_EXPR
8986 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right
)))))
8987 warning (OPT_Wparentheses
, "comparisons like %<X<=Y<=Z%> do not "
8988 "have their mathematical meaning");
8991 #undef NOT_A_BOOLEAN_EXPR_P
8994 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8997 warn_for_unused_label (tree label
)
8999 if (!TREE_USED (label
))
9001 if (DECL_INITIAL (label
))
9002 warning (OPT_Wunused_label
, "label %q+D defined but not used", label
);
9004 warning (OPT_Wunused_label
, "label %q+D declared but not defined", label
);
9008 #ifndef TARGET_HAS_TARGETCM
9009 struct gcc_targetcm targetcm
= TARGETCM_INITIALIZER
;
9012 /* Warn for division by zero according to the value of DIVISOR. LOC
9013 is the location of the division operator. */
9016 warn_for_div_by_zero (location_t loc
, tree divisor
)
9018 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9019 about division by zero. Do not issue a warning if DIVISOR has a
9020 floating-point type, since we consider 0.0/0.0 a valid way of
9021 generating a NaN. */
9022 if (skip_evaluation
== 0
9023 && (integer_zerop (divisor
) || fixed_zerop (divisor
)))
9024 warning_at (loc
, OPT_Wdiv_by_zero
, "division by zero");
9027 /* Subroutine of build_binary_op. Give warnings for comparisons
9028 between signed and unsigned quantities that may fail. Do the
9029 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9030 so that casts will be considered, but default promotions won't
9033 LOCATION is the location of the comparison operator.
9035 The arguments of this function map directly to local variables
9036 of build_binary_op. */
9039 warn_for_sign_compare (location_t location
,
9040 tree orig_op0
, tree orig_op1
,
9042 tree result_type
, enum tree_code resultcode
)
9044 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
9045 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
9046 int unsignedp0
, unsignedp1
;
9048 /* In C++, check for comparison of different enum types. */
9050 && TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
9051 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
9052 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
9053 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
9055 warning_at (location
,
9056 OPT_Wsign_compare
, "comparison between types %qT and %qT",
9057 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
9060 /* Do not warn if the comparison is being done in a signed type,
9061 since the signed type will only be chosen if it can represent
9062 all the values of the unsigned type. */
9063 if (!TYPE_UNSIGNED (result_type
))
9065 /* Do not warn if both operands are unsigned. */
9066 else if (op0_signed
== op1_signed
)
9070 tree sop
, uop
, base_type
;
9074 sop
= orig_op0
, uop
= orig_op1
;
9076 sop
= orig_op1
, uop
= orig_op0
;
9078 STRIP_TYPE_NOPS (sop
);
9079 STRIP_TYPE_NOPS (uop
);
9080 base_type
= (TREE_CODE (result_type
) == COMPLEX_TYPE
9081 ? TREE_TYPE (result_type
) : result_type
);
9083 /* Do not warn if the signed quantity is an unsuffixed integer
9084 literal (or some static constant expression involving such
9085 literals or a conditional expression involving such literals)
9086 and it is non-negative. */
9087 if (tree_expr_nonnegative_warnv_p (sop
, &ovf
))
9089 /* Do not warn if the comparison is an equality operation, the
9090 unsigned quantity is an integral constant, and it would fit
9091 in the result if the result were signed. */
9092 else if (TREE_CODE (uop
) == INTEGER_CST
9093 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
9094 && int_fits_type_p (uop
, c_common_signed_type (base_type
)))
9096 /* In C, do not warn if the unsigned quantity is an enumeration
9097 constant and its maximum value would fit in the result if the
9098 result were signed. */
9099 else if (!c_dialect_cxx() && TREE_CODE (uop
) == INTEGER_CST
9100 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
9101 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
9102 c_common_signed_type (base_type
)))
9105 warning_at (location
,
9107 "comparison between signed and unsigned integer expressions");
9110 /* Warn if two unsigned values are being compared in a size larger
9111 than their original size, and one (and only one) is the result of
9112 a `~' operator. This comparison will always fail.
9114 Also warn if one operand is a constant, and the constant does not
9115 have all bits set that are set in the ~ operand when it is
9118 op0
= get_narrower (op0
, &unsignedp0
);
9119 op1
= get_narrower (op1
, &unsignedp1
);
9121 if ((TREE_CODE (op0
) == BIT_NOT_EXPR
)
9122 ^ (TREE_CODE (op1
) == BIT_NOT_EXPR
))
9124 if (TREE_CODE (op0
) == BIT_NOT_EXPR
)
9125 op0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
9126 if (TREE_CODE (op1
) == BIT_NOT_EXPR
)
9127 op1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
9129 if (host_integerp (op0
, 0) || host_integerp (op1
, 0))
9132 HOST_WIDE_INT constant
, mask
;
9136 if (host_integerp (op0
, 0))
9139 unsignedp
= unsignedp1
;
9140 constant
= tree_low_cst (op0
, 0);
9145 unsignedp
= unsignedp0
;
9146 constant
= tree_low_cst (op1
, 0);
9149 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
9150 if (bits
< TYPE_PRECISION (result_type
)
9151 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
9153 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
9154 if ((mask
& constant
) != mask
)
9157 warning (OPT_Wsign_compare
,
9158 "promoted ~unsigned is always non-zero");
9160 warning_at (location
, OPT_Wsign_compare
,
9161 "comparison of promoted ~unsigned with constant");
9165 else if (unsignedp0
&& unsignedp1
9166 && (TYPE_PRECISION (TREE_TYPE (op0
))
9167 < TYPE_PRECISION (result_type
))
9168 && (TYPE_PRECISION (TREE_TYPE (op1
))
9169 < TYPE_PRECISION (result_type
)))
9170 warning_at (location
, OPT_Wsign_compare
,
9171 "comparison of promoted ~unsigned with unsigned");
9175 #include "gt-c-common.h"