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"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.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"
73 #define CHAR16_TYPE "short unsigned int"
77 #define CHAR32_TYPE "unsigned int"
81 #define WCHAR_TYPE "int"
84 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
85 #define MODIFIED_WCHAR_TYPE \
86 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
89 #define PTRDIFF_TYPE "long int"
93 #define WINT_TYPE "unsigned int"
97 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
99 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
105 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
107 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
108 ? "long unsigned int" \
109 : "long long unsigned int"))
112 /* The following symbols are subsumed in the c_global_trees array, and
113 listed here individually for documentation purposes.
115 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
117 tree short_integer_type_node;
118 tree long_integer_type_node;
119 tree long_long_integer_type_node;
121 tree short_unsigned_type_node;
122 tree long_unsigned_type_node;
123 tree long_long_unsigned_type_node;
125 tree truthvalue_type_node;
126 tree truthvalue_false_node;
127 tree truthvalue_true_node;
129 tree ptrdiff_type_node;
131 tree unsigned_char_type_node;
132 tree signed_char_type_node;
133 tree wchar_type_node;
134 tree signed_wchar_type_node;
135 tree unsigned_wchar_type_node;
137 tree char16_type_node;
138 tree char32_type_node;
140 tree float_type_node;
141 tree double_type_node;
142 tree long_double_type_node;
144 tree complex_integer_type_node;
145 tree complex_float_type_node;
146 tree complex_double_type_node;
147 tree complex_long_double_type_node;
149 tree dfloat32_type_node;
150 tree dfloat64_type_node;
151 tree_dfloat128_type_node;
153 tree intQI_type_node;
154 tree intHI_type_node;
155 tree intSI_type_node;
156 tree intDI_type_node;
157 tree intTI_type_node;
159 tree unsigned_intQI_type_node;
160 tree unsigned_intHI_type_node;
161 tree unsigned_intSI_type_node;
162 tree unsigned_intDI_type_node;
163 tree unsigned_intTI_type_node;
165 tree widest_integer_literal_type_node;
166 tree widest_unsigned_literal_type_node;
168 Nodes for types `void *' and `const void *'.
170 tree ptr_type_node, const_ptr_type_node;
172 Nodes for types `char *' and `const char *'.
174 tree string_type_node, const_string_type_node;
176 Type `char[SOMENUMBER]'.
177 Used when an array of char is needed and the size is irrelevant.
179 tree char_array_type_node;
181 Type `int[SOMENUMBER]' or something like it.
182 Used when an array of int needed and the size is irrelevant.
184 tree int_array_type_node;
186 Type `wchar_t[SOMENUMBER]' or something like it.
187 Used when a wide string literal is created.
189 tree wchar_array_type_node;
191 Type `char16_t[SOMENUMBER]' or something like it.
192 Used when a UTF-16 string literal is created.
194 tree char16_array_type_node;
196 Type `char32_t[SOMENUMBER]' or something like it.
197 Used when a UTF-32 string literal is created.
199 tree char32_array_type_node;
201 Type `int ()' -- used for implicit declaration of functions.
203 tree default_function_type;
205 A VOID_TYPE node, packaged in a TREE_LIST.
209 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
210 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
211 VAR_DECLS, but C++ does.)
213 tree function_name_decl_node;
214 tree pretty_function_name_decl_node;
215 tree c99_function_name_decl_node;
217 Stack of nested function name VAR_DECLs.
219 tree saved_function_name_decls;
223 tree c_global_trees[CTI_MAX];
225 /* Switches common to the C front ends. */
227 /* Nonzero if preprocessing only. */
229 int flag_preprocess_only;
231 /* Nonzero means don't output line number information. */
233 char flag_no_line_commands;
235 /* Nonzero causes -E output not to be done, but directives such as
236 #define that have side effects are still obeyed. */
240 /* Nonzero means dump macros in some fashion. */
242 char flag_dump_macros;
244 /* Nonzero means pass #include lines through to the output. */
246 char flag_dump_includes;
248 /* Nonzero means process PCH files while preprocessing. */
250 bool flag_pch_preprocess;
252 /* The file name to which we should write a precompiled header, or
253 NULL if no header will be written in this compile. */
255 const char *pch_file;
257 /* Nonzero if an ISO standard was selected. It rejects macros in the
261 /* Nonzero if -undef was given. It suppresses target built-in macros
265 /* Nonzero means don't recognize the non-ANSI builtin functions. */
269 /* Nonzero means don't recognize the non-ANSI builtin functions.
272 int flag_no_nonansi_builtin;
274 /* Nonzero means give `double' the same size as `float'. */
276 int flag_short_double;
278 /* Nonzero means give `wchar_t' the same size as `short'. */
280 int flag_short_wchar;
282 /* Nonzero means allow implicit conversions between vectors with
283 differing numbers of subparts and/or differing element types. */
284 int flag_lax_vector_conversions;
286 /* Nonzero means allow Microsoft extensions without warnings or errors. */
287 int flag_ms_extensions;
289 /* Nonzero means don't recognize the keyword `asm'. */
293 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
295 int flag_signed_bitfields = 1;
297 /* Warn about #pragma directives that are not recognized. */
299 int warn_unknown_pragmas; /* Tri state variable. */
301 /* Warn about format/argument anomalies in calls to formatted I/O functions
302 (*printf, *scanf, strftime, strfmon, etc.). */
306 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
307 with GCC this doesn't matter as __null is guaranteed to have the right
310 int warn_strict_null_sentinel;
312 /* Zero means that faster, ...NonNil variants of objc_msgSend...
313 calls will be used in ObjC; passing nil receivers to such calls
314 will most likely result in crashes. */
315 int flag_nil_receivers = 1;
317 /* Nonzero means that code generation will be altered to support
318 "zero-link" execution. This currently affects ObjC only, but may
319 affect other languages in the future. */
320 int flag_zero_link = 0;
322 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
323 unit. It will inform the ObjC runtime that class definition(s) herein
324 contained are to replace one(s) previously loaded. */
325 int flag_replace_objc_classes = 0;
327 /* C/ObjC language option variables. */
330 /* Nonzero means allow type mismatches in conditional expressions;
331 just make their values `void'. */
333 int flag_cond_mismatch;
335 /* Nonzero means enable C89 Amendment 1 features. */
339 /* Nonzero means use the ISO C99 dialect of C. */
343 /* Nonzero means that we have builtin functions, and main is an int. */
348 /* ObjC language option variables. */
351 /* Open and close the file for outputting class declarations, if
354 int flag_gen_declaration;
356 /* Tells the compiler that this is a special run. Do not perform any
357 compiling, instead we are to test some platform dependent features
358 and output a C header file with appropriate definitions. */
360 int print_struct_values;
362 /* Tells the compiler what is the constant string class for ObjC. */
364 const char *constant_string_class_name;
367 /* C++ language option variables. */
370 /* Nonzero means don't recognize any extension keywords. */
372 int flag_no_gnu_keywords;
374 /* Nonzero means do emit exported implementations of functions even if
375 they can be inlined. */
377 int flag_implement_inlines = 1;
379 /* Nonzero means that implicit instantiations will be emitted if needed. */
381 int flag_implicit_templates = 1;
383 /* Nonzero means that implicit instantiations of inline templates will be
384 emitted if needed, even if instantiations of non-inline templates
387 int flag_implicit_inline_templates = 1;
389 /* Nonzero means generate separate instantiation control files and
390 juggle them at link time. */
392 int flag_use_repository;
394 /* Nonzero if we want to issue diagnostics that the standard says are not
397 int flag_optional_diags = 1;
399 /* Nonzero means we should attempt to elide constructors when possible. */
401 int flag_elide_constructors = 1;
403 /* Nonzero means that member functions defined in class scope are
404 inline by default. */
406 int flag_default_inline = 1;
408 /* Controls whether compiler generates 'type descriptor' that give
409 run-time type information. */
413 /* Nonzero if we want to conserve space in the .o files. We do this
414 by putting uninitialized data and runtime initialized data into
415 .common instead of .data at the expense of not flagging multiple
418 int flag_conserve_space;
420 /* Nonzero if we want to obey access control semantics. */
422 int flag_access_control = 1;
424 /* Nonzero if we want to check the return value of new and avoid calling
425 constructors if it is a null pointer. */
429 /* The C++ dialect being used. C++98 is the default. */
431 enum cxx_dialect cxx_dialect = cxx98;
433 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
434 initialization variables.
435 0: Old rules, set by -fno-for-scope.
436 2: New ISO rules, set by -ffor-scope.
437 1: Try to implement new ISO rules, but with backup compatibility
438 (and warnings). This is the default, for now. */
440 int flag_new_for_scope = 1;
442 /* Nonzero if we want to emit defined symbols with common-like linkage as
443 weak symbols where possible, in order to conform to C++ semantics.
444 Otherwise, emit them as local symbols. */
448 /* 0 means we want the preprocessor to not emit line directives for
449 the current working directory. 1 means we want it to do it. -1
450 means we should decide depending on whether debugging information
451 is being emitted or not. */
453 int flag_working_directory = -1;
455 /* Nonzero to use __cxa_atexit, rather than atexit, to register
456 destructors for local statics and global objects. '2' means it has been
457 set nonzero as a default, not by a command-line flag. */
459 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
461 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
462 code. '2' means it has not been set explicitly on the command line. */
464 int flag_use_cxa_get_exception_ptr = 2;
466 /* Nonzero means to implement standard semantics for exception
467 specifications, calling unexpected if an exception is thrown that
468 doesn't match the specification. Zero means to treat them as
469 assertions and optimize accordingly, but not check them. */
471 int flag_enforce_eh_specs = 1;
473 /* Nonzero means to generate thread-safe code for initializing local
476 int flag_threadsafe_statics = 1;
478 /* Nonzero means warn about implicit declarations. */
480 int warn_implicit = 1;
482 /* Maximum template instantiation depth. This limit is rather
483 arbitrary, but it exists to limit the time it takes to notice
484 infinite template instantiations. */
486 int max_tinst_depth = 500;
490 /* The elements of `ridpointers' are identifier nodes for the reserved
491 type names and storage classes. It is indexed by a RID_... value. */
494 tree (*make_fname_decl) (tree, int);
496 /* Nonzero means the expression being parsed will never be evaluated.
497 This is a count, since unevaluated expressions can nest. */
500 /* Information about how a function name is generated. */
503 tree *const decl; /* pointer to the VAR_DECL. */
504 const unsigned rid; /* RID number for the identifier. */
505 const int pretty; /* How pretty is it? */
508 /* The three ways of getting then name of the current function. */
510 const struct fname_var_t fname_vars[] =
512 /* C99 compliant __func__, must be first. */
513 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
514 /* GCC __FUNCTION__ compliant. */
515 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
516 /* GCC __PRETTY_FUNCTION__ compliant. */
517 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
521 static tree check_case_value (tree);
522 static bool check_case_bounds (tree, tree, tree *, tree *);
524 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
525 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
528 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_always_inline_attribute (tree *, tree, tree, int,
533 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
534 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
535 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
536 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
537 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
538 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
539 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
541 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_transparent_union_attribute (tree *, tree, tree,
544 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
545 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
546 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
547 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
548 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
549 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
550 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
551 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
552 static tree handle_visibility_attribute (tree *, tree, tree, int,
554 static tree handle_tls_model_attribute (tree *, tree, tree, int,
556 static tree handle_no_instrument_function_attribute (tree *, tree,
558 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
559 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
560 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
562 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
563 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
564 static tree handle_deprecated_attribute (tree *, tree, tree, int,
566 static tree handle_vector_size_attribute (tree *, tree, tree, int,
568 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
569 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
570 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
571 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
573 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
574 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
575 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
576 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
577 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
579 static void check_function_nonnull (tree, int, tree *);
580 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
581 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
582 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
583 static int resort_field_decl_cmp (const void *, const void *);
585 /* Reserved words. The third field is a mask: keywords are disabled
586 if they match the mask.
589 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
590 C --std=c99: D_CXXONLY | D_OBJC
591 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
592 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
593 C++ --std=c0x: D_CONLY | D_OBJC
594 ObjC++ is like C++ except that D_OBJC is not set
596 If -fno-asm is used, D_ASM is added to the mask. If
597 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
598 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
599 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
601 const struct c_common_resword c_common_reswords[] =
603 { "_Bool", RID_BOOL, D_CONLY },
604 { "_Complex", RID_COMPLEX, 0 },
605 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
606 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
607 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
608 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
609 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
610 { "_Sat", RID_SAT, D_CONLY | D_EXT },
611 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
612 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
613 { "__alignof", RID_ALIGNOF, 0 },
614 { "__alignof__", RID_ALIGNOF, 0 },
615 { "__asm", RID_ASM, 0 },
616 { "__asm__", RID_ASM, 0 },
617 { "__attribute", RID_ATTRIBUTE, 0 },
618 { "__attribute__", RID_ATTRIBUTE, 0 },
619 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
620 { "__builtin_offsetof", RID_OFFSETOF, 0 },
621 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
622 { "__builtin_va_arg", RID_VA_ARG, 0 },
623 { "__complex", RID_COMPLEX, 0 },
624 { "__complex__", RID_COMPLEX, 0 },
625 { "__const", RID_CONST, 0 },
626 { "__const__", RID_CONST, 0 },
627 { "__decltype", RID_DECLTYPE, D_CXXONLY },
628 { "__extension__", RID_EXTENSION, 0 },
629 { "__func__", RID_C99_FUNCTION_NAME, 0 },
630 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
631 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
632 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
633 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
634 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
635 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
636 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
637 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
638 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
639 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
640 { "__is_class", RID_IS_CLASS, D_CXXONLY },
641 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
642 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
643 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
644 { "__is_pod", RID_IS_POD, D_CXXONLY },
645 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
646 { "__is_union", RID_IS_UNION, D_CXXONLY },
647 { "__imag", RID_IMAGPART, 0 },
648 { "__imag__", RID_IMAGPART, 0 },
649 { "__inline", RID_INLINE, 0 },
650 { "__inline__", RID_INLINE, 0 },
651 { "__label__", RID_LABEL, 0 },
652 { "__null", RID_NULL, 0 },
653 { "__real", RID_REALPART, 0 },
654 { "__real__", RID_REALPART, 0 },
655 { "__restrict", RID_RESTRICT, 0 },
656 { "__restrict__", RID_RESTRICT, 0 },
657 { "__signed", RID_SIGNED, 0 },
658 { "__signed__", RID_SIGNED, 0 },
659 { "__thread", RID_THREAD, 0 },
660 { "__typeof", RID_TYPEOF, 0 },
661 { "__typeof__", RID_TYPEOF, 0 },
662 { "__volatile", RID_VOLATILE, 0 },
663 { "__volatile__", RID_VOLATILE, 0 },
664 { "asm", RID_ASM, D_ASM },
665 { "auto", RID_AUTO, 0 },
666 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
667 { "break", RID_BREAK, 0 },
668 { "case", RID_CASE, 0 },
669 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
670 { "char", RID_CHAR, 0 },
671 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
672 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
673 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
674 { "const", RID_CONST, 0 },
675 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
676 { "continue", RID_CONTINUE, 0 },
677 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
678 { "default", RID_DEFAULT, 0 },
679 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
681 { "double", RID_DOUBLE, 0 },
682 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
683 { "else", RID_ELSE, 0 },
684 { "enum", RID_ENUM, 0 },
685 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
686 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
687 { "extern", RID_EXTERN, 0 },
688 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
689 { "float", RID_FLOAT, 0 },
690 { "for", RID_FOR, 0 },
691 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
692 { "goto", RID_GOTO, 0 },
694 { "inline", RID_INLINE, D_EXT89 },
695 { "int", RID_INT, 0 },
696 { "long", RID_LONG, 0 },
697 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
698 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
699 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
700 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
701 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
702 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
703 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
704 { "register", RID_REGISTER, 0 },
705 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
706 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
707 { "return", RID_RETURN, 0 },
708 { "short", RID_SHORT, 0 },
709 { "signed", RID_SIGNED, 0 },
710 { "sizeof", RID_SIZEOF, 0 },
711 { "static", RID_STATIC, 0 },
712 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
713 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
714 { "struct", RID_STRUCT, 0 },
715 { "switch", RID_SWITCH, 0 },
716 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
717 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
718 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
719 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
720 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
721 { "typedef", RID_TYPEDEF, 0 },
722 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
723 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
724 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
725 { "union", RID_UNION, 0 },
726 { "unsigned", RID_UNSIGNED, 0 },
727 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
728 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
729 { "void", RID_VOID, 0 },
730 { "volatile", RID_VOLATILE, 0 },
731 { "wchar_t", RID_WCHAR, D_CXXONLY },
732 { "while", RID_WHILE, 0 },
733 /* These Objective-C keywords are recognized only immediately after
735 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
736 { "defs", RID_AT_DEFS, D_OBJC },
737 { "encode", RID_AT_ENCODE, D_OBJC },
738 { "end", RID_AT_END, D_OBJC },
739 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
740 { "interface", RID_AT_INTERFACE, D_OBJC },
741 { "protocol", RID_AT_PROTOCOL, D_OBJC },
742 { "selector", RID_AT_SELECTOR, D_OBJC },
743 { "finally", RID_AT_FINALLY, D_OBJC },
744 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
745 /* These are recognized only in protocol-qualifier context
747 { "bycopy", RID_BYCOPY, D_OBJC },
748 { "byref", RID_BYREF, D_OBJC },
749 { "in", RID_IN, D_OBJC },
750 { "inout", RID_INOUT, D_OBJC },
751 { "oneway", RID_ONEWAY, D_OBJC },
752 { "out", RID_OUT, D_OBJC },
755 const unsigned int num_c_common_reswords =
756 sizeof c_common_reswords / sizeof (struct c_common_resword);
758 /* Table of machine-independent attributes common to all C-like languages. */
759 const struct attribute_spec c_common_attribute_table[] =
761 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
762 { "packed", 0, 0, false, false, false,
763 handle_packed_attribute },
764 { "nocommon", 0, 0, true, false, false,
765 handle_nocommon_attribute },
766 { "common", 0, 0, true, false, false,
767 handle_common_attribute },
768 /* FIXME: logically, noreturn attributes should be listed as
769 "false, true, true" and apply to function types. But implementing this
770 would require all the places in the compiler that use TREE_THIS_VOLATILE
771 on a decl to identify non-returning functions to be located and fixed
772 to check the function type instead. */
773 { "noreturn", 0, 0, true, false, false,
774 handle_noreturn_attribute },
775 { "volatile", 0, 0, true, false, false,
776 handle_noreturn_attribute },
777 { "noinline", 0, 0, true, false, false,
778 handle_noinline_attribute },
779 { "always_inline", 0, 0, true, false, false,
780 handle_always_inline_attribute },
781 { "gnu_inline", 0, 0, true, false, false,
782 handle_gnu_inline_attribute },
783 { "artificial", 0, 0, true, false, false,
784 handle_artificial_attribute },
785 { "flatten", 0, 0, true, false, false,
786 handle_flatten_attribute },
787 { "used", 0, 0, true, false, false,
788 handle_used_attribute },
789 { "unused", 0, 0, false, false, false,
790 handle_unused_attribute },
791 { "externally_visible", 0, 0, true, false, false,
792 handle_externally_visible_attribute },
793 /* The same comments as for noreturn attributes apply to const ones. */
794 { "const", 0, 0, true, false, false,
795 handle_const_attribute },
796 { "transparent_union", 0, 0, false, false, false,
797 handle_transparent_union_attribute },
798 { "constructor", 0, 1, true, false, false,
799 handle_constructor_attribute },
800 { "destructor", 0, 1, true, false, false,
801 handle_destructor_attribute },
802 { "mode", 1, 1, false, true, false,
803 handle_mode_attribute },
804 { "section", 1, 1, true, false, false,
805 handle_section_attribute },
806 { "aligned", 0, 1, false, false, false,
807 handle_aligned_attribute },
808 { "weak", 0, 0, true, false, false,
809 handle_weak_attribute },
810 { "alias", 1, 1, true, false, false,
811 handle_alias_attribute },
812 { "weakref", 0, 1, true, false, false,
813 handle_weakref_attribute },
814 { "no_instrument_function", 0, 0, true, false, false,
815 handle_no_instrument_function_attribute },
816 { "malloc", 0, 0, true, false, false,
817 handle_malloc_attribute },
818 { "returns_twice", 0, 0, true, false, false,
819 handle_returns_twice_attribute },
820 { "no_stack_limit", 0, 0, true, false, false,
821 handle_no_limit_stack_attribute },
822 { "pure", 0, 0, true, false, false,
823 handle_pure_attribute },
824 /* For internal use (marking of builtins) only. The name contains space
825 to prevent its usage in source code. */
826 { "no vops", 0, 0, true, false, false,
827 handle_novops_attribute },
828 { "deprecated", 0, 0, false, false, false,
829 handle_deprecated_attribute },
830 { "vector_size", 1, 1, false, true, false,
831 handle_vector_size_attribute },
832 { "visibility", 1, 1, false, false, false,
833 handle_visibility_attribute },
834 { "tls_model", 1, 1, true, false, false,
835 handle_tls_model_attribute },
836 { "nonnull", 0, -1, false, true, true,
837 handle_nonnull_attribute },
838 { "nothrow", 0, 0, true, false, false,
839 handle_nothrow_attribute },
840 { "may_alias", 0, 0, false, true, false, NULL },
841 { "cleanup", 1, 1, true, false, false,
842 handle_cleanup_attribute },
843 { "warn_unused_result", 0, 0, false, true, true,
844 handle_warn_unused_result_attribute },
845 { "sentinel", 0, 1, false, true, true,
846 handle_sentinel_attribute },
847 /* For internal use (marking of builtins) only. The name contains space
848 to prevent its usage in source code. */
849 { "type generic", 0, 0, false, true, true,
850 handle_type_generic_attribute },
851 { "alloc_size", 1, 2, false, true, true,
852 handle_alloc_size_attribute },
853 { "cold", 0, 0, true, false, false,
854 handle_cold_attribute },
855 { "hot", 0, 0, true, false, false,
856 handle_hot_attribute },
857 { "warning", 1, 1, true, false, false,
858 handle_error_attribute },
859 { "error", 1, 1, true, false, false,
860 handle_error_attribute },
861 { "target", 1, -1, true, false, false,
862 handle_target_attribute },
863 { "optimize", 1, -1, true, false, false,
864 handle_optimize_attribute },
865 { NULL, 0, 0, false, false, false, NULL }
868 /* Give the specifications for the format attributes, used by C and all
871 const struct attribute_spec c_common_format_attribute_table[] =
873 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
874 { "format", 3, 3, false, true, true,
875 handle_format_attribute },
876 { "format_arg", 1, 1, false, true, true,
877 handle_format_arg_attribute },
878 { NULL, 0, 0, false, false, false, NULL }
881 /* Push current bindings for the function name VAR_DECLS. */
884 start_fname_decls (void)
887 tree saved = NULL_TREE;
889 for (ix = 0; fname_vars[ix].decl; ix++)
891 tree decl = *fname_vars[ix].decl;
895 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
896 *fname_vars[ix].decl = NULL_TREE;
899 if (saved || saved_function_name_decls)
900 /* Normally they'll have been NULL, so only push if we've got a
901 stack, or they are non-NULL. */
902 saved_function_name_decls = tree_cons (saved, NULL_TREE,
903 saved_function_name_decls);
906 /* Finish up the current bindings, adding them into the current function's
907 statement tree. This must be done _before_ finish_stmt_tree is called.
908 If there is no current function, we must be at file scope and no statements
909 are involved. Pop the previous bindings. */
912 finish_fname_decls (void)
915 tree stmts = NULL_TREE;
916 tree stack = saved_function_name_decls;
918 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
919 append_to_statement_list (TREE_VALUE (stack), &stmts);
923 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
925 if (TREE_CODE (*bodyp) == BIND_EXPR)
926 bodyp = &BIND_EXPR_BODY (*bodyp);
928 append_to_statement_list_force (*bodyp, &stmts);
932 for (ix = 0; fname_vars[ix].decl; ix++)
933 *fname_vars[ix].decl = NULL_TREE;
937 /* We had saved values, restore them. */
940 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
942 tree decl = TREE_PURPOSE (saved);
943 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
945 *fname_vars[ix].decl = decl;
947 stack = TREE_CHAIN (stack);
949 saved_function_name_decls = stack;
952 /* Return the text name of the current function, suitably prettified
953 by PRETTY_P. Return string must be freed by caller. */
956 fname_as_string (int pretty_p)
958 const char *name = "top level";
961 cpp_string cstr = { 0, 0 }, strname;
969 if (current_function_decl)
970 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
972 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
974 namep = XNEWVEC (char, len);
975 snprintf (namep, len, "\"%s\"", name);
976 strname.text = (unsigned char *) namep;
977 strname.len = len - 1;
979 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
982 return (const char *) cstr.text;
988 /* Return the VAR_DECL for a const char array naming the current
989 function. If the VAR_DECL has not yet been created, create it
990 now. RID indicates how it should be formatted and IDENTIFIER_NODE
991 ID is its name (unfortunately C and C++ hold the RID values of
992 keywords in different places, so we can't derive RID from ID in
993 this language independent code. LOC is the location of the
997 fname_decl (location_t loc, unsigned int rid, tree id)
1000 tree decl = NULL_TREE;
1002 for (ix = 0; fname_vars[ix].decl; ix++)
1003 if (fname_vars[ix].rid == rid)
1006 decl = *fname_vars[ix].decl;
1009 /* If a tree is built here, it would normally have the lineno of
1010 the current statement. Later this tree will be moved to the
1011 beginning of the function and this line number will be wrong.
1012 To avoid this problem set the lineno to 0 here; that prevents
1013 it from appearing in the RTL. */
1015 location_t saved_location = input_location;
1016 input_location = UNKNOWN_LOCATION;
1018 stmts = push_stmt_list ();
1019 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1020 stmts = pop_stmt_list (stmts);
1021 if (!IS_EMPTY_STMT (stmts))
1022 saved_function_name_decls
1023 = tree_cons (decl, stmts, saved_function_name_decls);
1024 *fname_vars[ix].decl = decl;
1025 input_location = saved_location;
1027 if (!ix && !current_function_decl)
1028 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1033 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1036 fix_string_type (tree value)
1038 int length = TREE_STRING_LENGTH (value);
1040 tree e_type, i_type, a_type;
1042 /* Compute the number of elements, for the array type. */
1043 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1046 e_type = char_type_node;
1048 else if (TREE_TYPE (value) == char16_array_type_node)
1050 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1051 e_type = char16_type_node;
1053 else if (TREE_TYPE (value) == char32_array_type_node)
1055 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1056 e_type = char32_type_node;
1060 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1061 e_type = wchar_type_node;
1064 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1065 limit in C++98 Annex B is very large (65536) and is not normative,
1066 so we do not diagnose it (warn_overlength_strings is forced off
1067 in c_common_post_options). */
1068 if (warn_overlength_strings)
1070 const int nchars_max = flag_isoc99 ? 4095 : 509;
1071 const int relevant_std = flag_isoc99 ? 99 : 90;
1072 if (nchars - 1 > nchars_max)
1073 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1074 separate the %d from the 'C'. 'ISO' should not be
1075 translated, but it may be moved after 'C%d' in languages
1076 where modifiers follow nouns. */
1077 pedwarn (input_location, OPT_Woverlength_strings,
1078 "string length %qd is greater than the length %qd "
1079 "ISO C%d compilers are required to support",
1080 nchars - 1, nchars_max, relevant_std);
1083 /* Create the array type for the string constant. The ISO C++
1084 standard says that a string literal has type `const char[N]' or
1085 `const wchar_t[N]'. We use the same logic when invoked as a C
1086 front-end with -Wwrite-strings.
1087 ??? We should change the type of an expression depending on the
1088 state of a warning flag. We should just be warning -- see how
1089 this is handled in the C++ front-end for the deprecated implicit
1090 conversion from string literals to `char*' or `wchar_t*'.
1092 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1093 array type being the unqualified version of that type.
1094 Therefore, if we are constructing an array of const char, we must
1095 construct the matching unqualified array type first. The C front
1096 end does not require this, but it does no harm, so we do it
1098 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1099 a_type = build_array_type (e_type, i_type);
1100 if (c_dialect_cxx() || warn_write_strings)
1101 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1103 TREE_TYPE (value) = a_type;
1104 TREE_CONSTANT (value) = 1;
1105 TREE_READONLY (value) = 1;
1106 TREE_STATIC (value) = 1;
1110 /* Print a warning if a constant expression had overflow in folding.
1111 Invoke this function on every expression that the language
1112 requires to be a constant expression.
1113 Note the ANSI C standard says it is erroneous for a
1114 constant expression to overflow. */
1117 constant_expression_warning (tree value)
1119 if (warn_overflow && pedantic
1120 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1121 || TREE_CODE (value) == FIXED_CST
1122 || TREE_CODE (value) == VECTOR_CST
1123 || TREE_CODE (value) == COMPLEX_CST)
1124 && TREE_OVERFLOW (value))
1125 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1128 /* The same as above but print an unconditional error. */
1130 constant_expression_error (tree value)
1132 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1133 || TREE_CODE (value) == FIXED_CST
1134 || TREE_CODE (value) == VECTOR_CST
1135 || TREE_CODE (value) == COMPLEX_CST)
1136 && TREE_OVERFLOW (value))
1137 error ("overflow in constant expression");
1140 /* Print a warning if an expression had overflow in folding and its
1143 Invoke this function on every expression that
1144 (1) appears in the source code, and
1145 (2) is a constant expression that overflowed, and
1146 (3) is not already checked by convert_and_check;
1147 however, do not invoke this function on operands of explicit casts
1148 or when the expression is the result of an operator and any operand
1149 already overflowed. */
1152 overflow_warning (tree value)
1154 if (skip_evaluation) return;
1156 switch (TREE_CODE (value))
1159 warning (OPT_Woverflow, "integer overflow in expression");
1163 warning (OPT_Woverflow, "floating point overflow in expression");
1167 warning (OPT_Woverflow, "fixed-point overflow in expression");
1171 warning (OPT_Woverflow, "vector overflow in expression");
1175 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1176 warning (OPT_Woverflow, "complex integer overflow in expression");
1177 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1178 warning (OPT_Woverflow, "complex floating point overflow in expression");
1187 /* Warn about use of a logical || / && operator being used in a
1188 context where it is likely that the bitwise equivalent was intended
1189 by the programmer. CODE is the TREE_CODE of the operator, ARG1
1190 and ARG2 the arguments. */
1193 warn_logical_operator (enum tree_code code, tree arg1, tree
1198 case TRUTH_ANDIF_EXPR:
1199 case TRUTH_ORIF_EXPR:
1201 case TRUTH_AND_EXPR:
1202 if (!TREE_NO_WARNING (arg1)
1203 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
1204 && !CONSTANT_CLASS_P (arg1)
1205 && TREE_CODE (arg2) == INTEGER_CST
1206 && !integer_zerop (arg2))
1208 warning (OPT_Wlogical_op,
1209 "logical %<%s%> with non-zero constant "
1210 "will always evaluate as true",
1211 ((code == TRUTH_ANDIF_EXPR)
1212 || (code == TRUTH_AND_EXPR)) ? "&&" : "||");
1213 TREE_NO_WARNING (arg1) = true;
1222 /* Print a warning about casts that might indicate violation
1223 of strict aliasing rules if -Wstrict-aliasing is used and
1224 strict aliasing mode is in effect. OTYPE is the original
1225 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1228 strict_aliasing_warning (tree otype, tree type, tree expr)
1230 if (!(flag_strict_aliasing
1231 && POINTER_TYPE_P (type)
1232 && POINTER_TYPE_P (otype)
1233 && !VOID_TYPE_P (TREE_TYPE (type)))
1234 /* If the type we are casting to is a ref-all pointer
1235 dereferencing it is always valid. */
1236 || TYPE_REF_CAN_ALIAS_ALL (type))
1239 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1240 && (DECL_P (TREE_OPERAND (expr, 0))
1241 || handled_component_p (TREE_OPERAND (expr, 0))))
1243 /* Casting the address of an object to non void pointer. Warn
1244 if the cast breaks type based aliasing. */
1245 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1247 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1248 "might break strict-aliasing rules");
1253 /* warn_strict_aliasing >= 3. This includes the default (3).
1254 Only warn if the cast is dereferenced immediately. */
1255 alias_set_type set1 =
1256 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1257 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1259 if (set1 != set2 && set2 != 0
1260 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1262 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1263 "pointer will break strict-aliasing rules");
1266 else if (warn_strict_aliasing == 2
1267 && !alias_sets_must_conflict_p (set1, set2))
1269 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1270 "pointer might break strict-aliasing rules");
1276 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1278 /* At this level, warn for any conversions, even if an address is
1279 not taken in the same statement. This will likely produce many
1280 false positives, but could be useful to pinpoint problems that
1281 are not revealed at higher levels. */
1282 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1283 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1284 if (!COMPLETE_TYPE_P (type)
1285 || !alias_sets_must_conflict_p (set1, set2))
1287 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1288 "pointer might break strict-aliasing rules");
1296 /* Warn for unlikely, improbable, or stupid DECL declarations
1300 check_main_parameter_types (tree decl)
1305 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1306 args = TREE_CHAIN (args))
1308 tree type = args ? TREE_VALUE (args) : 0;
1310 if (type == void_type_node || type == error_mark_node )
1317 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1318 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1323 if (TREE_CODE (type) != POINTER_TYPE
1324 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1325 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1327 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1332 if (TREE_CODE (type) != POINTER_TYPE
1333 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1334 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1336 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1337 "%<char **%>", decl);
1342 /* It is intentional that this message does not mention the third
1343 argument because it's only mentioned in an appendix of the
1345 if (argct > 0 && (argct < 2 || argct > 3))
1346 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1349 /* True if pointers to distinct types T1 and T2 can be converted to
1350 each other without an explicit cast. Only returns true for opaque
1353 vector_targets_convertible_p (const_tree t1, const_tree t2)
1355 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1356 && (targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1357 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1363 /* True if vector types T1 and T2 can be converted to each other
1364 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1365 can only be converted with -flax-vector-conversions yet that is not
1366 in effect, emit a note telling the user about that option if such
1367 a note has not previously been emitted. */
1369 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1371 static bool emitted_lax_note = false;
1372 bool convertible_lax;
1374 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1375 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1379 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1380 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1381 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1382 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1383 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1385 if (!convertible_lax || flag_lax_vector_conversions)
1386 return convertible_lax;
1388 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1389 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1392 if (emit_lax_note && !emitted_lax_note)
1394 emitted_lax_note = true;
1395 inform (input_location, "use -flax-vector-conversions to permit "
1396 "conversions between vectors with differing "
1397 "element types or numbers of subparts");
1403 /* This is a helper function of build_binary_op.
1405 For certain operations if both args were extended from the same
1406 smaller type, do the arithmetic in that type and then extend.
1408 BITWISE indicates a bitwise operation.
1409 For them, this optimization is safe only if
1410 both args are zero-extended or both are sign-extended.
1411 Otherwise, we might change the result.
1412 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1413 but calculated in (unsigned short) it would be (unsigned short)-1.
1415 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1417 int unsigned0, unsigned1;
1422 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1423 excessive narrowing when we call get_narrower below. For
1424 example, suppose that OP0 is of unsigned int extended
1425 from signed char and that RESULT_TYPE is long long int.
1426 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1429 (long long int) (unsigned int) signed_char
1431 which get_narrower would narrow down to
1433 (unsigned int) signed char
1435 If we do not cast OP0 first, get_narrower would return
1436 signed_char, which is inconsistent with the case of the
1438 op0 = convert (result_type, op0);
1439 op1 = convert (result_type, op1);
1441 arg0 = get_narrower (op0, &unsigned0);
1442 arg1 = get_narrower (op1, &unsigned1);
1444 /* UNS is 1 if the operation to be done is an unsigned one. */
1445 uns = TYPE_UNSIGNED (result_type);
1447 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1448 but it *requires* conversion to FINAL_TYPE. */
1450 if ((TYPE_PRECISION (TREE_TYPE (op0))
1451 == TYPE_PRECISION (TREE_TYPE (arg0)))
1452 && TREE_TYPE (op0) != result_type)
1453 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1454 if ((TYPE_PRECISION (TREE_TYPE (op1))
1455 == TYPE_PRECISION (TREE_TYPE (arg1)))
1456 && TREE_TYPE (op1) != result_type)
1457 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1459 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1461 /* For bitwise operations, signedness of nominal type
1462 does not matter. Consider only how operands were extended. */
1466 /* Note that in all three cases below we refrain from optimizing
1467 an unsigned operation on sign-extended args.
1468 That would not be valid. */
1470 /* Both args variable: if both extended in same way
1471 from same width, do it in that width.
1472 Do it unsigned if args were zero-extended. */
1473 if ((TYPE_PRECISION (TREE_TYPE (arg0))
1474 < TYPE_PRECISION (result_type))
1475 && (TYPE_PRECISION (TREE_TYPE (arg1))
1476 == TYPE_PRECISION (TREE_TYPE (arg0)))
1477 && unsigned0 == unsigned1
1478 && (unsigned0 || !uns))
1479 return c_common_signed_or_unsigned_type
1480 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1482 else if (TREE_CODE (arg0) == INTEGER_CST
1483 && (unsigned1 || !uns)
1484 && (TYPE_PRECISION (TREE_TYPE (arg1))
1485 < TYPE_PRECISION (result_type))
1487 = c_common_signed_or_unsigned_type (unsigned1,
1489 && !POINTER_TYPE_P (type)
1490 && int_fits_type_p (arg0, type))
1493 else if (TREE_CODE (arg1) == INTEGER_CST
1494 && (unsigned0 || !uns)
1495 && (TYPE_PRECISION (TREE_TYPE (arg0))
1496 < TYPE_PRECISION (result_type))
1498 = c_common_signed_or_unsigned_type (unsigned0,
1500 && !POINTER_TYPE_P (type)
1501 && int_fits_type_p (arg1, type))
1507 /* Warns if the conversion of EXPR to TYPE may alter a value.
1508 This is a helper function for warnings_for_convert_and_check. */
1511 conversion_warning (tree type, tree expr)
1513 bool give_warning = false;
1516 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
1517 tree expr_type = TREE_TYPE (expr);
1519 if (!warn_conversion && !warn_sign_conversion)
1522 /* If any operand is artificial, then this expression was generated
1523 by the compiler and we do not warn. */
1524 for (i = 0; i < expr_num_operands; i++)
1526 tree op = TREE_OPERAND (expr, i);
1527 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
1531 switch (TREE_CODE (expr))
1539 case TRUTH_ANDIF_EXPR:
1540 case TRUTH_ORIF_EXPR:
1541 case TRUTH_AND_EXPR:
1543 case TRUTH_XOR_EXPR:
1544 case TRUTH_NOT_EXPR:
1545 /* Conversion from boolean to a signed:1 bit-field (which only
1546 can hold the values 0 and -1) doesn't lose information - but
1547 it does change the value. */
1548 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
1549 warning (OPT_Wconversion,
1550 "conversion to %qT from boolean expression", type);
1556 /* Warn for real constant that is not an exact integer converted
1558 if (TREE_CODE (expr_type) == REAL_TYPE
1559 && TREE_CODE (type) == INTEGER_TYPE)
1561 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
1562 give_warning = true;
1564 /* Warn for an integer constant that does not fit into integer type. */
1565 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1566 && TREE_CODE (type) == INTEGER_TYPE
1567 && !int_fits_type_p (expr, type))
1569 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
1570 && tree_int_cst_sgn (expr) < 0)
1571 warning (OPT_Wsign_conversion,
1572 "negative integer implicitly converted to unsigned type");
1573 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
1574 warning (OPT_Wsign_conversion, "conversion of unsigned constant "
1575 "value to negative integer");
1577 give_warning = true;
1579 else if (TREE_CODE (type) == REAL_TYPE)
1581 /* Warn for an integer constant that does not fit into real type. */
1582 if (TREE_CODE (expr_type) == INTEGER_TYPE)
1584 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1585 if (!exact_real_truncate (TYPE_MODE (type), &a))
1586 give_warning = true;
1588 /* Warn for a real constant that does not fit into a smaller
1590 else if (TREE_CODE (expr_type) == REAL_TYPE
1591 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1593 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1594 if (!exact_real_truncate (TYPE_MODE (type), &a))
1595 give_warning = true;
1600 warning (OPT_Wconversion,
1601 "conversion to %qT alters %qT constant value",
1608 /* In case of COND_EXPR, if both operands are constants or
1609 COND_EXPR, then we do not care about the type of COND_EXPR,
1610 only about the conversion of each operand. */
1611 tree op1 = TREE_OPERAND (expr, 1);
1612 tree op2 = TREE_OPERAND (expr, 2);
1614 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
1615 || TREE_CODE (op1) == COND_EXPR)
1616 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
1617 || TREE_CODE (op2) == COND_EXPR))
1619 conversion_warning (type, op1);
1620 conversion_warning (type, op2);
1626 default: /* 'expr' is not a constant. */
1628 /* Warn for real types converted to integer types. */
1629 if (TREE_CODE (expr_type) == REAL_TYPE
1630 && TREE_CODE (type) == INTEGER_TYPE)
1631 give_warning = true;
1633 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1634 && TREE_CODE (type) == INTEGER_TYPE)
1636 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1637 expr = get_unwidened (expr, 0);
1638 expr_type = TREE_TYPE (expr);
1640 /* Don't warn for short y; short x = ((int)y & 0xff); */
1641 if (TREE_CODE (expr) == BIT_AND_EXPR
1642 || TREE_CODE (expr) == BIT_IOR_EXPR
1643 || TREE_CODE (expr) == BIT_XOR_EXPR)
1645 /* If both args were extended from a shortest type,
1646 use that type if that is safe. */
1647 expr_type = shorten_binary_op (expr_type,
1648 TREE_OPERAND (expr, 0),
1649 TREE_OPERAND (expr, 1),
1652 if (TREE_CODE (expr) == BIT_AND_EXPR)
1654 tree op0 = TREE_OPERAND (expr, 0);
1655 tree op1 = TREE_OPERAND (expr, 1);
1656 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1657 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1659 /* If one of the operands is a non-negative constant
1660 that fits in the target type, then the type of the
1661 other operand does not matter. */
1662 if ((TREE_CODE (op0) == INTEGER_CST
1663 && int_fits_type_p (op0, c_common_signed_type (type))
1664 && int_fits_type_p (op0, c_common_unsigned_type (type)))
1665 || (TREE_CODE (op1) == INTEGER_CST
1666 && int_fits_type_p (op1, c_common_signed_type (type))
1667 && int_fits_type_p (op1,
1668 c_common_unsigned_type (type))))
1670 /* If constant is unsigned and fits in the target
1671 type, then the result will also fit. */
1672 else if ((TREE_CODE (op0) == INTEGER_CST
1674 && int_fits_type_p (op0, type))
1675 || (TREE_CODE (op1) == INTEGER_CST
1677 && int_fits_type_p (op1, type)))
1681 /* Warn for integer types converted to smaller integer types. */
1682 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1683 give_warning = true;
1685 /* When they are the same width but different signedness,
1686 then the value may change. */
1687 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
1688 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
1689 /* Even when converted to a bigger type, if the type is
1690 unsigned but expr is signed, then negative values
1692 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
1693 warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
1694 "may change the sign of the result",
1698 /* Warn for integer types converted to real types if and only if
1699 all the range of values of the integer type cannot be
1700 represented by the real type. */
1701 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1702 && TREE_CODE (type) == REAL_TYPE)
1704 tree type_low_bound = TYPE_MIN_VALUE (expr_type);
1705 tree type_high_bound = TYPE_MAX_VALUE (expr_type);
1706 REAL_VALUE_TYPE real_low_bound
1707 = real_value_from_int_cst (0, type_low_bound);
1708 REAL_VALUE_TYPE real_high_bound
1709 = real_value_from_int_cst (0, type_high_bound);
1711 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1712 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1713 give_warning = true;
1716 /* Warn for real types converted to smaller real types. */
1717 else if (TREE_CODE (expr_type) == REAL_TYPE
1718 && TREE_CODE (type) == REAL_TYPE
1719 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1720 give_warning = true;
1724 warning (OPT_Wconversion,
1725 "conversion to %qT from %qT may alter its value",
1730 /* Produce warnings after a conversion. RESULT is the result of
1731 converting EXPR to TYPE. This is a helper function for
1732 convert_and_check and cp_convert_and_check. */
1735 warnings_for_convert_and_check (tree type, tree expr, tree result)
1737 if (TREE_CODE (expr) == INTEGER_CST
1738 && (TREE_CODE (type) == INTEGER_TYPE
1739 || TREE_CODE (type) == ENUMERAL_TYPE)
1740 && !int_fits_type_p (expr, type))
1742 /* Do not diagnose overflow in a constant expression merely
1743 because a conversion overflowed. */
1744 if (TREE_OVERFLOW (result))
1745 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1747 if (TYPE_UNSIGNED (type))
1749 /* This detects cases like converting -129 or 256 to
1751 if (!int_fits_type_p (expr, c_common_signed_type (type)))
1752 warning (OPT_Woverflow,
1753 "large integer implicitly truncated to unsigned type");
1755 conversion_warning (type, expr);
1757 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
1758 warning (OPT_Woverflow,
1759 "overflow in implicit constant conversion");
1760 /* No warning for converting 0x80000000 to int. */
1762 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1763 || TYPE_PRECISION (TREE_TYPE (expr))
1764 != TYPE_PRECISION (type)))
1765 warning (OPT_Woverflow,
1766 "overflow in implicit constant conversion");
1769 conversion_warning (type, expr);
1771 else if ((TREE_CODE (result) == INTEGER_CST
1772 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
1773 warning (OPT_Woverflow,
1774 "overflow in implicit constant conversion");
1776 conversion_warning (type, expr);
1780 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1781 Invoke this function on every expression that is converted implicitly,
1782 i.e. because of language rules and not because of an explicit cast. */
1785 convert_and_check (tree type, tree expr)
1789 if (TREE_TYPE (expr) == type)
1792 result = convert (type, expr);
1794 if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
1795 warnings_for_convert_and_check (type, expr, result);
1800 /* A node in a list that describes references to variables (EXPR), which are
1801 either read accesses if WRITER is zero, or write accesses, in which case
1802 WRITER is the parent of EXPR. */
1809 /* Used to implement a cache the results of a call to verify_tree. We only
1810 use this for SAVE_EXPRs. */
1813 struct tlist_cache *next;
1814 struct tlist *cache_before_sp;
1815 struct tlist *cache_after_sp;
1819 /* Obstack to use when allocating tlist structures, and corresponding
1821 static struct obstack tlist_obstack;
1822 static char *tlist_firstobj = 0;
1824 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1826 static struct tlist *warned_ids;
1827 /* SAVE_EXPRs need special treatment. We process them only once and then
1828 cache the results. */
1829 static struct tlist_cache *save_expr_cache;
1831 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1832 static void merge_tlist (struct tlist **, struct tlist *, int);
1833 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1834 static int warning_candidate_p (tree);
1835 static void warn_for_collisions (struct tlist *);
1836 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1837 static struct tlist *new_tlist (struct tlist *, tree, tree);
1839 /* Create a new struct tlist and fill in its fields. */
1840 static struct tlist *
1841 new_tlist (struct tlist *next, tree t, tree writer)
1844 l = XOBNEW (&tlist_obstack, struct tlist);
1851 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1852 is nonnull, we ignore any node we find which has a writer equal to it. */
1855 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1859 struct tlist *next = add->next;
1862 if (!exclude_writer || add->writer != exclude_writer)
1863 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1868 /* Merge the nodes of ADD into TO. This merging process is done so that for
1869 each variable that already exists in TO, no new node is added; however if
1870 there is a write access recorded in ADD, and an occurrence on TO is only
1871 a read access, then the occurrence in TO will be modified to record the
1875 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1877 struct tlist **end = to;
1880 end = &(*end)->next;
1886 struct tlist *next = add->next;
1888 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1889 if (tmp2->expr == add->expr)
1893 tmp2->writer = add->writer;
1897 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1898 end = &(*end)->next;
1905 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1906 references in list LIST conflict with it, excluding reads if ONLY writers
1910 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1915 /* Avoid duplicate warnings. */
1916 for (tmp = warned_ids; tmp; tmp = tmp->next)
1917 if (tmp->expr == written)
1922 if (list->expr == written
1923 && list->writer != writer
1924 && (!only_writes || list->writer)
1925 && DECL_NAME (list->expr))
1927 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1928 warning_at (EXPR_HAS_LOCATION (writer)
1929 ? EXPR_LOCATION (writer) : input_location,
1930 OPT_Wsequence_point, "operation on %qE may be undefined",
1937 /* Given a list LIST of references to variables, find whether any of these
1938 can cause conflicts due to missing sequence points. */
1941 warn_for_collisions (struct tlist *list)
1945 for (tmp = list; tmp; tmp = tmp->next)
1948 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1952 /* Return nonzero if X is a tree that can be verified by the sequence point
1955 warning_candidate_p (tree x)
1957 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1960 /* Walk the tree X, and record accesses to variables. If X is written by the
1961 parent tree, WRITER is the parent.
1962 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1963 expression or its only operand forces a sequence point, then everything up
1964 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1966 Once we return, we will have emitted warnings if any subexpression before
1967 such a sequence point could be undefined. On a higher level, however, the
1968 sequence point may not be relevant, and we'll merge the two lists.
1970 Example: (b++, a) + b;
1971 The call that processes the COMPOUND_EXPR will store the increment of B
1972 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1973 processes the PLUS_EXPR will need to merge the two lists so that
1974 eventually, all accesses end up on the same list (and we'll warn about the
1975 unordered subexpressions b++ and b.
1977 A note on merging. If we modify the former example so that our expression
1980 care must be taken not simply to add all three expressions into the final
1981 PNO_SP list. The function merge_tlist takes care of that by merging the
1982 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1983 way, so that no more than one access to B is recorded. */
1986 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1989 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1990 enum tree_code code;
1991 enum tree_code_class cl;
1993 /* X may be NULL if it is the operand of an empty statement expression
1999 code = TREE_CODE (x);
2000 cl = TREE_CODE_CLASS (code);
2002 if (warning_candidate_p (x))
2004 *pno_sp = new_tlist (*pno_sp, x, writer);
2014 case TRUTH_ANDIF_EXPR:
2015 case TRUTH_ORIF_EXPR:
2016 tmp_before = tmp_nosp = tmp_list3 = 0;
2017 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2018 warn_for_collisions (tmp_nosp);
2019 merge_tlist (pbefore_sp, tmp_before, 0);
2020 merge_tlist (pbefore_sp, tmp_nosp, 0);
2021 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2022 merge_tlist (pbefore_sp, tmp_list3, 0);
2026 tmp_before = tmp_list2 = 0;
2027 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2028 warn_for_collisions (tmp_list2);
2029 merge_tlist (pbefore_sp, tmp_before, 0);
2030 merge_tlist (pbefore_sp, tmp_list2, 1);
2032 tmp_list3 = tmp_nosp = 0;
2033 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2034 warn_for_collisions (tmp_nosp);
2035 merge_tlist (pbefore_sp, tmp_list3, 0);
2037 tmp_list3 = tmp_list2 = 0;
2038 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2039 warn_for_collisions (tmp_list2);
2040 merge_tlist (pbefore_sp, tmp_list3, 0);
2041 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2042 two first, to avoid warning for (a ? b++ : b++). */
2043 merge_tlist (&tmp_nosp, tmp_list2, 0);
2044 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2047 case PREDECREMENT_EXPR:
2048 case PREINCREMENT_EXPR:
2049 case POSTDECREMENT_EXPR:
2050 case POSTINCREMENT_EXPR:
2051 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2055 tmp_before = tmp_nosp = tmp_list3 = 0;
2056 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2057 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2058 /* Expressions inside the LHS are not ordered wrt. the sequence points
2059 in the RHS. Example:
2061 Despite the fact that the modification of "a" is in the before_sp
2062 list (tmp_before), it conflicts with the use of "a" in the LHS.
2063 We can handle this by adding the contents of tmp_list3
2064 to those of tmp_before, and redoing the collision warnings for that
2066 add_tlist (&tmp_before, tmp_list3, x, 1);
2067 warn_for_collisions (tmp_before);
2068 /* Exclude the LHS itself here; we first have to merge it into the
2069 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2070 didn't exclude the LHS, we'd get it twice, once as a read and once
2072 add_tlist (pno_sp, tmp_list3, x, 0);
2073 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2075 merge_tlist (pbefore_sp, tmp_before, 0);
2076 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2077 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2078 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2082 /* We need to warn about conflicts among arguments and conflicts between
2083 args and the function address. Side effects of the function address,
2084 however, are not ordered by the sequence point of the call. */
2086 call_expr_arg_iterator iter;
2088 tmp_before = tmp_nosp = 0;
2089 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2090 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2092 tmp_list2 = tmp_list3 = 0;
2093 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2094 merge_tlist (&tmp_list3, tmp_list2, 0);
2095 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2097 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2098 warn_for_collisions (tmp_before);
2099 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2104 /* Scan all the list, e.g. indices of multi dimensional array. */
2107 tmp_before = tmp_nosp = 0;
2108 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2109 merge_tlist (&tmp_nosp, tmp_before, 0);
2110 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2117 struct tlist_cache *t;
2118 for (t = save_expr_cache; t; t = t->next)
2124 t = XOBNEW (&tlist_obstack, struct tlist_cache);
2125 t->next = save_expr_cache;
2127 save_expr_cache = t;
2129 tmp_before = tmp_nosp = 0;
2130 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2131 warn_for_collisions (tmp_nosp);
2136 struct tlist *t = tmp_nosp;
2138 merge_tlist (&tmp_list3, t, 0);
2140 t->cache_before_sp = tmp_before;
2141 t->cache_after_sp = tmp_list3;
2143 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2144 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2149 x = TREE_OPERAND (x, 0);
2156 /* For other expressions, simply recurse on their operands.
2157 Manual tail recursion for unary expressions.
2158 Other non-expressions need not be processed. */
2159 if (cl == tcc_unary)
2161 x = TREE_OPERAND (x, 0);
2165 else if (IS_EXPR_CODE_CLASS (cl))
2168 int max = TREE_OPERAND_LENGTH (x);
2169 for (lp = 0; lp < max; lp++)
2171 tmp_before = tmp_nosp = 0;
2172 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2173 merge_tlist (&tmp_nosp, tmp_before, 0);
2174 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2181 /* Try to warn for undefined behavior in EXPR due to missing sequence
2185 verify_sequence_points (tree expr)
2187 struct tlist *before_sp = 0, *after_sp = 0;
2190 save_expr_cache = 0;
2191 if (tlist_firstobj == 0)
2193 gcc_obstack_init (&tlist_obstack);
2194 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2197 verify_tree (expr, &before_sp, &after_sp, 0);
2198 warn_for_collisions (after_sp);
2199 obstack_free (&tlist_obstack, tlist_firstobj);
2202 /* Validate the expression after `case' and apply default promotions. */
2205 check_case_value (tree value)
2207 if (value == NULL_TREE)
2210 /* ??? Can we ever get nops here for a valid case value? We
2212 STRIP_TYPE_NOPS (value);
2213 /* In C++, the following is allowed:
2216 switch (...) { case i: ... }
2218 So, we try to reduce the VALUE to a constant that way. */
2219 if (c_dialect_cxx ())
2221 value = decl_constant_value (value);
2222 STRIP_TYPE_NOPS (value);
2223 value = fold (value);
2226 if (TREE_CODE (value) == INTEGER_CST)
2227 /* Promote char or short to int. */
2228 value = perform_integral_promotions (value);
2229 else if (value != error_mark_node)
2231 error ("case label does not reduce to an integer constant");
2232 value = error_mark_node;
2235 constant_expression_warning (value);
2240 /* See if the case values LOW and HIGH are in the range of the original
2241 type (i.e. before the default conversion to int) of the switch testing
2243 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2244 the type before promoting it. CASE_LOW_P is a pointer to the lower
2245 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2246 if the case is not a case range.
2247 The caller has to make sure that we are not called with NULL for
2248 CASE_LOW_P (i.e. the default case).
2249 Returns true if the case label is in range of ORIG_TYPE (saturated or
2250 untouched) or false if the label is out of range. */
2253 check_case_bounds (tree type, tree orig_type,
2254 tree *case_low_p, tree *case_high_p)
2256 tree min_value, max_value;
2257 tree case_low = *case_low_p;
2258 tree case_high = case_high_p ? *case_high_p : case_low;
2260 /* If there was a problem with the original type, do nothing. */
2261 if (orig_type == error_mark_node)
2264 min_value = TYPE_MIN_VALUE (orig_type);
2265 max_value = TYPE_MAX_VALUE (orig_type);
2267 /* Case label is less than minimum for type. */
2268 if (tree_int_cst_compare (case_low, min_value) < 0
2269 && tree_int_cst_compare (case_high, min_value) < 0)
2271 warning (0, "case label value is less than minimum value for type");
2275 /* Case value is greater than maximum for type. */
2276 if (tree_int_cst_compare (case_low, max_value) > 0
2277 && tree_int_cst_compare (case_high, max_value) > 0)
2279 warning (0, "case label value exceeds maximum value for type");
2283 /* Saturate lower case label value to minimum. */
2284 if (tree_int_cst_compare (case_high, min_value) >= 0
2285 && tree_int_cst_compare (case_low, min_value) < 0)
2287 warning (0, "lower value in case label range"
2288 " less than minimum value for type");
2289 case_low = min_value;
2292 /* Saturate upper case label value to maximum. */
2293 if (tree_int_cst_compare (case_low, max_value) <= 0
2294 && tree_int_cst_compare (case_high, max_value) > 0)
2296 warning (0, "upper value in case label range"
2297 " exceeds maximum value for type");
2298 case_high = max_value;
2301 if (*case_low_p != case_low)
2302 *case_low_p = convert (type, case_low);
2303 if (case_high_p && *case_high_p != case_high)
2304 *case_high_p = convert (type, case_high);
2309 /* Return an integer type with BITS bits of precision,
2310 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2313 c_common_type_for_size (unsigned int bits, int unsignedp)
2315 if (bits == TYPE_PRECISION (integer_type_node))
2316 return unsignedp ? unsigned_type_node : integer_type_node;
2318 if (bits == TYPE_PRECISION (signed_char_type_node))
2319 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2321 if (bits == TYPE_PRECISION (short_integer_type_node))
2322 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2324 if (bits == TYPE_PRECISION (long_integer_type_node))
2325 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2327 if (bits == TYPE_PRECISION (long_long_integer_type_node))
2328 return (unsignedp ? long_long_unsigned_type_node
2329 : long_long_integer_type_node);
2331 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2332 return (unsignedp ? widest_unsigned_literal_type_node
2333 : widest_integer_literal_type_node);
2335 if (bits <= TYPE_PRECISION (intQI_type_node))
2336 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2338 if (bits <= TYPE_PRECISION (intHI_type_node))
2339 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2341 if (bits <= TYPE_PRECISION (intSI_type_node))
2342 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2344 if (bits <= TYPE_PRECISION (intDI_type_node))
2345 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2350 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2351 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2352 and saturating if SATP is nonzero, otherwise not saturating. */
2355 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2356 int unsignedp, int satp)
2358 enum machine_mode mode;
2360 mode = unsignedp ? UQQmode : QQmode;
2362 mode = unsignedp ? UHAmode : HAmode;
2364 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2365 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2368 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2370 sorry ("GCC cannot support operators with integer types and "
2371 "fixed-point types that have too many integral and "
2372 "fractional bits together");
2376 return c_common_type_for_mode (mode, satp);
2379 /* Used for communication between c_common_type_for_mode and
2380 c_register_builtin_type. */
2381 static GTY(()) tree registered_builtin_types;
2383 /* Return a data type that has machine mode MODE.
2384 If the mode is an integer,
2385 then UNSIGNEDP selects between signed and unsigned types.
2386 If the mode is a fixed-point mode,
2387 then UNSIGNEDP selects between saturating and nonsaturating types. */
2390 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2394 if (mode == TYPE_MODE (integer_type_node))
2395 return unsignedp ? unsigned_type_node : integer_type_node;
2397 if (mode == TYPE_MODE (signed_char_type_node))
2398 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2400 if (mode == TYPE_MODE (short_integer_type_node))
2401 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2403 if (mode == TYPE_MODE (long_integer_type_node))
2404 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2406 if (mode == TYPE_MODE (long_long_integer_type_node))
2407 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2409 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2410 return unsignedp ? widest_unsigned_literal_type_node
2411 : widest_integer_literal_type_node;
2414 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2417 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2420 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2423 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2425 #if HOST_BITS_PER_WIDE_INT >= 64
2426 if (mode == TYPE_MODE (intTI_type_node))
2427 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2430 if (mode == TYPE_MODE (float_type_node))
2431 return float_type_node;
2433 if (mode == TYPE_MODE (double_type_node))
2434 return double_type_node;
2436 if (mode == TYPE_MODE (long_double_type_node))
2437 return long_double_type_node;
2439 if (mode == TYPE_MODE (void_type_node))
2440 return void_type_node;
2442 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2444 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2445 : make_signed_type (GET_MODE_PRECISION (mode)));
2447 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2449 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2450 : make_signed_type (GET_MODE_PRECISION (mode)));
2452 if (COMPLEX_MODE_P (mode))
2454 enum machine_mode inner_mode;
2457 if (mode == TYPE_MODE (complex_float_type_node))
2458 return complex_float_type_node;
2459 if (mode == TYPE_MODE (complex_double_type_node))
2460 return complex_double_type_node;
2461 if (mode == TYPE_MODE (complex_long_double_type_node))
2462 return complex_long_double_type_node;
2464 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2465 return complex_integer_type_node;
2467 inner_mode = GET_MODE_INNER (mode);
2468 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2469 if (inner_type != NULL_TREE)
2470 return build_complex_type (inner_type);
2472 else if (VECTOR_MODE_P (mode))
2474 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2475 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2476 if (inner_type != NULL_TREE)
2477 return build_vector_type_for_mode (inner_type, mode);
2480 if (mode == TYPE_MODE (dfloat32_type_node))
2481 return dfloat32_type_node;
2482 if (mode == TYPE_MODE (dfloat64_type_node))
2483 return dfloat64_type_node;
2484 if (mode == TYPE_MODE (dfloat128_type_node))
2485 return dfloat128_type_node;
2487 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2489 if (mode == TYPE_MODE (short_fract_type_node))
2490 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2491 if (mode == TYPE_MODE (fract_type_node))
2492 return unsignedp ? sat_fract_type_node : fract_type_node;
2493 if (mode == TYPE_MODE (long_fract_type_node))
2494 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2495 if (mode == TYPE_MODE (long_long_fract_type_node))
2496 return unsignedp ? sat_long_long_fract_type_node
2497 : long_long_fract_type_node;
2499 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2500 return unsignedp ? sat_unsigned_short_fract_type_node
2501 : unsigned_short_fract_type_node;
2502 if (mode == TYPE_MODE (unsigned_fract_type_node))
2503 return unsignedp ? sat_unsigned_fract_type_node
2504 : unsigned_fract_type_node;
2505 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2506 return unsignedp ? sat_unsigned_long_fract_type_node
2507 : unsigned_long_fract_type_node;
2508 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2509 return unsignedp ? sat_unsigned_long_long_fract_type_node
2510 : unsigned_long_long_fract_type_node;
2512 if (mode == TYPE_MODE (short_accum_type_node))
2513 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2514 if (mode == TYPE_MODE (accum_type_node))
2515 return unsignedp ? sat_accum_type_node : accum_type_node;
2516 if (mode == TYPE_MODE (long_accum_type_node))
2517 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2518 if (mode == TYPE_MODE (long_long_accum_type_node))
2519 return unsignedp ? sat_long_long_accum_type_node
2520 : long_long_accum_type_node;
2522 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2523 return unsignedp ? sat_unsigned_short_accum_type_node
2524 : unsigned_short_accum_type_node;
2525 if (mode == TYPE_MODE (unsigned_accum_type_node))
2526 return unsignedp ? sat_unsigned_accum_type_node
2527 : unsigned_accum_type_node;
2528 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2529 return unsignedp ? sat_unsigned_long_accum_type_node
2530 : unsigned_long_accum_type_node;
2531 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2532 return unsignedp ? sat_unsigned_long_long_accum_type_node
2533 : unsigned_long_long_accum_type_node;
2536 return unsignedp ? sat_qq_type_node : qq_type_node;
2538 return unsignedp ? sat_hq_type_node : hq_type_node;
2540 return unsignedp ? sat_sq_type_node : sq_type_node;
2542 return unsignedp ? sat_dq_type_node : dq_type_node;
2544 return unsignedp ? sat_tq_type_node : tq_type_node;
2546 if (mode == UQQmode)
2547 return unsignedp ? sat_uqq_type_node : uqq_type_node;
2548 if (mode == UHQmode)
2549 return unsignedp ? sat_uhq_type_node : uhq_type_node;
2550 if (mode == USQmode)
2551 return unsignedp ? sat_usq_type_node : usq_type_node;
2552 if (mode == UDQmode)
2553 return unsignedp ? sat_udq_type_node : udq_type_node;
2554 if (mode == UTQmode)
2555 return unsignedp ? sat_utq_type_node : utq_type_node;
2558 return unsignedp ? sat_ha_type_node : ha_type_node;
2560 return unsignedp ? sat_sa_type_node : sa_type_node;
2562 return unsignedp ? sat_da_type_node : da_type_node;
2564 return unsignedp ? sat_ta_type_node : ta_type_node;
2566 if (mode == UHAmode)
2567 return unsignedp ? sat_uha_type_node : uha_type_node;
2568 if (mode == USAmode)
2569 return unsignedp ? sat_usa_type_node : usa_type_node;
2570 if (mode == UDAmode)
2571 return unsignedp ? sat_uda_type_node : uda_type_node;
2572 if (mode == UTAmode)
2573 return unsignedp ? sat_uta_type_node : uta_type_node;
2576 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2577 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2578 return TREE_VALUE (t);
2584 c_common_unsigned_type (tree type)
2586 return c_common_signed_or_unsigned_type (1, type);
2589 /* Return a signed type the same as TYPE in other respects. */
2592 c_common_signed_type (tree type)
2594 return c_common_signed_or_unsigned_type (0, type);
2597 /* Return a type the same as TYPE except unsigned or
2598 signed according to UNSIGNEDP. */
2601 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2605 /* This block of code emulates the behavior of the old
2606 c_common_unsigned_type. In particular, it returns
2607 long_unsigned_type_node if passed a long, even when a int would
2608 have the same size. This is necessary for warnings to work
2609 correctly in archs where sizeof(int) == sizeof(long) */
2611 type1 = TYPE_MAIN_VARIANT (type);
2612 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2613 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2614 if (type1 == integer_type_node || type1 == unsigned_type_node)
2615 return unsignedp ? unsigned_type_node : integer_type_node;
2616 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2617 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2618 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2619 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2620 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
2621 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2622 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
2623 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
2624 #if HOST_BITS_PER_WIDE_INT >= 64
2625 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2626 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2628 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2629 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2630 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2631 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2632 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2633 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2634 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2635 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2637 #define C_COMMON_FIXED_TYPES(NAME) \
2638 if (type1 == short_ ## NAME ## _type_node \
2639 || type1 == unsigned_short_ ## NAME ## _type_node) \
2640 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2641 : short_ ## NAME ## _type_node; \
2642 if (type1 == NAME ## _type_node \
2643 || type1 == unsigned_ ## NAME ## _type_node) \
2644 return unsignedp ? unsigned_ ## NAME ## _type_node \
2645 : NAME ## _type_node; \
2646 if (type1 == long_ ## NAME ## _type_node \
2647 || type1 == unsigned_long_ ## NAME ## _type_node) \
2648 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2649 : long_ ## NAME ## _type_node; \
2650 if (type1 == long_long_ ## NAME ## _type_node \
2651 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2652 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2653 : long_long_ ## NAME ## _type_node;
2655 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
2656 if (type1 == NAME ## _type_node \
2657 || type1 == u ## NAME ## _type_node) \
2658 return unsignedp ? u ## NAME ## _type_node \
2659 : NAME ## _type_node;
2661 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
2662 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2663 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2664 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2665 : sat_ ## short_ ## NAME ## _type_node; \
2666 if (type1 == sat_ ## NAME ## _type_node \
2667 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2668 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2669 : sat_ ## NAME ## _type_node; \
2670 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2671 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2672 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2673 : sat_ ## long_ ## NAME ## _type_node; \
2674 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2675 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2676 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2677 : sat_ ## long_long_ ## NAME ## _type_node;
2679 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
2680 if (type1 == sat_ ## NAME ## _type_node \
2681 || type1 == sat_ ## u ## NAME ## _type_node) \
2682 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2683 : sat_ ## NAME ## _type_node;
2685 C_COMMON_FIXED_TYPES (fract);
2686 C_COMMON_FIXED_TYPES_SAT (fract);
2687 C_COMMON_FIXED_TYPES (accum);
2688 C_COMMON_FIXED_TYPES_SAT (accum);
2690 C_COMMON_FIXED_MODE_TYPES (qq);
2691 C_COMMON_FIXED_MODE_TYPES (hq);
2692 C_COMMON_FIXED_MODE_TYPES (sq);
2693 C_COMMON_FIXED_MODE_TYPES (dq);
2694 C_COMMON_FIXED_MODE_TYPES (tq);
2695 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
2696 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
2697 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
2698 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
2699 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
2700 C_COMMON_FIXED_MODE_TYPES (ha);
2701 C_COMMON_FIXED_MODE_TYPES (sa);
2702 C_COMMON_FIXED_MODE_TYPES (da);
2703 C_COMMON_FIXED_MODE_TYPES (ta);
2704 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
2705 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
2706 C_COMMON_FIXED_MODE_TYPES_SAT (da);
2707 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
2709 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2710 the precision; they have precision set to match their range, but
2711 may use a wider mode to match an ABI. If we change modes, we may
2712 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2713 the precision as well, so as to yield correct results for
2714 bit-field types. C++ does not have these separate bit-field
2715 types, and producing a signed or unsigned variant of an
2716 ENUMERAL_TYPE may cause other problems as well. */
2718 if (!INTEGRAL_TYPE_P (type)
2719 || TYPE_UNSIGNED (type) == unsignedp)
2722 #define TYPE_OK(node) \
2723 (TYPE_MODE (type) == TYPE_MODE (node) \
2724 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2725 if (TYPE_OK (signed_char_type_node))
2726 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2727 if (TYPE_OK (integer_type_node))
2728 return unsignedp ? unsigned_type_node : integer_type_node;
2729 if (TYPE_OK (short_integer_type_node))
2730 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2731 if (TYPE_OK (long_integer_type_node))
2732 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2733 if (TYPE_OK (long_long_integer_type_node))
2734 return (unsignedp ? long_long_unsigned_type_node
2735 : long_long_integer_type_node);
2736 if (TYPE_OK (widest_integer_literal_type_node))
2737 return (unsignedp ? widest_unsigned_literal_type_node
2738 : widest_integer_literal_type_node);
2740 #if HOST_BITS_PER_WIDE_INT >= 64
2741 if (TYPE_OK (intTI_type_node))
2742 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2744 if (TYPE_OK (intDI_type_node))
2745 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2746 if (TYPE_OK (intSI_type_node))
2747 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2748 if (TYPE_OK (intHI_type_node))
2749 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2750 if (TYPE_OK (intQI_type_node))
2751 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2754 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2757 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2760 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2762 /* Extended integer types of the same width as a standard type have
2763 lesser rank, so those of the same width as int promote to int or
2764 unsigned int and are valid for printf formats expecting int or
2765 unsigned int. To avoid such special cases, avoid creating
2766 extended integer types for bit-fields if a standard integer type
2768 if (width == TYPE_PRECISION (integer_type_node))
2769 return unsignedp ? unsigned_type_node : integer_type_node;
2770 if (width == TYPE_PRECISION (signed_char_type_node))
2771 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2772 if (width == TYPE_PRECISION (short_integer_type_node))
2773 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2774 if (width == TYPE_PRECISION (long_integer_type_node))
2775 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2776 if (width == TYPE_PRECISION (long_long_integer_type_node))
2777 return (unsignedp ? long_long_unsigned_type_node
2778 : long_long_integer_type_node);
2779 return build_nonstandard_integer_type (width, unsignedp);
2782 /* The C version of the register_builtin_type langhook. */
2785 c_register_builtin_type (tree type, const char* name)
2789 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2790 DECL_ARTIFICIAL (decl) = 1;
2791 if (!TYPE_NAME (type))
2792 TYPE_NAME (type) = decl;
2795 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2798 /* Print an error message for invalid operands to arith operation
2799 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
2800 LOCATION is the location of the message. */
2803 binary_op_error (location_t location, enum tree_code code,
2804 tree type0, tree type1)
2811 opname = "+"; break;
2813 opname = "-"; break;
2815 opname = "*"; break;
2817 opname = "max"; break;
2819 opname = "min"; break;
2821 opname = "=="; break;
2823 opname = "!="; break;
2825 opname = "<="; break;
2827 opname = ">="; break;
2829 opname = "<"; break;
2831 opname = ">"; break;
2833 opname = "<<"; break;
2835 opname = ">>"; break;
2836 case TRUNC_MOD_EXPR:
2837 case FLOOR_MOD_EXPR:
2838 opname = "%"; break;
2839 case TRUNC_DIV_EXPR:
2840 case FLOOR_DIV_EXPR:
2841 opname = "/"; break;
2843 opname = "&"; break;
2845 opname = "|"; break;
2846 case TRUTH_ANDIF_EXPR:
2847 opname = "&&"; break;
2848 case TRUTH_ORIF_EXPR:
2849 opname = "||"; break;
2851 opname = "^"; break;
2856 "invalid operands to binary %s (have %qT and %qT)", opname,
2860 /* Subroutine of build_binary_op, used for comparison operations.
2861 See if the operands have both been converted from subword integer types
2862 and, if so, perhaps change them both back to their original type.
2863 This function is also responsible for converting the two operands
2864 to the proper common type for comparison.
2866 The arguments of this function are all pointers to local variables
2867 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2868 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2870 If this function returns nonzero, it means that the comparison has
2871 a constant value. What this function returns is an expression for
2875 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2876 enum tree_code *rescode_ptr)
2879 tree op0 = *op0_ptr;
2880 tree op1 = *op1_ptr;
2881 int unsignedp0, unsignedp1;
2883 tree primop0, primop1;
2884 enum tree_code code = *rescode_ptr;
2886 /* Throw away any conversions to wider types
2887 already present in the operands. */
2889 primop0 = get_narrower (op0, &unsignedp0);
2890 primop1 = get_narrower (op1, &unsignedp1);
2892 /* Handle the case that OP0 does not *contain* a conversion
2893 but it *requires* conversion to FINAL_TYPE. */
2895 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2896 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2897 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2898 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2900 /* If one of the operands must be floated, we cannot optimize. */
2901 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2902 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2904 /* If first arg is constant, swap the args (changing operation
2905 so value is preserved), for canonicalization. Don't do this if
2906 the second arg is 0. */
2908 if (TREE_CONSTANT (primop0)
2909 && !integer_zerop (primop1) && !real_zerop (primop1)
2910 && !fixed_zerop (primop1))
2913 int temi = unsignedp0;
2921 unsignedp0 = unsignedp1;
2944 *rescode_ptr = code;
2947 /* If comparing an integer against a constant more bits wide,
2948 maybe we can deduce a value of 1 or 0 independent of the data.
2949 Or else truncate the constant now
2950 rather than extend the variable at run time.
2952 This is only interesting if the constant is the wider arg.
2953 Also, it is not safe if the constant is unsigned and the
2954 variable arg is signed, since in this case the variable
2955 would be sign-extended and then regarded as unsigned.
2956 Our technique fails in this case because the lowest/highest
2957 possible unsigned results don't follow naturally from the
2958 lowest/highest possible values of the variable operand.
2959 For just EQ_EXPR and NE_EXPR there is another technique that
2960 could be used: see if the constant can be faithfully represented
2961 in the other operand's type, by truncating it and reextending it
2962 and see if that preserves the constant's value. */
2964 if (!real1 && !real2
2965 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
2966 && TREE_CODE (primop1) == INTEGER_CST
2967 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2969 int min_gt, max_gt, min_lt, max_lt;
2970 tree maxval, minval;
2971 /* 1 if comparison is nominally unsigned. */
2972 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2975 type = c_common_signed_or_unsigned_type (unsignedp0,
2976 TREE_TYPE (primop0));
2978 maxval = TYPE_MAX_VALUE (type);
2979 minval = TYPE_MIN_VALUE (type);
2981 if (unsignedp && !unsignedp0)
2982 *restype_ptr = c_common_signed_type (*restype_ptr);
2984 if (TREE_TYPE (primop1) != *restype_ptr)
2986 /* Convert primop1 to target type, but do not introduce
2987 additional overflow. We know primop1 is an int_cst. */
2988 primop1 = force_fit_type_double (*restype_ptr,
2989 TREE_INT_CST_LOW (primop1),
2990 TREE_INT_CST_HIGH (primop1), 0,
2991 TREE_OVERFLOW (primop1));
2993 if (type != *restype_ptr)
2995 minval = convert (*restype_ptr, minval);
2996 maxval = convert (*restype_ptr, maxval);
2999 if (unsignedp && unsignedp0)
3001 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3002 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3003 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3004 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3008 min_gt = INT_CST_LT (primop1, minval);
3009 max_gt = INT_CST_LT (primop1, maxval);
3010 min_lt = INT_CST_LT (minval, primop1);
3011 max_lt = INT_CST_LT (maxval, primop1);
3015 /* This used to be a switch, but Genix compiler can't handle that. */
3016 if (code == NE_EXPR)
3018 if (max_lt || min_gt)
3019 val = truthvalue_true_node;
3021 else if (code == EQ_EXPR)
3023 if (max_lt || min_gt)
3024 val = truthvalue_false_node;
3026 else if (code == LT_EXPR)
3029 val = truthvalue_true_node;
3031 val = truthvalue_false_node;
3033 else if (code == GT_EXPR)
3036 val = truthvalue_true_node;
3038 val = truthvalue_false_node;
3040 else if (code == LE_EXPR)
3043 val = truthvalue_true_node;
3045 val = truthvalue_false_node;
3047 else if (code == GE_EXPR)
3050 val = truthvalue_true_node;
3052 val = truthvalue_false_node;
3055 /* If primop0 was sign-extended and unsigned comparison specd,
3056 we did a signed comparison above using the signed type bounds.
3057 But the comparison we output must be unsigned.
3059 Also, for inequalities, VAL is no good; but if the signed
3060 comparison had *any* fixed result, it follows that the
3061 unsigned comparison just tests the sign in reverse
3062 (positive values are LE, negative ones GE).
3063 So we can generate an unsigned comparison
3064 against an extreme value of the signed type. */
3066 if (unsignedp && !unsignedp0)
3073 primop1 = TYPE_MIN_VALUE (type);
3079 primop1 = TYPE_MAX_VALUE (type);
3086 type = c_common_unsigned_type (type);
3089 if (TREE_CODE (primop0) != INTEGER_CST)
3091 if (val == truthvalue_false_node)
3092 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3093 if (val == truthvalue_true_node)
3094 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3099 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3100 if (TREE_SIDE_EFFECTS (primop0))
3101 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3105 /* Value is not predetermined, but do the comparison
3106 in the type of the operand that is not constant.
3107 TYPE is already properly set. */
3110 /* If either arg is decimal float and the other is float, find the
3111 proper common type to use for comparison. */
3112 else if (real1 && real2
3113 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3114 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3115 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3117 else if (real1 && real2
3118 && (TYPE_PRECISION (TREE_TYPE (primop0))
3119 == TYPE_PRECISION (TREE_TYPE (primop1))))
3120 type = TREE_TYPE (primop0);
3122 /* If args' natural types are both narrower than nominal type
3123 and both extend in the same manner, compare them
3124 in the type of the wider arg.
3125 Otherwise must actually extend both to the nominal
3126 common type lest different ways of extending
3128 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3130 else if (unsignedp0 == unsignedp1 && real1 == real2
3131 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3132 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3134 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3135 type = c_common_signed_or_unsigned_type (unsignedp0
3136 || TYPE_UNSIGNED (*restype_ptr),
3138 /* Make sure shorter operand is extended the right way
3139 to match the longer operand. */
3141 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3142 TREE_TYPE (primop0)),
3145 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3146 TREE_TYPE (primop1)),
3151 /* Here we must do the comparison on the nominal type
3152 using the args exactly as we received them. */
3153 type = *restype_ptr;
3157 if (!real1 && !real2 && integer_zerop (primop1)
3158 && TYPE_UNSIGNED (*restype_ptr))
3164 /* All unsigned values are >= 0, so we warn. However,
3165 if OP0 is a constant that is >= 0, the signedness of
3166 the comparison isn't an issue, so suppress the
3168 if (warn_type_limits && !in_system_header
3169 && !(TREE_CODE (primop0) == INTEGER_CST
3170 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3172 warning (OPT_Wtype_limits,
3173 "comparison of unsigned expression >= 0 is always true");
3174 value = truthvalue_true_node;
3178 if (warn_type_limits && !in_system_header
3179 && !(TREE_CODE (primop0) == INTEGER_CST
3180 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3182 warning (OPT_Wtype_limits,
3183 "comparison of unsigned expression < 0 is always false");
3184 value = truthvalue_false_node;
3193 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3194 if (TREE_SIDE_EFFECTS (primop0))
3195 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3202 *op0_ptr = convert (type, primop0);
3203 *op1_ptr = convert (type, primop1);
3205 *restype_ptr = truthvalue_type_node;
3210 /* Return a tree for the sum or difference (RESULTCODE says which)
3211 of pointer PTROP and integer INTOP. */
3214 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3218 /* The result is a pointer of the same type that is being added. */
3219 tree result_type = TREE_TYPE (ptrop);
3221 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3223 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3224 "pointer of type %<void *%> used in arithmetic");
3225 size_exp = integer_one_node;
3227 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3229 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3230 "pointer to a function used in arithmetic");
3231 size_exp = integer_one_node;
3233 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3235 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3236 "pointer to member function used in arithmetic");
3237 size_exp = integer_one_node;
3240 size_exp = size_in_bytes (TREE_TYPE (result_type));
3242 /* We are manipulating pointer values, so we don't need to warn
3243 about relying on undefined signed overflow. We disable the
3244 warning here because we use integer types so fold won't know that
3245 they are really pointers. */
3246 fold_defer_overflow_warnings ();
3248 /* If what we are about to multiply by the size of the elements
3249 contains a constant term, apply distributive law
3250 and multiply that constant term separately.
3251 This helps produce common subexpressions. */
3252 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3253 && !TREE_CONSTANT (intop)
3254 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3255 && TREE_CONSTANT (size_exp)
3256 /* If the constant comes from pointer subtraction,
3257 skip this optimization--it would cause an error. */
3258 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3259 /* If the constant is unsigned, and smaller than the pointer size,
3260 then we must skip this optimization. This is because it could cause
3261 an overflow error if the constant is negative but INTOP is not. */
3262 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3263 || (TYPE_PRECISION (TREE_TYPE (intop))
3264 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3266 enum tree_code subcode = resultcode;
3267 tree int_type = TREE_TYPE (intop);
3268 if (TREE_CODE (intop) == MINUS_EXPR)
3269 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3270 /* Convert both subexpression types to the type of intop,
3271 because weird cases involving pointer arithmetic
3272 can result in a sum or difference with different type args. */
3273 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3275 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3276 intop = convert (int_type, TREE_OPERAND (intop, 0));
3279 /* Convert the integer argument to a type the same size as sizetype
3280 so the multiply won't overflow spuriously. */
3281 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3282 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3283 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3284 TYPE_UNSIGNED (sizetype)), intop);
3286 /* Replace the integer argument with a suitable product by the object size.
3287 Do this multiplication as signed, then convert to the appropriate
3288 type for the pointer operation. */
3289 intop = convert (sizetype,
3290 build_binary_op (EXPR_LOCATION (intop),
3292 convert (TREE_TYPE (intop), size_exp), 1));
3294 /* Create the sum or difference. */
3295 if (resultcode == MINUS_EXPR)
3296 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3298 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3300 fold_undefer_and_ignore_overflow_warnings ();
3305 /* Return whether EXPR is a declaration whose address can never be
3309 decl_with_nonnull_addr_p (const_tree expr)
3311 return (DECL_P (expr)
3312 && (TREE_CODE (expr) == PARM_DECL
3313 || TREE_CODE (expr) == LABEL_DECL
3314 || !DECL_WEAK (expr)));
3317 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3318 or for an `if' or `while' statement or ?..: exp. It should already
3319 have been validated to be of suitable type; otherwise, a bad
3320 diagnostic may result.
3322 The EXPR is located at LOCATION.
3324 This preparation consists of taking the ordinary
3325 representation of an expression expr and producing a valid tree
3326 boolean expression describing whether expr is nonzero. We could
3327 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3328 but we optimize comparisons, &&, ||, and !.
3330 The resulting type should always be `truthvalue_type_node'. */
3333 c_common_truthvalue_conversion (location_t location, tree expr)
3335 switch (TREE_CODE (expr))
3337 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
3338 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3339 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3340 case ORDERED_EXPR: case UNORDERED_EXPR:
3341 if (TREE_TYPE (expr) == truthvalue_type_node)
3343 return build2 (TREE_CODE (expr), truthvalue_type_node,
3344 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3346 case TRUTH_ANDIF_EXPR:
3347 case TRUTH_ORIF_EXPR:
3348 case TRUTH_AND_EXPR:
3350 case TRUTH_XOR_EXPR:
3351 if (TREE_TYPE (expr) == truthvalue_type_node)
3353 return build2 (TREE_CODE (expr), truthvalue_type_node,
3354 c_common_truthvalue_conversion (location,
3355 TREE_OPERAND (expr, 0)),
3356 c_common_truthvalue_conversion (location,
3357 TREE_OPERAND (expr, 1)));
3359 case TRUTH_NOT_EXPR:
3360 if (TREE_TYPE (expr) == truthvalue_type_node)
3362 return build1 (TREE_CODE (expr), truthvalue_type_node,
3363 c_common_truthvalue_conversion (location,
3364 TREE_OPERAND (expr, 0)));
3370 return integer_zerop (expr) ? truthvalue_false_node
3371 : truthvalue_true_node;
3374 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3375 ? truthvalue_true_node
3376 : truthvalue_false_node;
3379 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3380 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3381 ? truthvalue_true_node
3382 : truthvalue_false_node;
3385 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3390 tree inner = TREE_OPERAND (expr, 0);
3391 if (decl_with_nonnull_addr_p (inner))
3393 /* Common Ada/Pascal programmer's mistake. */
3394 warning_at (location,
3396 "the address of %qD will always evaluate as %<true%>",
3398 return truthvalue_true_node;
3404 return build_binary_op (EXPR_LOCATION (expr),
3405 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3406 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3407 c_common_truthvalue_conversion (location,
3408 TREE_OPERAND (expr, 0)),
3409 c_common_truthvalue_conversion (location,
3410 TREE_OPERAND (expr, 1)),
3416 /* These don't change whether an object is nonzero or zero. */
3417 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
3421 /* These don't change whether an object is zero or nonzero, but
3422 we can't ignore them if their second arg has side-effects. */
3423 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3424 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3425 TREE_OPERAND (expr, 1),
3426 c_common_truthvalue_conversion
3427 (location, TREE_OPERAND (expr, 0)));
3429 return c_common_truthvalue_conversion (location,
3430 TREE_OPERAND (expr, 0));
3433 /* Distribute the conversion into the arms of a COND_EXPR. */
3434 return fold_build3 (COND_EXPR, truthvalue_type_node,
3435 TREE_OPERAND (expr, 0),
3436 c_common_truthvalue_conversion (location,
3437 TREE_OPERAND (expr, 1)),
3438 c_common_truthvalue_conversion (location,
3439 TREE_OPERAND (expr, 2)));
3442 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3443 since that affects how `default_conversion' will behave. */
3444 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3445 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3447 /* If this is widening the argument, we can ignore it. */
3448 if (TYPE_PRECISION (TREE_TYPE (expr))
3449 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3450 return c_common_truthvalue_conversion (location,
3451 TREE_OPERAND (expr, 0));
3455 if (!TREE_NO_WARNING (expr)
3456 && warn_parentheses)
3458 warning (OPT_Wparentheses,
3459 "suggest parentheses around assignment used as truth value");
3460 TREE_NO_WARNING (expr) = 1;
3468 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3470 tree t = save_expr (expr);
3471 return (build_binary_op
3472 (EXPR_LOCATION (expr),
3473 (TREE_SIDE_EFFECTS (expr)
3474 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3475 c_common_truthvalue_conversion
3477 build_unary_op (location, REALPART_EXPR, t, 0)),
3478 c_common_truthvalue_conversion
3480 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3484 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3486 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3488 (TREE_TYPE (expr))));
3489 return build_binary_op (EXPR_LOCATION (expr),
3490 NE_EXPR, expr, fixed_zero_node, 1);
3493 return build_binary_op (EXPR_LOCATION (expr),
3494 NE_EXPR, expr, integer_zero_node, 1);
3497 static void def_builtin_1 (enum built_in_function fncode,
3499 enum built_in_class fnclass,
3500 tree fntype, tree libtype,
3501 bool both_p, bool fallback_p, bool nonansi_p,
3502 tree fnattrs, bool implicit_p);
3505 /* Apply the TYPE_QUALS to the new DECL. */
3508 c_apply_type_quals_to_decl (int type_quals, tree decl)
3510 tree type = TREE_TYPE (decl);
3512 if (type == error_mark_node)
3515 if (((type_quals & TYPE_QUAL_CONST)
3516 || (type && TREE_CODE (type) == REFERENCE_TYPE))
3517 /* An object declared 'const' is only readonly after it is
3518 initialized. We don't have any way of expressing this currently,
3519 so we need to be conservative and unset TREE_READONLY for types
3520 with constructors. Otherwise aliasing code will ignore stores in
3521 an inline constructor. */
3522 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3523 TREE_READONLY (decl) = 1;
3524 if (type_quals & TYPE_QUAL_VOLATILE)
3526 TREE_SIDE_EFFECTS (decl) = 1;
3527 TREE_THIS_VOLATILE (decl) = 1;
3529 if (type_quals & TYPE_QUAL_RESTRICT)
3531 while (type && TREE_CODE (type) == ARRAY_TYPE)
3532 /* Allow 'restrict' on arrays of pointers.
3533 FIXME currently we just ignore it. */
3534 type = TREE_TYPE (type);
3536 || !POINTER_TYPE_P (type)
3537 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3538 error ("invalid use of %<restrict%>");
3539 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3540 /* Indicate we need to make a unique alias set for this pointer.
3541 We can't do it here because it might be pointing to an
3543 DECL_POINTER_ALIAS_SET (decl) = -2;
3547 /* Hash function for the problem of multiple type definitions in
3548 different files. This must hash all types that will compare
3549 equal via comptypes to the same value. In practice it hashes
3550 on some of the simple stuff and leaves the details to comptypes. */
3553 c_type_hash (const void *p)
3557 const_tree const t = (const_tree) p;
3559 switch (TREE_CODE (t))
3561 /* For pointers, hash on pointee type plus some swizzling. */
3563 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3564 /* Hash on number of elements and total size. */
3567 t2 = TYPE_VALUES (t);
3571 t2 = TYPE_FIELDS (t);
3573 case QUAL_UNION_TYPE:
3575 t2 = TYPE_FIELDS (t);
3579 t2 = TYPE_FIELDS (t);
3584 for (; t2; t2 = TREE_CHAIN (t2))
3586 /* We might have a VLA here. */
3587 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
3590 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3591 return ((size << 24) | (i << shift));
3594 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3596 /* Return the typed-based alias set for T, which may be an expression
3597 or a type. Return -1 if we don't do anything special. */
3600 c_common_get_alias_set (tree t)
3605 /* Permit type-punning when accessing a union, provided the access
3606 is directly through the union. For example, this code does not
3607 permit taking the address of a union member and then storing
3608 through it. Even the type-punning allowed here is a GCC
3609 extension, albeit a common and useful one; the C standard says
3610 that such accesses have implementation-defined behavior. */
3612 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3613 u = TREE_OPERAND (u, 0))
3614 if (TREE_CODE (u) == COMPONENT_REF
3615 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3618 /* That's all the expressions we handle specially. */
3622 /* The C standard guarantees that any object may be accessed via an
3623 lvalue that has character type. */
3624 if (t == char_type_node
3625 || t == signed_char_type_node
3626 || t == unsigned_char_type_node)
3629 /* The C standard specifically allows aliasing between signed and
3630 unsigned variants of the same type. We treat the signed
3631 variant as canonical. */
3632 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3634 tree t1 = c_common_signed_type (t);
3636 /* t1 == t can happen for boolean nodes which are always unsigned. */
3638 return get_alias_set (t1);
3640 else if (POINTER_TYPE_P (t))
3644 /* Unfortunately, there is no canonical form of a pointer type.
3645 In particular, if we have `typedef int I', then `int *', and
3646 `I *' are different types. So, we have to pick a canonical
3647 representative. We do this below.
3649 Technically, this approach is actually more conservative that
3650 it needs to be. In particular, `const int *' and `int *'
3651 should be in different alias sets, according to the C and C++
3652 standard, since their types are not the same, and so,
3653 technically, an `int **' and `const int **' cannot point at
3656 But, the standard is wrong. In particular, this code is
3661 const int* const* cipp = ipp;
3663 And, it doesn't make sense for that to be legal unless you
3664 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3665 the pointed-to types. This issue has been reported to the
3667 t1 = build_type_no_quals (t);
3669 return get_alias_set (t1);
3672 /* Handle the case of multiple type nodes referring to "the same" type,
3673 which occurs with IMA. These share an alias set. FIXME: Currently only
3674 C90 is handled. (In C99 type compatibility is not transitive, which
3675 complicates things mightily. The alias set splay trees can theoretically
3676 represent this, but insertion is tricky when you consider all the
3677 different orders things might arrive in.) */
3679 if (c_language != clk_c || flag_isoc99)
3682 /* Save time if there's only one input file. */
3683 if (num_in_fnames == 1)
3686 /* Pointers need special handling if they point to any type that
3687 needs special handling (below). */
3688 if (TREE_CODE (t) == POINTER_TYPE)
3691 /* Find bottom type under any nested POINTERs. */
3692 for (t2 = TREE_TYPE (t);
3693 TREE_CODE (t2) == POINTER_TYPE;
3694 t2 = TREE_TYPE (t2))
3696 if (TREE_CODE (t2) != RECORD_TYPE
3697 && TREE_CODE (t2) != ENUMERAL_TYPE
3698 && TREE_CODE (t2) != QUAL_UNION_TYPE
3699 && TREE_CODE (t2) != UNION_TYPE)
3701 if (TYPE_SIZE (t2) == 0)
3704 /* These are the only cases that need special handling. */
3705 if (TREE_CODE (t) != RECORD_TYPE
3706 && TREE_CODE (t) != ENUMERAL_TYPE
3707 && TREE_CODE (t) != QUAL_UNION_TYPE
3708 && TREE_CODE (t) != UNION_TYPE
3709 && TREE_CODE (t) != POINTER_TYPE)
3712 if (TYPE_SIZE (t) == 0)
3715 /* Look up t in hash table. Only one of the compatible types within each
3716 alias set is recorded in the table. */
3717 if (!type_hash_table)
3718 type_hash_table = htab_create_ggc (1021, c_type_hash,
3719 (htab_eq) lang_hooks.types_compatible_p,
3721 slot = htab_find_slot (type_hash_table, t, INSERT);
3724 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3725 return TYPE_ALIAS_SET ((tree)*slot);
3728 /* Our caller will assign and record (in t) a new alias set; all we need
3729 to do is remember t in the hash table. */
3735 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3736 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3737 flag controls whether we should diagnose possibly ill-formed
3738 constructs or not. */
3741 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3743 const char *op_name;
3745 enum tree_code type_code = TREE_CODE (type);
3747 op_name = is_sizeof ? "sizeof" : "__alignof__";
3749 if (type_code == FUNCTION_TYPE)
3753 if (complain && (pedantic || warn_pointer_arith))
3754 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3755 "invalid application of %<sizeof%> to a function type");
3757 return error_mark_node;
3758 value = size_one_node;
3761 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3763 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3765 if (type_code == VOID_TYPE
3766 && complain && (pedantic || warn_pointer_arith))
3767 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3768 "invalid application of %qs to a void type", op_name);
3770 return error_mark_node;
3771 value = size_one_node;
3773 else if (!COMPLETE_TYPE_P (type))
3776 error ("invalid application of %qs to incomplete type %qT ",
3778 value = size_zero_node;
3783 /* Convert in case a char is more than one unit. */
3784 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3785 size_int (TYPE_PRECISION (char_type_node)
3788 value = size_int (TYPE_ALIGN_UNIT (type));
3791 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3792 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3793 never happen. However, this node should really have type
3794 `size_t', which is just a typedef for an ordinary integer type. */
3795 value = fold_convert (size_type_node, value);
3796 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3801 /* Implement the __alignof keyword: Return the minimum required
3802 alignment of EXPR, measured in bytes. For VAR_DECLs,
3803 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3804 from an "aligned" __attribute__ specification). */
3807 c_alignof_expr (tree expr)
3811 if (VAR_OR_FUNCTION_DECL_P (expr))
3812 t = size_int (DECL_ALIGN_UNIT (expr));
3814 else if (TREE_CODE (expr) == COMPONENT_REF
3815 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3817 error ("%<__alignof%> applied to a bit-field");
3820 else if (TREE_CODE (expr) == COMPONENT_REF
3821 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3822 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3824 else if (TREE_CODE (expr) == INDIRECT_REF)
3826 tree t = TREE_OPERAND (expr, 0);
3828 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3830 while (CONVERT_EXPR_P (t)
3831 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3835 t = TREE_OPERAND (t, 0);
3836 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3837 if (thisalign > bestalign)
3838 best = t, bestalign = thisalign;
3840 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3843 return c_alignof (TREE_TYPE (expr));
3845 return fold_convert (size_type_node, t);
3848 /* Handle C and C++ default attributes. */
3850 enum built_in_attribute
3852 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3853 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3854 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3855 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3856 #include "builtin-attrs.def"
3857 #undef DEF_ATTR_NULL_TREE
3859 #undef DEF_ATTR_IDENT
3860 #undef DEF_ATTR_TREE_LIST
3864 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3866 static void c_init_attributes (void);
3870 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3871 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3872 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3873 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3874 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3875 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3876 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3877 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3878 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3879 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3880 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3881 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3882 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3883 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3884 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3886 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3887 #include "builtin-types.def"
3888 #undef DEF_PRIMITIVE_TYPE
3889 #undef DEF_FUNCTION_TYPE_0
3890 #undef DEF_FUNCTION_TYPE_1
3891 #undef DEF_FUNCTION_TYPE_2
3892 #undef DEF_FUNCTION_TYPE_3
3893 #undef DEF_FUNCTION_TYPE_4
3894 #undef DEF_FUNCTION_TYPE_5
3895 #undef DEF_FUNCTION_TYPE_6
3896 #undef DEF_FUNCTION_TYPE_7
3897 #undef DEF_FUNCTION_TYPE_VAR_0
3898 #undef DEF_FUNCTION_TYPE_VAR_1
3899 #undef DEF_FUNCTION_TYPE_VAR_2
3900 #undef DEF_FUNCTION_TYPE_VAR_3
3901 #undef DEF_FUNCTION_TYPE_VAR_4
3902 #undef DEF_FUNCTION_TYPE_VAR_5
3903 #undef DEF_POINTER_TYPE
3907 typedef enum c_builtin_type builtin_type;
3909 /* A temporary array for c_common_nodes_and_builtins. Used in
3910 communication with def_fn_type. */
3911 static tree builtin_types[(int) BT_LAST + 1];
3913 /* A helper function for c_common_nodes_and_builtins. Build function type
3914 for DEF with return type RET and N arguments. If VAR is true, then the
3915 function should be variadic after those N arguments.
3917 Takes special care not to ICE if any of the types involved are
3918 error_mark_node, which indicates that said type is not in fact available
3919 (see builtin_type_for_size). In which case the function type as a whole
3920 should be error_mark_node. */
3923 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3925 tree args = NULL, t;
3930 for (i = 0; i < n; ++i)
3932 builtin_type a = (builtin_type) va_arg (list, int);
3933 t = builtin_types[a];
3934 if (t == error_mark_node)
3936 args = tree_cons (NULL_TREE, t, args);
3940 args = nreverse (args);
3942 args = chainon (args, void_list_node);
3944 t = builtin_types[ret];
3945 if (t == error_mark_node)
3947 t = build_function_type (t, args);
3950 builtin_types[def] = t;
3953 /* Build builtin functions common to both C and C++ language
3957 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3959 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3960 builtin_types[ENUM] = VALUE;
3961 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3962 def_fn_type (ENUM, RETURN, 0, 0);
3963 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3964 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3965 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3966 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3967 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3968 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3969 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3970 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3971 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3972 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3973 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3975 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3976 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3978 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3979 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3980 def_fn_type (ENUM, RETURN, 1, 0);
3981 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3982 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3983 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3984 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3985 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3986 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3987 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3988 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3989 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3990 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3991 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3992 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3994 #include "builtin-types.def"
3996 #undef DEF_PRIMITIVE_TYPE
3997 #undef DEF_FUNCTION_TYPE_1
3998 #undef DEF_FUNCTION_TYPE_2
3999 #undef DEF_FUNCTION_TYPE_3
4000 #undef DEF_FUNCTION_TYPE_4
4001 #undef DEF_FUNCTION_TYPE_5
4002 #undef DEF_FUNCTION_TYPE_6
4003 #undef DEF_FUNCTION_TYPE_VAR_0
4004 #undef DEF_FUNCTION_TYPE_VAR_1
4005 #undef DEF_FUNCTION_TYPE_VAR_2
4006 #undef DEF_FUNCTION_TYPE_VAR_3
4007 #undef DEF_FUNCTION_TYPE_VAR_4
4008 #undef DEF_FUNCTION_TYPE_VAR_5
4009 #undef DEF_POINTER_TYPE
4010 builtin_types[(int) BT_LAST] = NULL_TREE;
4012 c_init_attributes ();
4014 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4015 NONANSI_P, ATTRS, IMPLICIT, COND) \
4017 def_builtin_1 (ENUM, NAME, CLASS, \
4018 builtin_types[(int) TYPE], \
4019 builtin_types[(int) LIBTYPE], \
4020 BOTH_P, FALLBACK_P, NONANSI_P, \
4021 built_in_attributes[(int) ATTRS], IMPLICIT);
4022 #include "builtins.def"
4025 targetm.init_builtins ();
4027 build_common_builtin_nodes ();
4033 /* Build tree nodes and builtin functions common to both C and C++ language
4037 c_common_nodes_and_builtins (void)
4039 int char16_type_size;
4040 int char32_type_size;
4041 int wchar_type_size;
4042 tree array_domain_type;
4043 tree va_list_ref_type_node;
4044 tree va_list_arg_type_node;
4046 /* Define `int' and `char' first so that dbx will output them first. */
4047 record_builtin_type (RID_INT, NULL, integer_type_node);
4048 record_builtin_type (RID_CHAR, "char", char_type_node);
4050 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4051 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4052 but not C. Are the conditionals here needed? */
4053 if (c_dialect_cxx ())
4054 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4055 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4056 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4057 record_builtin_type (RID_MAX, "long unsigned int",
4058 long_unsigned_type_node);
4059 if (c_dialect_cxx ())
4060 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4061 record_builtin_type (RID_MAX, "long long int",
4062 long_long_integer_type_node);
4063 record_builtin_type (RID_MAX, "long long unsigned int",
4064 long_long_unsigned_type_node);
4065 if (c_dialect_cxx ())
4066 record_builtin_type (RID_MAX, "long long unsigned",
4067 long_long_unsigned_type_node);
4068 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4069 record_builtin_type (RID_MAX, "short unsigned int",
4070 short_unsigned_type_node);
4071 if (c_dialect_cxx ())
4072 record_builtin_type (RID_MAX, "unsigned short",
4073 short_unsigned_type_node);
4075 /* Define both `signed char' and `unsigned char'. */
4076 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4077 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4079 /* These are types that c_common_type_for_size and
4080 c_common_type_for_mode use. */
4081 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4083 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4085 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4087 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4089 #if HOST_BITS_PER_WIDE_INT >= 64
4090 if (targetm.scalar_mode_supported_p (TImode))
4091 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4092 get_identifier ("__int128_t"),
4095 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4096 unsigned_intQI_type_node));
4097 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4098 unsigned_intHI_type_node));
4099 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4100 unsigned_intSI_type_node));
4101 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4102 unsigned_intDI_type_node));
4103 #if HOST_BITS_PER_WIDE_INT >= 64
4104 if (targetm.scalar_mode_supported_p (TImode))
4105 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4106 get_identifier ("__uint128_t"),
4107 unsigned_intTI_type_node));
4110 /* Create the widest literal types. */
4111 widest_integer_literal_type_node
4112 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4113 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4114 widest_integer_literal_type_node));
4116 widest_unsigned_literal_type_node
4117 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4118 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4119 widest_unsigned_literal_type_node));
4121 /* `unsigned long' is the standard type for sizeof.
4122 Note that stddef.h uses `unsigned long',
4123 and this must agree, even if long and int are the same size. */
4125 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4126 signed_size_type_node = c_common_signed_type (size_type_node);
4127 set_sizetype (size_type_node);
4130 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4132 build_common_tree_nodes_2 (flag_short_double);
4134 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4135 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4136 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4138 /* Only supported decimal floating point extension if the target
4139 actually supports underlying modes. */
4140 if (targetm.scalar_mode_supported_p (SDmode)
4141 && targetm.scalar_mode_supported_p (DDmode)
4142 && targetm.scalar_mode_supported_p (TDmode))
4144 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4145 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4146 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4149 if (targetm.fixed_point_supported_p ())
4151 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4152 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4153 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4154 record_builtin_type (RID_MAX, "long long _Fract",
4155 long_long_fract_type_node);
4156 record_builtin_type (RID_MAX, "unsigned short _Fract",
4157 unsigned_short_fract_type_node);
4158 record_builtin_type (RID_MAX, "unsigned _Fract",
4159 unsigned_fract_type_node);
4160 record_builtin_type (RID_MAX, "unsigned long _Fract",
4161 unsigned_long_fract_type_node);
4162 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4163 unsigned_long_long_fract_type_node);
4164 record_builtin_type (RID_MAX, "_Sat short _Fract",
4165 sat_short_fract_type_node);
4166 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4167 record_builtin_type (RID_MAX, "_Sat long _Fract",
4168 sat_long_fract_type_node);
4169 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4170 sat_long_long_fract_type_node);
4171 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4172 sat_unsigned_short_fract_type_node);
4173 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4174 sat_unsigned_fract_type_node);
4175 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4176 sat_unsigned_long_fract_type_node);
4177 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4178 sat_unsigned_long_long_fract_type_node);
4179 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4180 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4181 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4182 record_builtin_type (RID_MAX, "long long _Accum",
4183 long_long_accum_type_node);
4184 record_builtin_type (RID_MAX, "unsigned short _Accum",
4185 unsigned_short_accum_type_node);
4186 record_builtin_type (RID_MAX, "unsigned _Accum",
4187 unsigned_accum_type_node);
4188 record_builtin_type (RID_MAX, "unsigned long _Accum",
4189 unsigned_long_accum_type_node);
4190 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4191 unsigned_long_long_accum_type_node);
4192 record_builtin_type (RID_MAX, "_Sat short _Accum",
4193 sat_short_accum_type_node);
4194 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4195 record_builtin_type (RID_MAX, "_Sat long _Accum",
4196 sat_long_accum_type_node);
4197 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4198 sat_long_long_accum_type_node);
4199 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4200 sat_unsigned_short_accum_type_node);
4201 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4202 sat_unsigned_accum_type_node);
4203 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4204 sat_unsigned_long_accum_type_node);
4205 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4206 sat_unsigned_long_long_accum_type_node);
4210 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4211 get_identifier ("complex int"),
4212 complex_integer_type_node));
4213 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4214 get_identifier ("complex float"),
4215 complex_float_type_node));
4216 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4217 get_identifier ("complex double"),
4218 complex_double_type_node));
4219 lang_hooks.decls.pushdecl
4220 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4221 complex_long_double_type_node));
4223 if (c_dialect_cxx ())
4224 /* For C++, make fileptr_type_node a distinct void * type until
4225 FILE type is defined. */
4226 fileptr_type_node = build_variant_type_copy (ptr_type_node);
4228 record_builtin_type (RID_VOID, NULL, void_type_node);
4230 /* Set the TYPE_NAME for any variants that were built before
4231 record_builtin_type gave names to the built-in types. */
4233 tree void_name = TYPE_NAME (void_type_node);
4234 TYPE_NAME (void_type_node) = NULL_TREE;
4235 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4237 TYPE_NAME (void_type_node) = void_name;
4240 /* This node must not be shared. */
4241 void_zero_node = make_node (INTEGER_CST);
4242 TREE_TYPE (void_zero_node) = void_type_node;
4244 void_list_node = build_void_list_node ();
4246 /* Make a type to be the domain of a few array types
4247 whose domains don't really matter.
4248 200 is small enough that it always fits in size_t
4249 and large enough that it can hold most function names for the
4250 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4251 array_domain_type = build_index_type (size_int (200));
4253 /* Make a type for arrays of characters.
4254 With luck nothing will ever really depend on the length of this
4256 char_array_type_node
4257 = build_array_type (char_type_node, array_domain_type);
4259 /* Likewise for arrays of ints. */
4261 = build_array_type (integer_type_node, array_domain_type);
4263 string_type_node = build_pointer_type (char_type_node);
4264 const_string_type_node
4265 = build_pointer_type (build_qualified_type
4266 (char_type_node, TYPE_QUAL_CONST));
4268 /* This is special for C++ so functions can be overloaded. */
4269 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4270 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4271 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4272 if (c_dialect_cxx ())
4274 if (TYPE_UNSIGNED (wchar_type_node))
4275 wchar_type_node = make_unsigned_type (wchar_type_size);
4277 wchar_type_node = make_signed_type (wchar_type_size);
4278 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4282 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
4283 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
4286 /* This is for wide string constants. */
4287 wchar_array_type_node
4288 = build_array_type (wchar_type_node, array_domain_type);
4290 /* Define 'char16_t'. */
4291 char16_type_node = get_identifier (CHAR16_TYPE);
4292 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4293 char16_type_size = TYPE_PRECISION (char16_type_node);
4294 if (c_dialect_cxx ())
4296 char16_type_node = make_unsigned_type (char16_type_size);
4298 if (cxx_dialect == cxx0x)
4299 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4302 /* This is for UTF-16 string constants. */
4303 char16_array_type_node
4304 = build_array_type (char16_type_node, array_domain_type);
4306 /* Define 'char32_t'. */
4307 char32_type_node = get_identifier (CHAR32_TYPE);
4308 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4309 char32_type_size = TYPE_PRECISION (char32_type_node);
4310 if (c_dialect_cxx ())
4312 char32_type_node = make_unsigned_type (char32_type_size);
4314 if (cxx_dialect == cxx0x)
4315 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4318 /* This is for UTF-32 string constants. */
4319 char32_array_type_node
4320 = build_array_type (char32_type_node, array_domain_type);
4323 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4326 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4328 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4330 default_function_type = build_function_type (integer_type_node, NULL_TREE);
4332 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
4333 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
4335 lang_hooks.decls.pushdecl
4336 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
4337 va_list_type_node));
4338 #ifdef TARGET_ENUM_VA_LIST
4343 for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
4345 lang_hooks.decls.pushdecl
4346 (build_decl (TYPE_DECL, get_identifier (pname),
4353 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4355 va_list_arg_type_node = va_list_ref_type_node =
4356 build_pointer_type (TREE_TYPE (va_list_type_node));
4360 va_list_arg_type_node = va_list_type_node;
4361 va_list_ref_type_node = build_reference_type (va_list_type_node);
4364 if (!flag_preprocess_only)
4365 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4367 main_identifier_node = get_identifier ("main");
4369 /* Create the built-in __null node. It is important that this is
4371 null_node = make_node (INTEGER_CST);
4372 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
4374 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4375 memset (builtin_types, 0, sizeof (builtin_types));
4378 /* Look up the function in built_in_decls that corresponds to DECL
4379 and set ASMSPEC as its user assembler name. DECL must be a
4380 function decl that declares a builtin. */
4383 set_builtin_user_assembler_name (tree decl, const char *asmspec)
4386 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
4387 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
4390 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
4391 set_user_assembler_name (builtin, asmspec);
4392 switch (DECL_FUNCTION_CODE (decl))
4394 case BUILT_IN_MEMCPY:
4395 init_block_move_fn (asmspec);
4396 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
4398 case BUILT_IN_MEMSET:
4399 init_block_clear_fn (asmspec);
4400 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
4402 case BUILT_IN_MEMMOVE:
4403 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
4405 case BUILT_IN_MEMCMP:
4406 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
4408 case BUILT_IN_ABORT:
4409 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
4416 /* The number of named compound-literals generated thus far. */
4417 static GTY(()) int compound_literal_number;
4419 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4422 set_compound_literal_name (tree decl)
4425 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4426 compound_literal_number);
4427 compound_literal_number++;
4428 DECL_NAME (decl) = get_identifier (name);
4432 build_va_arg (tree expr, tree type)
4434 return build1 (VA_ARG_EXPR, type, expr);
4438 /* Linked list of disabled built-in functions. */
4440 typedef struct disabled_builtin
4443 struct disabled_builtin *next;
4445 static disabled_builtin *disabled_builtins = NULL;
4447 static bool builtin_function_disabled_p (const char *);
4449 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4450 begins with "__builtin_", give an error. */
4453 disable_builtin_function (const char *name)
4455 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4456 error ("cannot disable built-in function %qs", name);
4459 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4460 new_disabled_builtin->name = name;
4461 new_disabled_builtin->next = disabled_builtins;
4462 disabled_builtins = new_disabled_builtin;
4467 /* Return true if the built-in function NAME has been disabled, false
4471 builtin_function_disabled_p (const char *name)
4473 disabled_builtin *p;
4474 for (p = disabled_builtins; p != NULL; p = p->next)
4476 if (strcmp (name, p->name) == 0)
4483 /* Worker for DEF_BUILTIN.
4484 Possibly define a builtin function with one or two names.
4485 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4486 nonansi_p and flag_no_nonansi_builtin. */
4489 def_builtin_1 (enum built_in_function fncode,
4491 enum built_in_class fnclass,
4492 tree fntype, tree libtype,
4493 bool both_p, bool fallback_p, bool nonansi_p,
4494 tree fnattrs, bool implicit_p)
4497 const char *libname;
4499 if (fntype == error_mark_node)
4502 gcc_assert ((!both_p && !fallback_p)
4503 || !strncmp (name, "__builtin_",
4504 strlen ("__builtin_")));
4506 libname = name + strlen ("__builtin_");
4507 decl = add_builtin_function (name, fntype, fncode, fnclass,
4508 (fallback_p ? libname : NULL),
4511 && !flag_no_builtin && !builtin_function_disabled_p (libname)
4512 && !(nonansi_p && flag_no_nonansi_builtin))
4513 add_builtin_function (libname, libtype, fncode, fnclass,
4516 built_in_decls[(int) fncode] = decl;
4518 implicit_built_in_decls[(int) fncode] = decl;
4521 /* Nonzero if the type T promotes to int. This is (nearly) the
4522 integral promotions defined in ISO C99 6.3.1.1/2. */
4525 c_promoting_integer_type_p (const_tree t)
4527 switch (TREE_CODE (t))
4530 return (TYPE_MAIN_VARIANT (t) == char_type_node
4531 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
4532 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
4533 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
4534 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
4535 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
4538 /* ??? Technically all enumerations not larger than an int
4539 promote to an int. But this is used along code paths
4540 that only want to notice a size change. */
4541 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
4551 /* Return 1 if PARMS specifies a fixed number of parameters
4552 and none of their types is affected by default promotions. */
4555 self_promoting_args_p (const_tree parms)
4558 for (t = parms; t; t = TREE_CHAIN (t))
4560 tree type = TREE_VALUE (t);
4562 if (type == error_mark_node)
4565 if (TREE_CHAIN (t) == 0 && type != void_type_node)
4571 if (TYPE_MAIN_VARIANT (type) == float_type_node)
4574 if (c_promoting_integer_type_p (type))
4580 /* Recursively remove any '*' or '&' operator from TYPE. */
4582 strip_pointer_operator (tree t)
4584 while (POINTER_TYPE_P (t))
4589 /* Recursively remove pointer or array type from TYPE. */
4591 strip_pointer_or_array_types (tree t)
4593 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
4598 /* Used to compare case labels. K1 and K2 are actually tree nodes
4599 representing case labels, or NULL_TREE for a `default' label.
4600 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4601 K2, and 0 if K1 and K2 are equal. */
4604 case_compare (splay_tree_key k1, splay_tree_key k2)
4606 /* Consider a NULL key (such as arises with a `default' label) to be
4607 smaller than anything else. */
4613 return tree_int_cst_compare ((tree) k1, (tree) k2);
4616 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4617 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4618 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4619 case label was declared using the usual C/C++ syntax, rather than
4620 the GNU case range extension. CASES is a tree containing all the
4621 case ranges processed so far; COND is the condition for the
4622 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
4623 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
4626 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
4627 tree low_value, tree high_value)
4632 splay_tree_node node;
4634 /* Create the LABEL_DECL itself. */
4635 label = create_artificial_label ();
4637 /* If there was an error processing the switch condition, bail now
4638 before we get more confused. */
4639 if (!cond || cond == error_mark_node)
4642 if ((low_value && TREE_TYPE (low_value)
4643 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4644 || (high_value && TREE_TYPE (high_value)
4645 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4647 error ("pointers are not permitted as case values");
4651 /* Case ranges are a GNU extension. */
4653 pedwarn (input_location, OPT_pedantic,
4654 "range expressions in switch statements are non-standard");
4656 type = TREE_TYPE (cond);
4659 low_value = check_case_value (low_value);
4660 low_value = convert_and_check (type, low_value);
4661 if (low_value == error_mark_node)
4666 high_value = check_case_value (high_value);
4667 high_value = convert_and_check (type, high_value);
4668 if (high_value == error_mark_node)
4672 if (low_value && high_value)
4674 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4675 really a case range, even though it was written that way.
4676 Remove the HIGH_VALUE to simplify later processing. */
4677 if (tree_int_cst_equal (low_value, high_value))
4678 high_value = NULL_TREE;
4679 else if (!tree_int_cst_lt (low_value, high_value))
4680 warning (0, "empty range specified");
4683 /* See if the case is in range of the type of the original testing
4684 expression. If both low_value and high_value are out of range,
4685 don't insert the case label and return NULL_TREE. */
4687 && !check_case_bounds (type, orig_type,
4688 &low_value, high_value ? &high_value : NULL))
4691 /* Look up the LOW_VALUE in the table of case labels we already
4693 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4694 /* If there was not an exact match, check for overlapping ranges.
4695 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4696 that's a `default' label and the only overlap is an exact match. */
4697 if (!node && (low_value || high_value))
4699 splay_tree_node low_bound;
4700 splay_tree_node high_bound;
4702 /* Even though there wasn't an exact match, there might be an
4703 overlap between this case range and another case range.
4704 Since we've (inductively) not allowed any overlapping case
4705 ranges, we simply need to find the greatest low case label
4706 that is smaller that LOW_VALUE, and the smallest low case
4707 label that is greater than LOW_VALUE. If there is an overlap
4708 it will occur in one of these two ranges. */
4709 low_bound = splay_tree_predecessor (cases,
4710 (splay_tree_key) low_value);
4711 high_bound = splay_tree_successor (cases,
4712 (splay_tree_key) low_value);
4714 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4715 the LOW_VALUE, so there is no need to check unless the
4716 LOW_BOUND is in fact itself a case range. */
4718 && CASE_HIGH ((tree) low_bound->value)
4719 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4722 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4723 range is bigger than the low end of the current range, so we
4724 are only interested if the current range is a real range, and
4725 not an ordinary case label. */
4728 && (tree_int_cst_compare ((tree) high_bound->key,
4733 /* If there was an overlap, issue an error. */
4736 tree duplicate = CASE_LABEL ((tree) node->value);
4740 error ("duplicate (or overlapping) case value");
4741 error ("%Jthis is the first entry overlapping that value", duplicate);
4745 error ("duplicate case value") ;
4746 error ("%Jpreviously used here", duplicate);
4750 error ("multiple default labels in one switch");
4751 error ("%Jthis is the first default label", duplicate);
4756 /* Add a CASE_LABEL to the statement-tree. */
4757 case_label = add_stmt (build_case_label (low_value, high_value, label));
4758 /* Register this case label in the splay tree. */
4759 splay_tree_insert (cases,
4760 (splay_tree_key) low_value,
4761 (splay_tree_value) case_label);
4766 /* Add a label so that the back-end doesn't think that the beginning of
4767 the switch is unreachable. Note that we do not add a case label, as
4768 that just leads to duplicates and thence to failure later on. */
4771 tree t = create_artificial_label ();
4772 add_stmt (build_stmt (LABEL_EXPR, t));
4774 return error_mark_node;
4777 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4778 Used to verify that case values match up with enumerator values. */
4781 match_case_to_enum_1 (tree key, tree type, tree label)
4783 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4785 /* ??? Not working too hard to print the double-word value.
4786 Should perhaps be done with %lwd in the diagnostic routines? */
4787 if (TREE_INT_CST_HIGH (key) == 0)
4788 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4789 TREE_INT_CST_LOW (key));
4790 else if (!TYPE_UNSIGNED (type)
4791 && TREE_INT_CST_HIGH (key) == -1
4792 && TREE_INT_CST_LOW (key) != 0)
4793 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4794 -TREE_INT_CST_LOW (key));
4796 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4797 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
4798 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
4800 if (TYPE_NAME (type) == 0)
4801 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4802 "%Jcase value %qs not in enumerated type",
4803 CASE_LABEL (label), buf);
4805 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4806 "%Jcase value %qs not in enumerated type %qT",
4807 CASE_LABEL (label), buf, type);
4810 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4811 Used to verify that case values match up with enumerator values. */
4814 match_case_to_enum (splay_tree_node node, void *data)
4816 tree label = (tree) node->value;
4817 tree type = (tree) data;
4819 /* Skip default case. */
4820 if (!CASE_LOW (label))
4823 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4824 when we did our enum->case scan. Reset our scratch bit after. */
4825 if (!CASE_LOW_SEEN (label))
4826 match_case_to_enum_1 (CASE_LOW (label), type, label);
4828 CASE_LOW_SEEN (label) = 0;
4830 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4831 not set, that means that CASE_HIGH did not appear when we did our
4832 enum->case scan. Reset our scratch bit after. */
4833 if (CASE_HIGH (label))
4835 if (!CASE_HIGH_SEEN (label))
4836 match_case_to_enum_1 (CASE_HIGH (label), type, label);
4838 CASE_HIGH_SEEN (label) = 0;
4844 /* Handle -Wswitch*. Called from the front end after parsing the
4845 switch construct. */
4846 /* ??? Should probably be somewhere generic, since other languages
4847 besides C and C++ would want this. At the moment, however, C/C++
4848 are the only tree-ssa languages that support enumerations at all,
4849 so the point is moot. */
4852 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4853 tree type, tree cond)
4855 splay_tree_node default_node;
4856 splay_tree_node node;
4858 int saved_warn_switch;
4860 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4863 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4865 warning (OPT_Wswitch_default, "%Hswitch missing default case",
4868 /* From here on, we only care about about enumerated types. */
4869 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4872 /* If the switch expression was an enumerated type, check that
4873 exactly all enumeration literals are covered by the cases.
4874 The check is made when -Wswitch was specified and there is no
4875 default case, or when -Wswitch-enum was specified. */
4877 if (!warn_switch_enum
4878 && !(warn_switch && !default_node))
4881 /* Clearing COND if it is not an integer constant simplifies
4882 the tests inside the loop below. */
4883 if (TREE_CODE (cond) != INTEGER_CST)
4886 /* The time complexity here is O(N*lg(N)) worst case, but for the
4887 common case of monotonically increasing enumerators, it is
4888 O(N), since the nature of the splay tree will keep the next
4889 element adjacent to the root at all times. */
4891 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4893 tree value = TREE_VALUE (chain);
4894 if (TREE_CODE (value) == CONST_DECL)
4895 value = DECL_INITIAL (value);
4896 node = splay_tree_lookup (cases, (splay_tree_key) value);
4899 /* Mark the CASE_LOW part of the case entry as seen. */
4900 tree label = (tree) node->value;
4901 CASE_LOW_SEEN (label) = 1;
4905 /* Even though there wasn't an exact match, there might be a
4906 case range which includes the enumerator's value. */
4907 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4908 if (node && CASE_HIGH ((tree) node->value))
4910 tree label = (tree) node->value;
4911 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4914 /* If we match the upper bound exactly, mark the CASE_HIGH
4915 part of the case entry as seen. */
4917 CASE_HIGH_SEEN (label) = 1;
4922 /* We've now determined that this enumerated literal isn't
4923 handled by the case labels of the switch statement. */
4925 /* If the switch expression is a constant, we only really care
4926 about whether that constant is handled by the switch. */
4927 if (cond && tree_int_cst_compare (cond, value))
4930 /* If there is a default_node, the only relevant option is
4931 Wswitch-enum. Otherwise, if both are enabled then we prefer
4932 to warn using -Wswitch because -Wswitch is enabled by -Wall
4933 while -Wswitch-enum is explicit. */
4934 warning ((default_node || !warn_switch)
4935 ? OPT_Wswitch_enum : OPT_Wswitch,
4936 "%Henumeration value %qE not handled in switch",
4937 &switch_location, TREE_PURPOSE (chain));
4940 /* Warn if there are case expressions that don't correspond to
4941 enumerators. This can occur since C and C++ don't enforce
4942 type-checking of assignments to enumeration variables.
4944 The time complexity here is now always O(N) worst case, since
4945 we should have marked both the lower bound and upper bound of
4946 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4947 above. This scan also resets those fields. */
4949 /* If there is a default_node, the only relevant option is
4950 Wswitch-enum. Otherwise, if both are enabled then we prefer
4951 to warn using -Wswitch because -Wswitch is enabled by -Wall
4952 while -Wswitch-enum is explicit. */
4953 saved_warn_switch = warn_switch;
4956 splay_tree_foreach (cases, match_case_to_enum, type);
4957 warn_switch = saved_warn_switch;
4961 /* Finish an expression taking the address of LABEL (an
4962 IDENTIFIER_NODE). Returns an expression for the address.
4964 LOC is the location for the expression returned. */
4967 finish_label_address_expr (tree label, location_t loc)
4971 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
4973 if (label == error_mark_node)
4974 return error_mark_node;
4976 label = lookup_label (label);
4977 if (label == NULL_TREE)
4978 result = null_pointer_node;
4981 TREE_USED (label) = 1;
4982 result = build1 (ADDR_EXPR, ptr_type_node, label);
4983 /* The current function in not necessarily uninlinable.
4984 Computed gotos are incompatible with inlining, but the value
4985 here could be used only in a diagnostic, for example. */
4986 protected_set_expr_location (result, loc);
4992 /* Hook used by expand_expr to expand language-specific tree codes. */
4993 /* The only things that should go here are bits needed to expand
4994 constant initializers. Everything else should be handled by the
4995 gimplification routines. */
4998 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4999 int modifiera /* Actually enum expand_modifier. */,
5002 enum expand_modifier modifier = (enum expand_modifier) modifiera;
5003 switch (TREE_CODE (exp))
5005 case COMPOUND_LITERAL_EXPR:
5007 /* Initialize the anonymous variable declared in the compound
5008 literal, then return the variable. */
5009 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
5010 emit_local_var (decl);
5011 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
5019 /* Hook used by staticp to handle language-specific tree codes. */
5022 c_staticp (tree exp)
5024 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
5025 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
5030 /* Given a boolean expression ARG, return a tree representing an increment
5031 or decrement (as indicated by CODE) of ARG. The front end must check for
5032 invalid cases (e.g., decrement in C++). */
5034 boolean_increment (enum tree_code code, tree arg)
5037 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5039 arg = stabilize_reference (arg);
5042 case PREINCREMENT_EXPR:
5043 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5045 case POSTINCREMENT_EXPR:
5046 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5047 arg = save_expr (arg);
5048 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5049 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5051 case PREDECREMENT_EXPR:
5052 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5053 invert_truthvalue (arg));
5055 case POSTDECREMENT_EXPR:
5056 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5057 invert_truthvalue (arg));
5058 arg = save_expr (arg);
5059 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5060 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5065 TREE_SIDE_EFFECTS (val) = 1;
5069 /* Built-in macros for stddef.h, that require macros defined in this
5072 c_stddef_cpp_builtins(void)
5074 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5075 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5076 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5077 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5078 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5079 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5080 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5081 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5085 c_init_attributes (void)
5087 /* Fill in the built_in_attributes array. */
5088 #define DEF_ATTR_NULL_TREE(ENUM) \
5089 built_in_attributes[(int) ENUM] = NULL_TREE;
5090 #define DEF_ATTR_INT(ENUM, VALUE) \
5091 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5092 #define DEF_ATTR_IDENT(ENUM, STRING) \
5093 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5094 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5095 built_in_attributes[(int) ENUM] \
5096 = tree_cons (built_in_attributes[(int) PURPOSE], \
5097 built_in_attributes[(int) VALUE], \
5098 built_in_attributes[(int) CHAIN]);
5099 #include "builtin-attrs.def"
5100 #undef DEF_ATTR_NULL_TREE
5102 #undef DEF_ATTR_IDENT
5103 #undef DEF_ATTR_TREE_LIST
5106 /* Attribute handlers common to C front ends. */
5108 /* Handle a "packed" attribute; arguments as in
5109 struct attribute_spec.handler. */
5112 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5113 int flags, bool *no_add_attrs)
5117 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5118 *node = build_variant_type_copy (*node);
5119 TYPE_PACKED (*node) = 1;
5121 else if (TREE_CODE (*node) == FIELD_DECL)
5123 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5124 /* Still pack bitfields. */
5125 && ! DECL_INITIAL (*node))
5126 warning (OPT_Wattributes,
5127 "%qE attribute ignored for field of type %qT",
5128 name, TREE_TYPE (*node));
5130 DECL_PACKED (*node) = 1;
5132 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5133 used for DECL_REGISTER. It wouldn't mean anything anyway.
5134 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5135 that changes what the typedef is typing. */
5138 warning (OPT_Wattributes, "%qE attribute ignored", name);
5139 *no_add_attrs = true;
5145 /* Handle a "nocommon" attribute; arguments as in
5146 struct attribute_spec.handler. */
5149 handle_nocommon_attribute (tree *node, tree name,
5150 tree ARG_UNUSED (args),
5151 int ARG_UNUSED (flags), bool *no_add_attrs)
5153 if (TREE_CODE (*node) == VAR_DECL)
5154 DECL_COMMON (*node) = 0;
5157 warning (OPT_Wattributes, "%qE attribute ignored", name);
5158 *no_add_attrs = true;
5164 /* Handle a "common" attribute; arguments as in
5165 struct attribute_spec.handler. */
5168 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5169 int ARG_UNUSED (flags), bool *no_add_attrs)
5171 if (TREE_CODE (*node) == VAR_DECL)
5172 DECL_COMMON (*node) = 1;
5175 warning (OPT_Wattributes, "%qE attribute ignored", name);
5176 *no_add_attrs = true;
5182 /* Handle a "noreturn" attribute; arguments as in
5183 struct attribute_spec.handler. */
5186 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5187 int ARG_UNUSED (flags), bool *no_add_attrs)
5189 tree type = TREE_TYPE (*node);
5191 /* See FIXME comment in c_common_attribute_table. */
5192 if (TREE_CODE (*node) == FUNCTION_DECL)
5193 TREE_THIS_VOLATILE (*node) = 1;
5194 else if (TREE_CODE (type) == POINTER_TYPE
5195 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5197 = build_pointer_type
5198 (build_type_variant (TREE_TYPE (type),
5199 TYPE_READONLY (TREE_TYPE (type)), 1));
5202 warning (OPT_Wattributes, "%qE attribute ignored", name);
5203 *no_add_attrs = true;
5209 /* Handle a "hot" and attribute; arguments as in
5210 struct attribute_spec.handler. */
5213 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5214 int ARG_UNUSED (flags), bool *no_add_attrs)
5216 if (TREE_CODE (*node) == FUNCTION_DECL)
5218 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5220 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5222 *no_add_attrs = true;
5224 /* Most of the rest of the hot processing is done later with
5225 lookup_attribute. */
5229 warning (OPT_Wattributes, "%qE attribute ignored", name);
5230 *no_add_attrs = true;
5235 /* Handle a "cold" and attribute; arguments as in
5236 struct attribute_spec.handler. */
5239 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5240 int ARG_UNUSED (flags), bool *no_add_attrs)
5242 if (TREE_CODE (*node) == FUNCTION_DECL)
5244 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5246 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5248 *no_add_attrs = true;
5250 /* Most of the rest of the cold processing is done later with
5251 lookup_attribute. */
5255 warning (OPT_Wattributes, "%qE attribute ignored", name);
5256 *no_add_attrs = true;
5262 /* Handle a "noinline" attribute; arguments as in
5263 struct attribute_spec.handler. */
5266 handle_noinline_attribute (tree *node, tree name,
5267 tree ARG_UNUSED (args),
5268 int ARG_UNUSED (flags), bool *no_add_attrs)
5270 if (TREE_CODE (*node) == FUNCTION_DECL)
5271 DECL_UNINLINABLE (*node) = 1;
5274 warning (OPT_Wattributes, "%qE attribute ignored", name);
5275 *no_add_attrs = true;
5281 /* Handle a "always_inline" attribute; arguments as in
5282 struct attribute_spec.handler. */
5285 handle_always_inline_attribute (tree *node, tree name,
5286 tree ARG_UNUSED (args),
5287 int ARG_UNUSED (flags),
5290 if (TREE_CODE (*node) == FUNCTION_DECL)
5292 /* Set the attribute and mark it for disregarding inline
5294 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
5298 warning (OPT_Wattributes, "%qE attribute ignored", name);
5299 *no_add_attrs = true;
5305 /* Handle a "gnu_inline" attribute; arguments as in
5306 struct attribute_spec.handler. */
5309 handle_gnu_inline_attribute (tree *node, tree name,
5310 tree ARG_UNUSED (args),
5311 int ARG_UNUSED (flags),
5314 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5316 /* Do nothing else, just set the attribute. We'll get at
5317 it later with lookup_attribute. */
5321 warning (OPT_Wattributes, "%qE attribute ignored", name);
5322 *no_add_attrs = true;
5328 /* Handle an "artificial" attribute; arguments as in
5329 struct attribute_spec.handler. */
5332 handle_artificial_attribute (tree *node, tree name,
5333 tree ARG_UNUSED (args),
5334 int ARG_UNUSED (flags),
5337 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5339 /* Do nothing else, just set the attribute. We'll get at
5340 it later with lookup_attribute. */
5344 warning (OPT_Wattributes, "%qE attribute ignored", name);
5345 *no_add_attrs = true;
5351 /* Handle a "flatten" attribute; arguments as in
5352 struct attribute_spec.handler. */
5355 handle_flatten_attribute (tree *node, tree name,
5356 tree args ATTRIBUTE_UNUSED,
5357 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5359 if (TREE_CODE (*node) == FUNCTION_DECL)
5360 /* Do nothing else, just set the attribute. We'll get at
5361 it later with lookup_attribute. */
5365 warning (OPT_Wattributes, "%qE attribute ignored", name);
5366 *no_add_attrs = true;
5372 /* Handle a "warning" or "error" attribute; arguments as in
5373 struct attribute_spec.handler. */
5376 handle_error_attribute (tree *node, tree name, tree args,
5377 int ARG_UNUSED (flags), bool *no_add_attrs)
5379 if (TREE_CODE (*node) == FUNCTION_DECL
5380 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5381 /* Do nothing else, just set the attribute. We'll get at
5382 it later with lookup_attribute. */
5386 warning (OPT_Wattributes, "%qE attribute ignored", name);
5387 *no_add_attrs = true;
5393 /* Handle a "used" attribute; arguments as in
5394 struct attribute_spec.handler. */
5397 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
5398 int ARG_UNUSED (flags), bool *no_add_attrs)
5402 if (TREE_CODE (node) == FUNCTION_DECL
5403 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
5405 TREE_USED (node) = 1;
5406 DECL_PRESERVE_P (node) = 1;
5410 warning (OPT_Wattributes, "%qE attribute ignored", name);
5411 *no_add_attrs = true;
5417 /* Handle a "unused" attribute; arguments as in
5418 struct attribute_spec.handler. */
5421 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5422 int flags, bool *no_add_attrs)
5428 if (TREE_CODE (decl) == PARM_DECL
5429 || TREE_CODE (decl) == VAR_DECL
5430 || TREE_CODE (decl) == FUNCTION_DECL
5431 || TREE_CODE (decl) == LABEL_DECL
5432 || TREE_CODE (decl) == TYPE_DECL)
5433 TREE_USED (decl) = 1;
5436 warning (OPT_Wattributes, "%qE attribute ignored", name);
5437 *no_add_attrs = true;
5442 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5443 *node = build_variant_type_copy (*node);
5444 TREE_USED (*node) = 1;
5450 /* Handle a "externally_visible" attribute; arguments as in
5451 struct attribute_spec.handler. */
5454 handle_externally_visible_attribute (tree *pnode, tree name,
5455 tree ARG_UNUSED (args),
5456 int ARG_UNUSED (flags),
5461 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
5463 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
5464 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
5466 warning (OPT_Wattributes,
5467 "%qE attribute have effect only on public objects", name);
5468 *no_add_attrs = true;
5473 warning (OPT_Wattributes, "%qE attribute ignored", name);
5474 *no_add_attrs = true;
5480 /* Handle a "const" attribute; arguments as in
5481 struct attribute_spec.handler. */
5484 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5485 int ARG_UNUSED (flags), bool *no_add_attrs)
5487 tree type = TREE_TYPE (*node);
5489 /* See FIXME comment on noreturn in c_common_attribute_table. */
5490 if (TREE_CODE (*node) == FUNCTION_DECL)
5491 TREE_READONLY (*node) = 1;
5492 else if (TREE_CODE (type) == POINTER_TYPE
5493 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5495 = build_pointer_type
5496 (build_type_variant (TREE_TYPE (type), 1,
5497 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5500 warning (OPT_Wattributes, "%qE attribute ignored", name);
5501 *no_add_attrs = true;
5507 /* Handle a "transparent_union" attribute; arguments as in
5508 struct attribute_spec.handler. */
5511 handle_transparent_union_attribute (tree *node, tree name,
5512 tree ARG_UNUSED (args), int flags,
5517 *no_add_attrs = true;
5519 if (TREE_CODE (*node) == TYPE_DECL)
5520 node = &TREE_TYPE (*node);
5523 if (TREE_CODE (type) == UNION_TYPE)
5525 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5526 the code in finish_struct. */
5527 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5529 if (TYPE_FIELDS (type) == NULL_TREE
5530 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
5533 /* A type variant isn't good enough, since we don't a cast
5534 to such a type removed as a no-op. */
5535 *node = type = build_duplicate_type (type);
5538 TYPE_TRANSPARENT_UNION (type) = 1;
5543 warning (OPT_Wattributes, "%qE attribute ignored", name);
5547 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
5548 get the requested priority for a constructor or destructor,
5549 possibly issuing diagnostics for invalid or reserved
5552 static priority_type
5553 get_priority (tree args, bool is_destructor)
5559 return DEFAULT_INIT_PRIORITY;
5561 if (!SUPPORTS_INIT_PRIORITY)
5564 error ("destructor priorities are not supported");
5566 error ("constructor priorities are not supported");
5567 return DEFAULT_INIT_PRIORITY;
5570 arg = TREE_VALUE (args);
5571 if (!host_integerp (arg, /*pos=*/0)
5572 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
5575 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
5576 if (pri < 0 || pri > MAX_INIT_PRIORITY)
5579 if (pri <= MAX_RESERVED_INIT_PRIORITY)
5583 "destructor priorities from 0 to %d are reserved "
5584 "for the implementation",
5585 MAX_RESERVED_INIT_PRIORITY);
5588 "constructor priorities from 0 to %d are reserved "
5589 "for the implementation",
5590 MAX_RESERVED_INIT_PRIORITY);
5596 error ("destructor priorities must be integers from 0 to %d inclusive",
5599 error ("constructor priorities must be integers from 0 to %d inclusive",
5601 return DEFAULT_INIT_PRIORITY;
5604 /* Handle a "constructor" attribute; arguments as in
5605 struct attribute_spec.handler. */
5608 handle_constructor_attribute (tree *node, tree name, tree args,
5609 int ARG_UNUSED (flags),
5613 tree type = TREE_TYPE (decl);
5615 if (TREE_CODE (decl) == FUNCTION_DECL
5616 && TREE_CODE (type) == FUNCTION_TYPE
5617 && decl_function_context (decl) == 0)
5619 priority_type priority;
5620 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5621 priority = get_priority (args, /*is_destructor=*/false);
5622 SET_DECL_INIT_PRIORITY (decl, priority);
5623 TREE_USED (decl) = 1;
5627 warning (OPT_Wattributes, "%qE attribute ignored", name);
5628 *no_add_attrs = true;
5634 /* Handle a "destructor" attribute; arguments as in
5635 struct attribute_spec.handler. */
5638 handle_destructor_attribute (tree *node, tree name, tree args,
5639 int ARG_UNUSED (flags),
5643 tree type = TREE_TYPE (decl);
5645 if (TREE_CODE (decl) == FUNCTION_DECL
5646 && TREE_CODE (type) == FUNCTION_TYPE
5647 && decl_function_context (decl) == 0)
5649 priority_type priority;
5650 DECL_STATIC_DESTRUCTOR (decl) = 1;
5651 priority = get_priority (args, /*is_destructor=*/true);
5652 SET_DECL_FINI_PRIORITY (decl, priority);
5653 TREE_USED (decl) = 1;
5657 warning (OPT_Wattributes, "%qE attribute ignored", name);
5658 *no_add_attrs = true;
5664 /* Handle a "mode" attribute; arguments as in
5665 struct attribute_spec.handler. */
5668 handle_mode_attribute (tree *node, tree name, tree args,
5669 int ARG_UNUSED (flags), bool *no_add_attrs)
5673 *no_add_attrs = true;
5675 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5676 warning (OPT_Wattributes, "%qE attribute ignored", name);
5680 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5681 int len = strlen (p);
5682 enum machine_mode mode = VOIDmode;
5686 if (len > 4 && p[0] == '_' && p[1] == '_'
5687 && p[len - 1] == '_' && p[len - 2] == '_')
5689 char *newp = (char *) alloca (len - 1);
5691 strcpy (newp, &p[2]);
5692 newp[len - 4] = '\0';
5696 /* Change this type to have a type with the specified mode.
5697 First check for the special modes. */
5698 if (!strcmp (p, "byte"))
5700 else if (!strcmp (p, "word"))
5702 else if (!strcmp (p, "pointer"))
5704 else if (!strcmp (p, "libgcc_cmp_return"))
5705 mode = targetm.libgcc_cmp_return_mode ();
5706 else if (!strcmp (p, "libgcc_shift_count"))
5707 mode = targetm.libgcc_shift_count_mode ();
5708 else if (!strcmp (p, "unwind_word"))
5709 mode = targetm.unwind_word_mode ();
5711 for (j = 0; j < NUM_MACHINE_MODES; j++)
5712 if (!strcmp (p, GET_MODE_NAME (j)))
5714 mode = (enum machine_mode) j;
5718 if (mode == VOIDmode)
5720 error ("unknown machine mode %qs", p);
5725 switch (GET_MODE_CLASS (mode))
5728 case MODE_PARTIAL_INT:
5730 case MODE_DECIMAL_FLOAT:
5735 valid_mode = targetm.scalar_mode_supported_p (mode);
5738 case MODE_COMPLEX_INT:
5739 case MODE_COMPLEX_FLOAT:
5740 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5743 case MODE_VECTOR_INT:
5744 case MODE_VECTOR_FLOAT:
5745 case MODE_VECTOR_FRACT:
5746 case MODE_VECTOR_UFRACT:
5747 case MODE_VECTOR_ACCUM:
5748 case MODE_VECTOR_UACCUM:
5749 warning (OPT_Wattributes, "specifying vector types with "
5750 "__attribute__ ((mode)) is deprecated");
5751 warning (OPT_Wattributes,
5752 "use __attribute__ ((vector_size)) instead");
5753 valid_mode = vector_mode_valid_p (mode);
5761 error ("unable to emulate %qs", p);
5765 if (POINTER_TYPE_P (type))
5767 tree (*fn)(tree, enum machine_mode, bool);
5769 if (!targetm.valid_pointer_mode (mode))
5771 error ("invalid pointer mode %qs", p);
5775 if (TREE_CODE (type) == POINTER_TYPE)
5776 fn = build_pointer_type_for_mode;
5778 fn = build_reference_type_for_mode;
5779 typefm = fn (TREE_TYPE (type), mode, false);
5783 /* For fixed-point modes, we need to test if the signness of type
5784 and the machine mode are consistent. */
5785 if (ALL_FIXED_POINT_MODE_P (mode)
5786 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
5788 error ("signness of type and machine mode %qs don't match", p);
5791 /* For fixed-point modes, we need to pass saturating info. */
5792 typefm = lang_hooks.types.type_for_mode (mode,
5793 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
5794 : TYPE_UNSIGNED (type));
5797 if (typefm == NULL_TREE)
5799 error ("no data type for mode %qs", p);
5802 else if (TREE_CODE (type) == ENUMERAL_TYPE)
5804 /* For enumeral types, copy the precision from the integer
5805 type returned above. If not an INTEGER_TYPE, we can't use
5806 this mode for this type. */
5807 if (TREE_CODE (typefm) != INTEGER_TYPE)
5809 error ("cannot use mode %qs for enumeral types", p);
5813 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5815 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5820 /* We cannot build a type variant, as there's code that assumes
5821 that TYPE_MAIN_VARIANT has the same mode. This includes the
5822 debug generators. Instead, create a subrange type. This
5823 results in all of the enumeral values being emitted only once
5824 in the original, and the subtype gets them by reference. */
5825 if (TYPE_UNSIGNED (type))
5826 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5828 typefm = make_signed_type (TYPE_PRECISION (typefm));
5829 TREE_TYPE (typefm) = type;
5832 else if (VECTOR_MODE_P (mode)
5833 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5834 : TREE_CODE (type) != TREE_CODE (typefm))
5836 error ("mode %qs applied to inappropriate type", p);
5846 /* Handle a "section" attribute; arguments as in
5847 struct attribute_spec.handler. */
5850 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5851 int ARG_UNUSED (flags), bool *no_add_attrs)
5855 if (targetm.have_named_sections)
5857 user_defined_section_attribute = true;
5859 if ((TREE_CODE (decl) == FUNCTION_DECL
5860 || TREE_CODE (decl) == VAR_DECL)
5861 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5863 if (TREE_CODE (decl) == VAR_DECL
5864 && current_function_decl != NULL_TREE
5865 && !TREE_STATIC (decl))
5867 error ("%Jsection attribute cannot be specified for "
5868 "local variables", decl);
5869 *no_add_attrs = true;
5872 /* The decl may have already been given a section attribute
5873 from a previous declaration. Ensure they match. */
5874 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5875 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5876 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5878 error ("section of %q+D conflicts with previous declaration",
5880 *no_add_attrs = true;
5882 else if (TREE_CODE (decl) == VAR_DECL
5883 && !targetm.have_tls && targetm.emutls.tmpl_section
5884 && DECL_THREAD_LOCAL_P (decl))
5886 error ("section of %q+D cannot be overridden", *node);
5887 *no_add_attrs = true;
5890 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5894 error ("section attribute not allowed for %q+D", *node);
5895 *no_add_attrs = true;
5900 error ("%Jsection attributes are not supported for this target", *node);
5901 *no_add_attrs = true;
5907 /* Handle a "aligned" attribute; arguments as in
5908 struct attribute_spec.handler. */
5911 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5912 int flags, bool *no_add_attrs)
5914 tree decl = NULL_TREE;
5917 tree align_expr = (args ? TREE_VALUE (args)
5918 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
5924 type = &TREE_TYPE (decl);
5925 is_type = TREE_CODE (*node) == TYPE_DECL;
5927 else if (TYPE_P (*node))
5928 type = node, is_type = 1;
5930 if (TREE_CODE (align_expr) != INTEGER_CST)
5932 error ("requested alignment is not a constant");
5933 *no_add_attrs = true;
5935 else if ((i = tree_log2 (align_expr)) == -1)
5937 error ("requested alignment is not a power of 2");
5938 *no_add_attrs = true;
5940 else if (i > HOST_BITS_PER_INT - 2)
5942 error ("requested alignment is too large");
5943 *no_add_attrs = true;
5947 if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5948 /* OK, modify the type in place. */;
5949 /* If we have a TYPE_DECL, then copy the type, so that we
5950 don't accidentally modify a builtin type. See pushdecl. */
5951 else if (decl && TREE_TYPE (decl) != error_mark_node
5952 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5954 tree tt = TREE_TYPE (decl);
5955 *type = build_variant_type_copy (*type);
5956 DECL_ORIGINAL_TYPE (decl) = tt;
5957 TYPE_NAME (*type) = decl;
5958 TREE_USED (*type) = TREE_USED (decl);
5959 TREE_TYPE (decl) = *type;
5962 *type = build_variant_type_copy (*type);
5964 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5965 TYPE_USER_ALIGN (*type) = 1;
5967 else if (! VAR_OR_FUNCTION_DECL_P (decl)
5968 && TREE_CODE (decl) != FIELD_DECL)
5970 error ("alignment may not be specified for %q+D", decl);
5971 *no_add_attrs = true;
5973 else if (TREE_CODE (decl) == FUNCTION_DECL
5974 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
5976 if (DECL_USER_ALIGN (decl))
5977 error ("alignment for %q+D was previously specified as %d "
5978 "and may not be decreased", decl,
5979 DECL_ALIGN (decl) / BITS_PER_UNIT);
5981 error ("alignment for %q+D must be at least %d", decl,
5982 DECL_ALIGN (decl) / BITS_PER_UNIT);
5983 *no_add_attrs = true;
5987 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5988 DECL_USER_ALIGN (decl) = 1;
5994 /* Handle a "weak" attribute; arguments as in
5995 struct attribute_spec.handler. */
5998 handle_weak_attribute (tree *node, tree name,
5999 tree ARG_UNUSED (args),
6000 int ARG_UNUSED (flags),
6001 bool * ARG_UNUSED (no_add_attrs))
6003 if (TREE_CODE (*node) == FUNCTION_DECL
6004 && DECL_DECLARED_INLINE_P (*node))
6006 error ("inline function %q+D cannot be declared weak", *node);
6007 *no_add_attrs = true;
6009 else if (TREE_CODE (*node) == FUNCTION_DECL
6010 || TREE_CODE (*node) == VAR_DECL)
6011 declare_weak (*node);
6013 warning (OPT_Wattributes, "%qE attribute ignored", name);
6018 /* Handle an "alias" attribute; arguments as in
6019 struct attribute_spec.handler. */
6022 handle_alias_attribute (tree *node, tree name, tree args,
6023 int ARG_UNUSED (flags), bool *no_add_attrs)
6027 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6029 warning (OPT_Wattributes, "%qE attribute ignored", name);
6030 *no_add_attrs = true;
6032 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6033 || (TREE_CODE (decl) != FUNCTION_DECL
6034 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6035 /* A static variable declaration is always a tentative definition,
6036 but the alias is a non-tentative definition which overrides. */
6037 || (TREE_CODE (decl) != FUNCTION_DECL
6038 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6040 error ("%q+D defined both normally and as an alias", decl);
6041 *no_add_attrs = true;
6044 /* Note that the very first time we process a nested declaration,
6045 decl_function_context will not be set. Indeed, *would* never
6046 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6047 we do below. After such frobbery, pushdecl would set the context.
6048 In any case, this is never what we want. */
6049 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6053 id = TREE_VALUE (args);
6054 if (TREE_CODE (id) != STRING_CST)
6056 error ("alias argument not a string");
6057 *no_add_attrs = true;
6060 id = get_identifier (TREE_STRING_POINTER (id));
6061 /* This counts as a use of the object pointed to. */
6064 if (TREE_CODE (decl) == FUNCTION_DECL)
6065 DECL_INITIAL (decl) = error_mark_node;
6068 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6069 DECL_EXTERNAL (decl) = 1;
6071 DECL_EXTERNAL (decl) = 0;
6072 TREE_STATIC (decl) = 1;
6077 warning (OPT_Wattributes, "%qE attribute ignored", name);
6078 *no_add_attrs = true;
6084 /* Handle a "weakref" attribute; arguments as in struct
6085 attribute_spec.handler. */
6088 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6089 int flags, bool *no_add_attrs)
6091 tree attr = NULL_TREE;
6093 /* We must ignore the attribute when it is associated with
6094 local-scoped decls, since attribute alias is ignored and many
6095 such symbols do not even have a DECL_WEAK field. */
6096 if (decl_function_context (*node)
6097 || current_function_decl
6098 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6100 warning (OPT_Wattributes, "%qE attribute ignored", name);
6101 *no_add_attrs = true;
6105 /* The idea here is that `weakref("name")' mutates into `weakref,
6106 alias("name")', and weakref without arguments, in turn,
6107 implicitly adds weak. */
6111 attr = tree_cons (get_identifier ("alias"), args, attr);
6112 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6114 *no_add_attrs = true;
6116 decl_attributes (node, attr, flags);
6120 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6121 error ("%Jweakref attribute must appear before alias attribute",
6124 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6125 and that isn't supported; and because it wants to add it to
6126 the list of weak decls, which isn't helpful. */
6127 DECL_WEAK (*node) = 1;
6133 /* Handle an "visibility" attribute; arguments as in
6134 struct attribute_spec.handler. */
6137 handle_visibility_attribute (tree *node, tree name, tree args,
6138 int ARG_UNUSED (flags),
6139 bool *ARG_UNUSED (no_add_attrs))
6142 tree id = TREE_VALUE (args);
6143 enum symbol_visibility vis;
6147 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6149 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6151 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6155 else if (TYPE_FIELDS (*node))
6157 error ("%qE attribute ignored because %qT is already defined",
6162 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6164 warning (OPT_Wattributes, "%qE attribute ignored", name);
6168 if (TREE_CODE (id) != STRING_CST)
6170 error ("visibility argument not a string");
6174 /* If this is a type, set the visibility on the type decl. */
6177 decl = TYPE_NAME (decl);
6180 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6182 warning (OPT_Wattributes, "%qE attribute ignored on types",
6188 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6189 vis = VISIBILITY_DEFAULT;
6190 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6191 vis = VISIBILITY_INTERNAL;
6192 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6193 vis = VISIBILITY_HIDDEN;
6194 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6195 vis = VISIBILITY_PROTECTED;
6198 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6199 vis = VISIBILITY_DEFAULT;
6202 if (DECL_VISIBILITY_SPECIFIED (decl)
6203 && vis != DECL_VISIBILITY (decl))
6205 tree attributes = (TYPE_P (*node)
6206 ? TYPE_ATTRIBUTES (*node)
6207 : DECL_ATTRIBUTES (decl));
6208 if (lookup_attribute ("visibility", attributes))
6209 error ("%qD redeclared with different visibility", decl);
6210 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6211 && lookup_attribute ("dllimport", attributes))
6212 error ("%qD was declared %qs which implies default visibility",
6214 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6215 && lookup_attribute ("dllexport", attributes))
6216 error ("%qD was declared %qs which implies default visibility",
6220 DECL_VISIBILITY (decl) = vis;
6221 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6223 /* Go ahead and attach the attribute to the node as well. This is needed
6224 so we can determine whether we have VISIBILITY_DEFAULT because the
6225 visibility was not specified, or because it was explicitly overridden
6226 from the containing scope. */
6231 /* Determine the ELF symbol visibility for DECL, which is either a
6232 variable or a function. It is an error to use this function if a
6233 definition of DECL is not available in this translation unit.
6234 Returns true if the final visibility has been determined by this
6235 function; false if the caller is free to make additional
6239 c_determine_visibility (tree decl)
6241 gcc_assert (TREE_CODE (decl) == VAR_DECL
6242 || TREE_CODE (decl) == FUNCTION_DECL);
6244 /* If the user explicitly specified the visibility with an
6245 attribute, honor that. DECL_VISIBILITY will have been set during
6246 the processing of the attribute. We check for an explicit
6247 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6248 to distinguish the use of an attribute from the use of a "#pragma
6249 GCC visibility push(...)"; in the latter case we still want other
6250 considerations to be able to overrule the #pragma. */
6251 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6252 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6253 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6254 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6257 /* Set default visibility to whatever the user supplied with
6258 visibility_specified depending on #pragma GCC visibility. */
6259 if (!DECL_VISIBILITY_SPECIFIED (decl))
6261 if (visibility_options.inpragma
6262 || DECL_VISIBILITY (decl) != default_visibility)
6264 DECL_VISIBILITY (decl) = default_visibility;
6265 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6266 /* If visibility changed and DECL already has DECL_RTL, ensure
6267 symbol flags are updated. */
6268 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6269 || TREE_CODE (decl) == FUNCTION_DECL)
6270 && DECL_RTL_SET_P (decl))
6271 make_decl_rtl (decl);
6277 /* Handle an "tls_model" attribute; arguments as in
6278 struct attribute_spec.handler. */
6281 handle_tls_model_attribute (tree *node, tree name, tree args,
6282 int ARG_UNUSED (flags), bool *no_add_attrs)
6286 enum tls_model kind;
6288 *no_add_attrs = true;
6290 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
6292 warning (OPT_Wattributes, "%qE attribute ignored", name);
6296 kind = DECL_TLS_MODEL (decl);
6297 id = TREE_VALUE (args);
6298 if (TREE_CODE (id) != STRING_CST)
6300 error ("tls_model argument not a string");
6304 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
6305 kind = TLS_MODEL_LOCAL_EXEC;
6306 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
6307 kind = TLS_MODEL_INITIAL_EXEC;
6308 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
6309 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
6310 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
6311 kind = TLS_MODEL_GLOBAL_DYNAMIC;
6313 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6315 DECL_TLS_MODEL (decl) = kind;
6319 /* Handle a "no_instrument_function" attribute; arguments as in
6320 struct attribute_spec.handler. */
6323 handle_no_instrument_function_attribute (tree *node, tree name,
6324 tree ARG_UNUSED (args),
6325 int ARG_UNUSED (flags),
6330 if (TREE_CODE (decl) != FUNCTION_DECL)
6332 error ("%J%qE attribute applies only to functions", decl, name);
6333 *no_add_attrs = true;
6335 else if (DECL_INITIAL (decl))
6337 error ("%Jcan%'t set %qE attribute after definition", decl, name);
6338 *no_add_attrs = true;
6341 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6346 /* Handle a "malloc" attribute; arguments as in
6347 struct attribute_spec.handler. */
6350 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6351 int ARG_UNUSED (flags), bool *no_add_attrs)
6353 if (TREE_CODE (*node) == FUNCTION_DECL
6354 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
6355 DECL_IS_MALLOC (*node) = 1;
6358 warning (OPT_Wattributes, "%qE attribute ignored", name);
6359 *no_add_attrs = true;
6365 /* Handle a "alloc_size" attribute; arguments as in
6366 struct attribute_spec.handler. */
6369 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6370 int ARG_UNUSED (flags), bool *no_add_attrs)
6372 unsigned arg_count = type_num_arguments (*node);
6373 for (; args; args = TREE_CHAIN (args))
6375 tree position = TREE_VALUE (args);
6377 if (TREE_CODE (position) != INTEGER_CST
6378 || TREE_INT_CST_HIGH (position)
6379 || TREE_INT_CST_LOW (position) < 1
6380 || TREE_INT_CST_LOW (position) > arg_count )
6382 warning (OPT_Wattributes,
6383 "alloc_size parameter outside range");
6384 *no_add_attrs = true;
6391 /* Handle a "returns_twice" attribute; arguments as in
6392 struct attribute_spec.handler. */
6395 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6396 int ARG_UNUSED (flags), bool *no_add_attrs)
6398 if (TREE_CODE (*node) == FUNCTION_DECL)
6399 DECL_IS_RETURNS_TWICE (*node) = 1;
6402 warning (OPT_Wattributes, "%qE attribute ignored", name);
6403 *no_add_attrs = true;
6409 /* Handle a "no_limit_stack" attribute; arguments as in
6410 struct attribute_spec.handler. */
6413 handle_no_limit_stack_attribute (tree *node, tree name,
6414 tree ARG_UNUSED (args),
6415 int ARG_UNUSED (flags),
6420 if (TREE_CODE (decl) != FUNCTION_DECL)
6422 error ("%J%qE attribute applies only to functions", decl, name);
6423 *no_add_attrs = true;
6425 else if (DECL_INITIAL (decl))
6427 error ("%Jcan%'t set %qE attribute after definition", decl, name);
6428 *no_add_attrs = true;
6431 DECL_NO_LIMIT_STACK (decl) = 1;
6436 /* Handle a "pure" attribute; arguments as in
6437 struct attribute_spec.handler. */
6440 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6441 int ARG_UNUSED (flags), bool *no_add_attrs)
6443 if (TREE_CODE (*node) == FUNCTION_DECL)
6444 DECL_PURE_P (*node) = 1;
6445 /* ??? TODO: Support types. */
6448 warning (OPT_Wattributes, "%qE attribute ignored", name);
6449 *no_add_attrs = true;
6455 /* Handle a "no vops" attribute; arguments as in
6456 struct attribute_spec.handler. */
6459 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
6460 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6461 bool *ARG_UNUSED (no_add_attrs))
6463 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
6464 DECL_IS_NOVOPS (*node) = 1;
6468 /* Handle a "deprecated" attribute; arguments as in
6469 struct attribute_spec.handler. */
6472 handle_deprecated_attribute (tree *node, tree name,
6473 tree ARG_UNUSED (args), int flags,
6476 tree type = NULL_TREE;
6478 tree what = NULL_TREE;
6483 type = TREE_TYPE (decl);
6485 if (TREE_CODE (decl) == TYPE_DECL
6486 || TREE_CODE (decl) == PARM_DECL
6487 || TREE_CODE (decl) == VAR_DECL
6488 || TREE_CODE (decl) == FUNCTION_DECL
6489 || TREE_CODE (decl) == FIELD_DECL)
6490 TREE_DEPRECATED (decl) = 1;
6494 else if (TYPE_P (*node))
6496 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6497 *node = build_variant_type_copy (*node);
6498 TREE_DEPRECATED (*node) = 1;
6506 *no_add_attrs = true;
6507 if (type && TYPE_NAME (type))
6509 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6510 what = TYPE_NAME (*node);
6511 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6512 && DECL_NAME (TYPE_NAME (type)))
6513 what = DECL_NAME (TYPE_NAME (type));
6516 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
6518 warning (OPT_Wattributes, "%qE attribute ignored", name);
6524 /* Handle a "vector_size" attribute; arguments as in
6525 struct attribute_spec.handler. */
6528 handle_vector_size_attribute (tree *node, tree name, tree args,
6529 int ARG_UNUSED (flags),
6532 unsigned HOST_WIDE_INT vecsize, nunits;
6533 enum machine_mode orig_mode;
6534 tree type = *node, new_type, size;
6536 *no_add_attrs = true;
6538 size = TREE_VALUE (args);
6540 if (!host_integerp (size, 1))
6542 warning (OPT_Wattributes, "%qE attribute ignored", name);
6546 /* Get the vector size (in bytes). */
6547 vecsize = tree_low_cst (size, 1);
6549 /* We need to provide for vector pointers, vector arrays, and
6550 functions returning vectors. For example:
6552 __attribute__((vector_size(16))) short *foo;
6554 In this case, the mode is SI, but the type being modified is
6555 HI, so we need to look further. */
6557 while (POINTER_TYPE_P (type)
6558 || TREE_CODE (type) == FUNCTION_TYPE
6559 || TREE_CODE (type) == METHOD_TYPE
6560 || TREE_CODE (type) == ARRAY_TYPE
6561 || TREE_CODE (type) == OFFSET_TYPE)
6562 type = TREE_TYPE (type);
6564 /* Get the mode of the type being modified. */
6565 orig_mode = TYPE_MODE (type);
6567 if ((!INTEGRAL_TYPE_P (type)
6568 && !SCALAR_FLOAT_TYPE_P (type)
6569 && !FIXED_POINT_TYPE_P (type))
6570 || (!SCALAR_FLOAT_MODE_P (orig_mode)
6571 && GET_MODE_CLASS (orig_mode) != MODE_INT
6572 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
6573 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
6574 || TREE_CODE (type) == BOOLEAN_TYPE)
6576 error ("invalid vector type for attribute %qE", name);
6580 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
6582 error ("vector size not an integral multiple of component size");
6588 error ("zero vector size");
6592 /* Calculate how many units fit in the vector. */
6593 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6594 if (nunits & (nunits - 1))
6596 error ("number of components of the vector not a power of two");
6600 new_type = build_vector_type (type, nunits);
6602 /* Build back pointers if needed. */
6603 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
6608 /* Handle the "nonnull" attribute. */
6610 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
6611 tree args, int ARG_UNUSED (flags),
6615 unsigned HOST_WIDE_INT attr_arg_num;
6617 /* If no arguments are specified, all pointer arguments should be
6618 non-null. Verify a full prototype is given so that the arguments
6619 will have the correct types when we actually check them later. */
6622 if (!TYPE_ARG_TYPES (type))
6624 error ("nonnull attribute without arguments on a non-prototype");
6625 *no_add_attrs = true;
6630 /* Argument list specified. Verify that each argument number references
6631 a pointer argument. */
6632 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6635 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
6637 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
6639 error ("nonnull argument has invalid operand number (argument %lu)",
6640 (unsigned long) attr_arg_num);
6641 *no_add_attrs = true;
6645 argument = TYPE_ARG_TYPES (type);
6648 for (ck_num = 1; ; ck_num++)
6650 if (!argument || ck_num == arg_num)
6652 argument = TREE_CHAIN (argument);
6656 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6658 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6659 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6660 *no_add_attrs = true;
6664 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6666 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6667 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6668 *no_add_attrs = true;
6677 /* Check the argument list of a function call for null in argument slots
6678 that are marked as requiring a non-null pointer argument. The NARGS
6679 arguments are passed in the array ARGARRAY.
6683 check_function_nonnull (tree attrs, int nargs, tree *argarray)
6688 for (a = attrs; a; a = TREE_CHAIN (a))
6690 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6692 args = TREE_VALUE (a);
6694 /* Walk the argument list. If we encounter an argument number we
6695 should check for non-null, do it. If the attribute has no args,
6696 then every pointer argument is checked (in which case the check
6697 for pointer type is done in check_nonnull_arg). */
6698 for (i = 0; i < nargs; i++)
6700 if (!args || nonnull_check_p (args, i + 1))
6701 check_function_arguments_recurse (check_nonnull_arg, NULL,
6709 /* Check that the Nth argument of a function call (counting backwards
6710 from the end) is a (pointer)0. The NARGS arguments are passed in the
6714 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
6716 tree attr = lookup_attribute ("sentinel", attrs);
6724 /* Skip over the named arguments. */
6725 while (typelist && len < nargs)
6727 typelist = TREE_CHAIN (typelist);
6731 if (TREE_VALUE (attr))
6733 tree p = TREE_VALUE (TREE_VALUE (attr));
6734 pos = TREE_INT_CST_LOW (p);
6737 /* The sentinel must be one of the varargs, i.e.
6738 in position >= the number of fixed arguments. */
6739 if ((nargs - 1 - pos) < len)
6741 warning (OPT_Wformat,
6742 "not enough variable arguments to fit a sentinel");
6746 /* Validate the sentinel. */
6747 sentinel = argarray[nargs - 1 - pos];
6748 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
6749 || !integer_zerop (sentinel))
6750 /* Although __null (in C++) is only an integer we allow it
6751 nevertheless, as we are guaranteed that it's exactly
6752 as wide as a pointer, and we don't want to force
6753 users to cast the NULL they have written there.
6754 We warn with -Wstrict-null-sentinel, though. */
6755 && (warn_strict_null_sentinel || null_node != sentinel))
6756 warning (OPT_Wformat, "missing sentinel in function call");
6760 /* Helper for check_function_nonnull; given a list of operands which
6761 must be non-null in ARGS, determine if operand PARAM_NUM should be
6765 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6767 unsigned HOST_WIDE_INT arg_num = 0;
6769 for (; args; args = TREE_CHAIN (args))
6771 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6775 if (arg_num == param_num)
6781 /* Check that the function argument PARAM (which is operand number
6782 PARAM_NUM) is non-null. This is called by check_function_nonnull
6783 via check_function_arguments_recurse. */
6786 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6787 unsigned HOST_WIDE_INT param_num)
6789 /* Just skip checking the argument if it's not a pointer. This can
6790 happen if the "nonnull" attribute was given without an operand
6791 list (which means to check every pointer argument). */
6793 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6796 if (integer_zerop (param))
6797 warning (OPT_Wnonnull, "null argument where non-null required "
6798 "(argument %lu)", (unsigned long) param_num);
6801 /* Helper for nonnull attribute handling; fetch the operand number
6802 from the attribute argument list. */
6805 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6807 /* Verify the arg number is a constant. */
6808 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6809 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6812 *valp = TREE_INT_CST_LOW (arg_num_expr);
6816 /* Handle a "nothrow" attribute; arguments as in
6817 struct attribute_spec.handler. */
6820 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6821 int ARG_UNUSED (flags), bool *no_add_attrs)
6823 if (TREE_CODE (*node) == FUNCTION_DECL)
6824 TREE_NOTHROW (*node) = 1;
6825 /* ??? TODO: Support types. */
6828 warning (OPT_Wattributes, "%qE attribute ignored", name);
6829 *no_add_attrs = true;
6835 /* Handle a "cleanup" attribute; arguments as in
6836 struct attribute_spec.handler. */
6839 handle_cleanup_attribute (tree *node, tree name, tree args,
6840 int ARG_UNUSED (flags), bool *no_add_attrs)
6843 tree cleanup_id, cleanup_decl;
6845 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6846 for global destructors in C++. This requires infrastructure that
6847 we don't have generically at the moment. It's also not a feature
6848 we'd be missing too much, since we do have attribute constructor. */
6849 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6851 warning (OPT_Wattributes, "%qE attribute ignored", name);
6852 *no_add_attrs = true;
6856 /* Verify that the argument is a function in scope. */
6857 /* ??? We could support pointers to functions here as well, if
6858 that was considered desirable. */
6859 cleanup_id = TREE_VALUE (args);
6860 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6862 error ("cleanup argument not an identifier");
6863 *no_add_attrs = true;
6866 cleanup_decl = lookup_name (cleanup_id);
6867 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6869 error ("cleanup argument not a function");
6870 *no_add_attrs = true;
6874 /* That the function has proper type is checked with the
6875 eventual call to build_function_call. */
6880 /* Handle a "warn_unused_result" attribute. No special handling. */
6883 handle_warn_unused_result_attribute (tree *node, tree name,
6884 tree ARG_UNUSED (args),
6885 int ARG_UNUSED (flags), bool *no_add_attrs)
6887 /* Ignore the attribute for functions not returning any value. */
6888 if (VOID_TYPE_P (TREE_TYPE (*node)))
6890 warning (OPT_Wattributes, "%qE attribute ignored", name);
6891 *no_add_attrs = true;
6897 /* Handle a "sentinel" attribute. */
6900 handle_sentinel_attribute (tree *node, tree name, tree args,
6901 int ARG_UNUSED (flags), bool *no_add_attrs)
6903 tree params = TYPE_ARG_TYPES (*node);
6907 warning (OPT_Wattributes,
6908 "%qE attribute requires prototypes with named arguments", name);
6909 *no_add_attrs = true;
6913 while (TREE_CHAIN (params))
6914 params = TREE_CHAIN (params);
6916 if (VOID_TYPE_P (TREE_VALUE (params)))
6918 warning (OPT_Wattributes,
6919 "%qE attribute only applies to variadic functions", name);
6920 *no_add_attrs = true;
6926 tree position = TREE_VALUE (args);
6928 if (TREE_CODE (position) != INTEGER_CST)
6930 warning (OPT_Wattributes,
6931 "requested position is not an integer constant");
6932 *no_add_attrs = true;
6936 if (tree_int_cst_lt (position, integer_zero_node))
6938 warning (OPT_Wattributes,
6939 "requested position is less than zero");
6940 *no_add_attrs = true;
6948 /* Handle a "type_generic" attribute. */
6951 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6952 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6953 bool * ARG_UNUSED (no_add_attrs))
6957 /* Ensure we have a function type. */
6958 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
6960 params = TYPE_ARG_TYPES (*node);
6961 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
6962 params = TREE_CHAIN (params);
6964 /* Ensure we have a variadic function. */
6965 gcc_assert (!params);
6970 /* Handle a "target" attribute. */
6973 handle_target_attribute (tree *node, tree name, tree args, int flags,
6976 /* Ensure we have a function type. */
6977 if (TREE_CODE (*node) != FUNCTION_DECL)
6979 warning (OPT_Wattributes, "%qE attribute ignored", name);
6980 *no_add_attrs = true;
6982 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
6984 *no_add_attrs = true;
6989 /* Arguments being collected for optimization. */
6990 typedef const char *const_char_p; /* For DEF_VEC_P. */
6991 DEF_VEC_P(const_char_p);
6992 DEF_VEC_ALLOC_P(const_char_p, gc);
6993 static GTY(()) VEC(const_char_p, gc) *optimize_args;
6996 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
6997 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
6998 false for #pragma GCC optimize. */
7001 parse_optimize_options (tree args, bool attr_p)
7006 int saved_flag_strict_aliasing;
7007 const char **opt_argv;
7010 /* Build up argv vector. Just in case the string is stored away, use garbage
7011 collected strings. */
7012 VEC_truncate (const_char_p, optimize_args, 0);
7013 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7015 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7017 tree value = TREE_VALUE (ap);
7019 if (TREE_CODE (value) == INTEGER_CST)
7022 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7023 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7026 else if (TREE_CODE (value) == STRING_CST)
7028 /* Split string into multiple substrings. */
7029 size_t len = TREE_STRING_LENGTH (value);
7030 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7031 char *end = p + len;
7035 while (next_p != NULL)
7041 comma = strchr (p, ',');
7054 r = q = (char *) ggc_alloc (len2 + 3);
7056 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7058 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7062 warning (OPT_Wattributes,
7063 "Bad option %s to optimize attribute.", p);
7065 warning (OPT_Wpragmas,
7066 "Bad option %s to pragma attribute", p);
7074 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7075 itself is -Os, and any other switch begins with a -f. */
7076 if ((*p >= '0' && *p <= '9')
7077 || (p[0] == 's' && p[1] == '\0'))
7083 memcpy (r, p, len2);
7085 VEC_safe_push (const_char_p, gc, optimize_args, q);
7091 opt_argc = VEC_length (const_char_p, optimize_args);
7092 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7094 for (i = 1; i < opt_argc; i++)
7095 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7097 saved_flag_strict_aliasing = flag_strict_aliasing;
7099 /* Now parse the options. */
7100 decode_options (opt_argc, opt_argv);
7102 /* Don't allow changing -fstrict-aliasing. */
7103 flag_strict_aliasing = saved_flag_strict_aliasing;
7105 VEC_truncate (const_char_p, optimize_args, 0);
7109 /* For handling "optimize" attribute. arguments as in
7110 struct attribute_spec.handler. */
7113 handle_optimize_attribute (tree *node, tree name, tree args,
7114 int ARG_UNUSED (flags), bool *no_add_attrs)
7116 /* Ensure we have a function type. */
7117 if (TREE_CODE (*node) != FUNCTION_DECL)
7119 warning (OPT_Wattributes, "%qE attribute ignored", name);
7120 *no_add_attrs = true;
7124 struct cl_optimization cur_opts;
7125 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7127 /* Save current options. */
7128 cl_optimization_save (&cur_opts);
7130 /* If we previously had some optimization options, use them as the
7133 cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7135 /* Parse options, and update the vector. */
7136 parse_optimize_options (args, true);
7137 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7138 = build_optimization_node ();
7140 /* Restore current options. */
7141 cl_optimization_restore (&cur_opts);
7147 /* Check for valid arguments being passed to a function.
7148 ATTRS is a list of attributes. There are NARGS arguments in the array
7149 ARGARRAY. TYPELIST is the list of argument types for the function.
7152 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7154 /* Check for null being passed in a pointer argument that must be
7155 non-null. We also need to do this if format checking is enabled. */
7158 check_function_nonnull (attrs, nargs, argarray);
7160 /* Check for errors in format strings. */
7162 if (warn_format || warn_missing_format_attribute)
7163 check_function_format (attrs, nargs, argarray);
7166 check_function_sentinel (attrs, nargs, argarray, typelist);
7169 /* Generic argument checking recursion routine. PARAM is the argument to
7170 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7171 once the argument is resolved. CTX is context for the callback. */
7173 check_function_arguments_recurse (void (*callback)
7174 (void *, tree, unsigned HOST_WIDE_INT),
7175 void *ctx, tree param,
7176 unsigned HOST_WIDE_INT param_num)
7178 if (CONVERT_EXPR_P (param)
7179 && (TYPE_PRECISION (TREE_TYPE (param))
7180 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7182 /* Strip coercion. */
7183 check_function_arguments_recurse (callback, ctx,
7184 TREE_OPERAND (param, 0), param_num);
7188 if (TREE_CODE (param) == CALL_EXPR)
7190 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7192 bool found_format_arg = false;
7194 /* See if this is a call to a known internationalization function
7195 that modifies a format arg. Such a function may have multiple
7196 format_arg attributes (for example, ngettext). */
7198 for (attrs = TYPE_ATTRIBUTES (type);
7200 attrs = TREE_CHAIN (attrs))
7201 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7204 tree format_num_expr;
7207 call_expr_arg_iterator iter;
7209 /* Extract the argument number, which was previously checked
7211 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7213 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7214 && !TREE_INT_CST_HIGH (format_num_expr));
7216 format_num = TREE_INT_CST_LOW (format_num_expr);
7218 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7220 inner_arg = next_call_expr_arg (&iter), i++)
7221 if (i == format_num)
7223 check_function_arguments_recurse (callback, ctx,
7224 inner_arg, param_num);
7225 found_format_arg = true;
7230 /* If we found a format_arg attribute and did a recursive check,
7231 we are done with checking this argument. Otherwise, we continue
7232 and this will be considered a non-literal. */
7233 if (found_format_arg)
7237 if (TREE_CODE (param) == COND_EXPR)
7239 /* Check both halves of the conditional expression. */
7240 check_function_arguments_recurse (callback, ctx,
7241 TREE_OPERAND (param, 1), param_num);
7242 check_function_arguments_recurse (callback, ctx,
7243 TREE_OPERAND (param, 2), param_num);
7247 (*callback) (ctx, param, param_num);
7250 /* Checks the number of arguments NARGS against the required number
7251 REQUIRED and issues an error if there is a mismatch. Returns true
7252 if the number of arguments is correct, otherwise false. */
7255 validate_nargs (tree fndecl, int nargs, int required)
7257 if (nargs < required)
7259 error ("not enough arguments to function %qE", fndecl);
7262 else if (nargs > required)
7264 error ("too many arguments to function %qE", fndecl);
7270 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7271 Returns false if there was an error, otherwise true. */
7274 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
7276 if (!DECL_BUILT_IN (fndecl)
7277 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
7280 switch (DECL_FUNCTION_CODE (fndecl))
7282 case BUILT_IN_CONSTANT_P:
7283 return validate_nargs (fndecl, nargs, 1);
7285 case BUILT_IN_ISFINITE:
7286 case BUILT_IN_ISINF:
7287 case BUILT_IN_ISINF_SIGN:
7288 case BUILT_IN_ISNAN:
7289 case BUILT_IN_ISNORMAL:
7290 if (validate_nargs (fndecl, nargs, 1))
7292 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
7294 error ("non-floating-point argument in call to "
7295 "function %qE", fndecl);
7302 case BUILT_IN_ISGREATER:
7303 case BUILT_IN_ISGREATEREQUAL:
7304 case BUILT_IN_ISLESS:
7305 case BUILT_IN_ISLESSEQUAL:
7306 case BUILT_IN_ISLESSGREATER:
7307 case BUILT_IN_ISUNORDERED:
7308 if (validate_nargs (fndecl, nargs, 2))
7310 enum tree_code code0, code1;
7311 code0 = TREE_CODE (TREE_TYPE (args[0]));
7312 code1 = TREE_CODE (TREE_TYPE (args[1]));
7313 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
7314 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7315 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
7317 error ("non-floating-point arguments in call to "
7318 "function %qE", fndecl);
7325 case BUILT_IN_FPCLASSIFY:
7326 if (validate_nargs (fndecl, nargs, 6))
7331 if (TREE_CODE (args[i]) != INTEGER_CST)
7333 error ("non-const integer argument %u in call to function %qE",
7338 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
7340 error ("non-floating-point argument in call to function %qE",
7353 /* Function to help qsort sort FIELD_DECLs by name order. */
7356 field_decl_cmp (const void *x_p, const void *y_p)
7358 const tree *const x = (const tree *const) x_p;
7359 const tree *const y = (const tree *const) y_p;
7361 if (DECL_NAME (*x) == DECL_NAME (*y))
7362 /* A nontype is "greater" than a type. */
7363 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7364 if (DECL_NAME (*x) == NULL_TREE)
7366 if (DECL_NAME (*y) == NULL_TREE)
7368 if (DECL_NAME (*x) < DECL_NAME (*y))
7374 gt_pointer_operator new_value;
7378 /* This routine compares two fields like field_decl_cmp but using the
7379 pointer operator in resort_data. */
7382 resort_field_decl_cmp (const void *x_p, const void *y_p)
7384 const tree *const x = (const tree *const) x_p;
7385 const tree *const y = (const tree *const) y_p;
7387 if (DECL_NAME (*x) == DECL_NAME (*y))
7388 /* A nontype is "greater" than a type. */
7389 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7390 if (DECL_NAME (*x) == NULL_TREE)
7392 if (DECL_NAME (*y) == NULL_TREE)
7395 tree d1 = DECL_NAME (*x);
7396 tree d2 = DECL_NAME (*y);
7397 resort_data.new_value (&d1, resort_data.cookie);
7398 resort_data.new_value (&d2, resort_data.cookie);
7405 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
7408 resort_sorted_fields (void *obj,
7409 void * ARG_UNUSED (orig_obj),
7410 gt_pointer_operator new_value,
7413 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
7414 resort_data.new_value = new_value;
7415 resort_data.cookie = cookie;
7416 qsort (&sf->elts[0], sf->len, sizeof (tree),
7417 resort_field_decl_cmp);
7420 /* Subroutine of c_parse_error.
7421 Return the result of concatenating LHS and RHS. RHS is really
7422 a string literal, its first character is indicated by RHS_START and
7423 RHS_SIZE is its length (including the terminating NUL character).
7425 The caller is responsible for deleting the returned pointer. */
7428 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
7430 const int lhs_size = strlen (lhs);
7431 char *result = XNEWVEC (char, lhs_size + rhs_size);
7432 strncpy (result, lhs, lhs_size);
7433 strncpy (result + lhs_size, rhs_start, rhs_size);
7437 /* Issue the error given by GMSGID, indicating that it occurred before
7438 TOKEN, which had the associated VALUE. */
7441 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
7443 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
7445 char *message = NULL;
7447 if (token == CPP_EOF)
7448 message = catenate_messages (gmsgid, " at end of input");
7449 else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
7450 || token == CPP_CHAR32)
7452 unsigned int val = TREE_INT_CST_LOW (value);
7471 if (val <= UCHAR_MAX && ISGRAPH (val))
7472 message = catenate_messages (gmsgid, " before %s'%c'");
7474 message = catenate_messages (gmsgid, " before %s'\\x%x'");
7476 error (message, prefix, val);
7480 else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
7481 || token == CPP_STRING32)
7482 message = catenate_messages (gmsgid, " before string constant");
7483 else if (token == CPP_NUMBER)
7484 message = catenate_messages (gmsgid, " before numeric constant");
7485 else if (token == CPP_NAME)
7487 message = catenate_messages (gmsgid, " before %qE");
7488 error (message, value);
7492 else if (token == CPP_PRAGMA)
7493 message = catenate_messages (gmsgid, " before %<#pragma%>");
7494 else if (token == CPP_PRAGMA_EOL)
7495 message = catenate_messages (gmsgid, " before end of line");
7496 else if (token < N_TTYPES)
7498 message = catenate_messages (gmsgid, " before %qs token");
7499 error (message, cpp_type2name (token));
7511 #undef catenate_messages
7514 /* Walk a gimplified function and warn for functions whose return value is
7515 ignored and attribute((warn_unused_result)) is set. This is done before
7516 inlining, so we don't have to worry about that. */
7519 c_warn_unused_result (gimple_seq seq)
7522 gimple_stmt_iterator i;
7524 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
7526 gimple g = gsi_stmt (i);
7528 switch (gimple_code (g))
7531 c_warn_unused_result (gimple_bind_body (g));
7534 c_warn_unused_result (gimple_try_eval (g));
7535 c_warn_unused_result (gimple_try_cleanup (g));
7538 c_warn_unused_result (gimple_catch_handler (g));
7540 case GIMPLE_EH_FILTER:
7541 c_warn_unused_result (gimple_eh_filter_failure (g));
7545 if (gimple_call_lhs (g))
7548 /* This is a naked call, as opposed to a GIMPLE_CALL with an
7549 LHS. All calls whose value is ignored should be
7550 represented like this. Look for the attribute. */
7551 fdecl = gimple_call_fndecl (g);
7552 ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
7554 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
7556 location_t loc = gimple_location (g);
7559 warning (0, "%Hignoring return value of %qD, "
7560 "declared with attribute warn_unused_result",
7563 warning (0, "%Hignoring return value of function "
7564 "declared with attribute warn_unused_result",
7570 /* Not a container, not a call, or a call whose value is used. */
7576 /* Convert a character from the host to the target execution character
7577 set. cpplib handles this, mostly. */
7580 c_common_to_target_charset (HOST_WIDE_INT c)
7582 /* Character constants in GCC proper are sign-extended under -fsigned-char,
7583 zero-extended under -fno-signed-char. cpplib insists that characters
7584 and character constants are always unsigned. Hence we must convert
7586 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
7588 uc = cpp_host_to_exec_charset (parse_in, uc);
7590 if (flag_signed_char)
7591 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
7592 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
7597 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
7598 component references, with STOP_REF, or alternatively an INDIRECT_REF of
7599 NULL, at the bottom; much like the traditional rendering of offsetof as a
7600 macro. Returns the folded and properly cast result. */
7603 fold_offsetof_1 (tree expr, tree stop_ref)
7605 enum tree_code code = PLUS_EXPR;
7608 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
7609 return size_zero_node;
7611 switch (TREE_CODE (expr))
7617 error ("cannot apply %<offsetof%> to static data member %qD", expr);
7618 return error_mark_node;
7622 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7623 return error_mark_node;
7627 if (!integer_zerop (TREE_OPERAND (expr, 0)))
7629 error ("cannot apply %<offsetof%> to a non constant address");
7630 return error_mark_node;
7632 return size_zero_node;
7635 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7636 if (base == error_mark_node)
7639 t = TREE_OPERAND (expr, 1);
7640 if (DECL_C_BIT_FIELD (t))
7642 error ("attempt to take address of bit-field structure "
7644 return error_mark_node;
7646 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
7647 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
7652 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7653 if (base == error_mark_node)
7656 t = TREE_OPERAND (expr, 1);
7657 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
7660 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
7662 t = convert (sizetype, t);
7663 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
7667 /* Handle static members of volatile structs. */
7668 t = TREE_OPERAND (expr, 1);
7669 gcc_assert (TREE_CODE (t) == VAR_DECL);
7670 return fold_offsetof_1 (t, stop_ref);
7676 return size_binop (code, base, off);
7680 fold_offsetof (tree expr, tree stop_ref)
7682 /* Convert back from the internal sizetype to size_t. */
7683 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
7686 /* Print an error message for an invalid lvalue. USE says
7687 how the lvalue is being used and so selects the error message. */
7690 lvalue_error (enum lvalue_use use)
7695 error ("lvalue required as left operand of assignment");
7698 error ("lvalue required as increment operand");
7701 error ("lvalue required as decrement operand");
7704 error ("lvalue required as unary %<&%> operand");
7707 error ("lvalue required in asm statement");
7714 /* *PTYPE is an incomplete array. Complete it with a domain based on
7715 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7716 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7717 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
7720 complete_array_type (tree *ptype, tree initial_value, bool do_default)
7722 tree maxindex, type, main_type, elt, unqual_elt;
7723 int failure = 0, quals;
7724 hashval_t hashcode = 0;
7726 maxindex = size_zero_node;
7729 if (TREE_CODE (initial_value) == STRING_CST)
7732 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7733 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
7735 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7737 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
7739 if (VEC_empty (constructor_elt, v))
7743 maxindex = integer_minus_one_node;
7748 unsigned HOST_WIDE_INT cnt;
7749 constructor_elt *ce;
7750 bool fold_p = false;
7752 if (VEC_index (constructor_elt, v, 0)->index)
7753 maxindex = fold_convert (sizetype,
7754 VEC_index (constructor_elt,
7756 curindex = maxindex;
7759 VEC_iterate (constructor_elt, v, cnt, ce);
7762 bool curfold_p = false;
7764 curindex = ce->index, curfold_p = true;
7768 curindex = fold_convert (sizetype, curindex);
7769 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
7771 if (tree_int_cst_lt (maxindex, curindex))
7772 maxindex = curindex, fold_p = curfold_p;
7775 maxindex = fold_convert (sizetype, maxindex);
7780 /* Make an error message unless that happened already. */
7781 if (initial_value != error_mark_node)
7793 elt = TREE_TYPE (type);
7794 quals = TYPE_QUALS (strip_array_types (elt));
7798 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
7800 /* Using build_distinct_type_copy and modifying things afterward instead
7801 of using build_array_type to create a new type preserves all of the
7802 TYPE_LANG_FLAG_? bits that the front end may have set. */
7803 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7804 TREE_TYPE (main_type) = unqual_elt;
7805 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
7806 layout_type (main_type);
7808 /* Make sure we have the canonical MAIN_TYPE. */
7809 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
7810 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
7812 main_type = type_hash_canon (hashcode, main_type);
7814 /* Fix the canonical type. */
7815 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
7816 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
7817 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
7818 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
7819 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
7820 != TYPE_DOMAIN (main_type)))
7821 TYPE_CANONICAL (main_type)
7822 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
7823 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
7825 TYPE_CANONICAL (main_type) = main_type;
7830 type = c_build_qualified_type (main_type, quals);
7832 if (COMPLETE_TYPE_P (type)
7833 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7834 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7836 error ("size of array is too large");
7837 /* If we proceed with the array type as it is, we'll eventually
7838 crash in tree_low_cst(). */
7839 type = error_mark_node;
7847 /* Used to help initialize the builtin-types.def table. When a type of
7848 the correct size doesn't exist, use error_mark_node instead of NULL.
7849 The later results in segfaults even when a decl using the type doesn't
7853 builtin_type_for_size (int size, bool unsignedp)
7855 tree type = lang_hooks.types.type_for_size (size, unsignedp);
7856 return type ? type : error_mark_node;
7859 /* A helper function for resolve_overloaded_builtin in resolving the
7860 overloaded __sync_ builtins. Returns a positive power of 2 if the
7861 first operand of PARAMS is a pointer to a supported data type.
7862 Returns 0 if an error is encountered. */
7865 sync_resolve_size (tree function, tree params)
7872 error ("too few arguments to function %qE", function);
7876 type = TREE_TYPE (TREE_VALUE (params));
7877 if (TREE_CODE (type) != POINTER_TYPE)
7880 type = TREE_TYPE (type);
7881 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
7884 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7885 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
7889 error ("incompatible type for argument %d of %qE", 1, function);
7893 /* A helper function for resolve_overloaded_builtin. Adds casts to
7894 PARAMS to make arguments match up with those of FUNCTION. Drops
7895 the variadic arguments at the end. Returns false if some error
7896 was encountered; true on success. */
7899 sync_resolve_params (tree orig_function, tree function, tree params)
7901 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
7905 /* We've declared the implementation functions to use "volatile void *"
7906 as the pointer parameter, so we shouldn't get any complaints from the
7907 call to check_function_arguments what ever type the user used. */
7908 arg_types = TREE_CHAIN (arg_types);
7909 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7912 /* For the rest of the values, we need to cast these to FTYPE, so that we
7913 don't get warnings for passing pointer types, etc. */
7914 while (arg_types != void_list_node)
7918 params = TREE_CHAIN (params);
7921 error ("too few arguments to function %qE", orig_function);
7925 /* ??? Ideally for the first conversion we'd use convert_for_assignment
7926 so that we get warnings for anything that doesn't match the pointer
7927 type. This isn't portable across the C and C++ front ends atm. */
7928 val = TREE_VALUE (params);
7929 val = convert (ptype, val);
7930 val = convert (TREE_VALUE (arg_types), val);
7931 TREE_VALUE (params) = val;
7933 arg_types = TREE_CHAIN (arg_types);
7937 /* The definition of these primitives is variadic, with the remaining
7938 being "an optional list of variables protected by the memory barrier".
7939 No clue what that's supposed to mean, precisely, but we consider all
7940 call-clobbered variables to be protected so we're safe. */
7941 TREE_CHAIN (params) = NULL;
7946 /* A helper function for resolve_overloaded_builtin. Adds a cast to
7947 RESULT to make it match the type of the first pointer argument in
7951 sync_resolve_return (tree params, tree result)
7953 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7954 ptype = TYPE_MAIN_VARIANT (ptype);
7955 return convert (ptype, result);
7958 /* Some builtin functions are placeholders for other expressions. This
7959 function should be called immediately after parsing the call expression
7960 before surrounding code has committed to the type of the expression.
7962 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7963 PARAMS is the argument list for the call. The return value is non-null
7964 when expansion is complete, and null if normal processing should
7968 resolve_overloaded_builtin (tree function, tree params)
7970 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
7971 switch (DECL_BUILT_IN_CLASS (function))
7973 case BUILT_IN_NORMAL:
7976 if (targetm.resolve_overloaded_builtin)
7977 return targetm.resolve_overloaded_builtin (function, params);
7984 /* Handle BUILT_IN_NORMAL here. */
7987 case BUILT_IN_FETCH_AND_ADD_N:
7988 case BUILT_IN_FETCH_AND_SUB_N:
7989 case BUILT_IN_FETCH_AND_OR_N:
7990 case BUILT_IN_FETCH_AND_AND_N:
7991 case BUILT_IN_FETCH_AND_XOR_N:
7992 case BUILT_IN_FETCH_AND_NAND_N:
7993 case BUILT_IN_ADD_AND_FETCH_N:
7994 case BUILT_IN_SUB_AND_FETCH_N:
7995 case BUILT_IN_OR_AND_FETCH_N:
7996 case BUILT_IN_AND_AND_FETCH_N:
7997 case BUILT_IN_XOR_AND_FETCH_N:
7998 case BUILT_IN_NAND_AND_FETCH_N:
7999 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8000 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8001 case BUILT_IN_LOCK_TEST_AND_SET_N:
8002 case BUILT_IN_LOCK_RELEASE_N:
8004 int n = sync_resolve_size (function, params);
8005 tree new_function, result;
8008 return error_mark_node;
8010 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8011 if (!sync_resolve_params (function, new_function, params))
8012 return error_mark_node;
8014 result = build_function_call (new_function, params);
8015 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8016 && orig_code != BUILT_IN_LOCK_RELEASE_N)
8017 result = sync_resolve_return (params, result);
8027 /* Ignoring their sign, return true if two scalar types are the same. */
8029 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8031 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8033 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8034 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8035 || c2 == FIXED_POINT_TYPE));
8037 /* Equality works here because c_common_signed_type uses
8038 TYPE_MAIN_VARIANT. */
8039 return c_common_signed_type (t1)
8040 == c_common_signed_type (t2);
8043 /* Check for missing format attributes on function pointers. LTYPE is
8044 the new type or left-hand side type. RTYPE is the old type or
8045 right-hand side type. Returns TRUE if LTYPE is missing the desired
8049 check_missing_format_attribute (tree ltype, tree rtype)
8051 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8054 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8055 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8060 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8061 if (is_attribute_p ("format", TREE_PURPOSE (la)))
8069 /* Subscripting with type char is likely to lose on a machine where
8070 chars are signed. So warn on any machine, but optionally. Don't
8071 warn for unsigned char since that type is safe. Don't warn for
8072 signed char because anyone who uses that must have done so
8073 deliberately. Furthermore, we reduce the false positive load by
8074 warning only for non-constant value of type char. */
8077 warn_array_subscript_with_type_char (tree index)
8079 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8080 && TREE_CODE (index) != INTEGER_CST)
8081 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8084 /* Implement -Wparentheses for the unexpected C precedence rules, to
8085 cover cases like x + y << z which readers are likely to
8086 misinterpret. We have seen an expression in which CODE is a binary
8087 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8088 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8089 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8090 expression was not formed using a binary or unary operator, or it
8091 was enclosed in parentheses. */
8094 warn_about_parentheses (enum tree_code code,
8095 enum tree_code code_left, tree arg_left,
8096 enum tree_code code_right, tree arg_right)
8098 if (!warn_parentheses)
8101 /* This macro tests that the expression ARG with original tree code
8102 CODE appears to be a boolean expression. or the result of folding a
8103 boolean expression. */
8104 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8105 (truth_value_p (TREE_CODE (ARG)) \
8106 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8107 /* Folding may create 0 or 1 integers from other expressions. */ \
8108 || ((CODE) != INTEGER_CST \
8109 && (integer_onep (ARG) || integer_zerop (ARG))))
8114 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8115 warning (OPT_Wparentheses,
8116 "suggest parentheses around %<+%> inside %<<<%>");
8117 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8118 warning (OPT_Wparentheses,
8119 "suggest parentheses around %<-%> inside %<<<%>");
8123 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8124 warning (OPT_Wparentheses,
8125 "suggest parentheses around %<+%> inside %<>>%>");
8126 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8127 warning (OPT_Wparentheses,
8128 "suggest parentheses around %<-%> inside %<>>%>");
8131 case TRUTH_ORIF_EXPR:
8132 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8133 warning (OPT_Wparentheses,
8134 "suggest parentheses around %<&&%> within %<||%>");
8138 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8139 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8140 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8141 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8142 warning (OPT_Wparentheses,
8143 "suggest parentheses around arithmetic in operand of %<|%>");
8144 /* Check cases like x|y==z */
8145 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8146 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8147 warning (OPT_Wparentheses,
8148 "suggest parentheses around comparison in operand of %<|%>");
8149 /* Check cases like !x | y */
8150 else if (code_left == TRUTH_NOT_EXPR
8151 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8152 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8153 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8157 if (code_left == BIT_AND_EXPR
8158 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8159 || code_right == BIT_AND_EXPR
8160 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8161 warning (OPT_Wparentheses,
8162 "suggest parentheses around arithmetic in operand of %<^%>");
8163 /* Check cases like x^y==z */
8164 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8165 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8166 warning (OPT_Wparentheses,
8167 "suggest parentheses around comparison in operand of %<^%>");
8171 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8172 warning (OPT_Wparentheses,
8173 "suggest parentheses around %<+%> in operand of %<&%>");
8174 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8175 warning (OPT_Wparentheses,
8176 "suggest parentheses around %<-%> in operand of %<&%>");
8177 /* Check cases like x&y==z */
8178 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8179 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8180 warning (OPT_Wparentheses,
8181 "suggest parentheses around comparison in operand of %<&%>");
8182 /* Check cases like !x & y */
8183 else if (code_left == TRUTH_NOT_EXPR
8184 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8185 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8186 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8190 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8191 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8192 warning (OPT_Wparentheses,
8193 "suggest parentheses around comparison in operand of %<==%>");
8196 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8197 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8198 warning (OPT_Wparentheses,
8199 "suggest parentheses around comparison in operand of %<!=%>");
8203 if (TREE_CODE_CLASS (code) == tcc_comparison
8204 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
8205 && code_left != NE_EXPR && code_left != EQ_EXPR
8206 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
8207 || (TREE_CODE_CLASS (code_right) == tcc_comparison
8208 && code_right != NE_EXPR && code_right != EQ_EXPR
8209 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
8210 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
8211 "have their mathematical meaning");
8214 #undef NOT_A_BOOLEAN_EXPR_P
8217 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8220 warn_for_unused_label (tree label)
8222 if (!TREE_USED (label))
8224 if (DECL_INITIAL (label))
8225 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
8227 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
8231 #ifndef TARGET_HAS_TARGETCM
8232 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
8235 /* Warn for division by zero according to the value of DIVISOR. LOC
8236 is the location of the division operator. */
8239 warn_for_div_by_zero (location_t loc, tree divisor)
8241 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8242 about division by zero. Do not issue a warning if DIVISOR has a
8243 floating-point type, since we consider 0.0/0.0 a valid way of
8244 generating a NaN. */
8245 if (skip_evaluation == 0
8246 && (integer_zerop (divisor) || fixed_zerop (divisor)))
8247 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
8250 /* Subroutine of build_binary_op. Give warnings for comparisons
8251 between signed and unsigned quantities that may fail. Do the
8252 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8253 so that casts will be considered, but default promotions won't
8256 LOCATION is the location of the comparison operator.
8258 The arguments of this function map directly to local variables
8259 of build_binary_op. */
8262 warn_for_sign_compare (location_t location,
8263 tree orig_op0, tree orig_op1,
8265 tree result_type, enum tree_code resultcode)
8267 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
8268 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
8269 int unsignedp0, unsignedp1;
8271 /* In C++, check for comparison of different enum types. */
8273 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
8274 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
8275 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
8276 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
8278 warning_at (location,
8279 OPT_Wsign_compare, "comparison between types %qT and %qT",
8280 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
8283 /* Do not warn if the comparison is being done in a signed type,
8284 since the signed type will only be chosen if it can represent
8285 all the values of the unsigned type. */
8286 if (!TYPE_UNSIGNED (result_type))
8288 /* Do not warn if both operands are unsigned. */
8289 else if (op0_signed == op1_signed)
8293 tree sop, uop, base_type;
8297 sop = orig_op0, uop = orig_op1;
8299 sop = orig_op1, uop = orig_op0;
8301 STRIP_TYPE_NOPS (sop);
8302 STRIP_TYPE_NOPS (uop);
8303 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
8304 ? TREE_TYPE (result_type) : result_type);
8306 /* Do not warn if the signed quantity is an unsuffixed integer
8307 literal (or some static constant expression involving such
8308 literals or a conditional expression involving such literals)
8309 and it is non-negative. */
8310 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
8312 /* Do not warn if the comparison is an equality operation, the
8313 unsigned quantity is an integral constant, and it would fit
8314 in the result if the result were signed. */
8315 else if (TREE_CODE (uop) == INTEGER_CST
8316 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
8317 && int_fits_type_p (uop, c_common_signed_type (base_type)))
8319 /* In C, do not warn if the unsigned quantity is an enumeration
8320 constant and its maximum value would fit in the result if the
8321 result were signed. */
8322 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
8323 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
8324 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
8325 c_common_signed_type (base_type)))
8328 warning_at (location,
8330 "comparison between signed and unsigned integer expressions");
8333 /* Warn if two unsigned values are being compared in a size larger
8334 than their original size, and one (and only one) is the result of
8335 a `~' operator. This comparison will always fail.
8337 Also warn if one operand is a constant, and the constant does not
8338 have all bits set that are set in the ~ operand when it is
8341 op0 = get_narrower (op0, &unsignedp0);
8342 op1 = get_narrower (op1, &unsignedp1);
8344 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
8345 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
8347 if (TREE_CODE (op0) == BIT_NOT_EXPR)
8348 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
8349 if (TREE_CODE (op1) == BIT_NOT_EXPR)
8350 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
8352 if (host_integerp (op0, 0) || host_integerp (op1, 0))
8355 HOST_WIDE_INT constant, mask;
8359 if (host_integerp (op0, 0))
8362 unsignedp = unsignedp1;
8363 constant = tree_low_cst (op0, 0);
8368 unsignedp = unsignedp0;
8369 constant = tree_low_cst (op1, 0);
8372 bits = TYPE_PRECISION (TREE_TYPE (primop));
8373 if (bits < TYPE_PRECISION (result_type)
8374 && bits < HOST_BITS_PER_LONG && unsignedp)
8376 mask = (~ (HOST_WIDE_INT) 0) << bits;
8377 if ((mask & constant) != mask)
8380 warning (OPT_Wsign_compare,
8381 "promoted ~unsigned is always non-zero");
8383 warning_at (location, OPT_Wsign_compare,
8384 "comparison of promoted ~unsigned with constant");
8388 else if (unsignedp0 && unsignedp1
8389 && (TYPE_PRECISION (TREE_TYPE (op0))
8390 < TYPE_PRECISION (result_type))
8391 && (TYPE_PRECISION (TREE_TYPE (op1))
8392 < TYPE_PRECISION (result_type)))
8393 warning_at (location, OPT_Wsign_compare,
8394 "comparison of promoted ~unsigned with unsigned");
8398 /* Record the types used by the current global variable declaration
8399 being parsed, so that we can decide later to emit their debug info.
8400 Those types are in types_used_by_cur_var_decl, and we are going to
8401 store them in the types_used_by_vars_hash hash table.
8402 DECL is the declaration of the global variable that has been parsed. */
8405 record_types_used_by_current_var_decl (tree decl)
8407 gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
8409 if (types_used_by_cur_var_decl)
8412 for (node = types_used_by_cur_var_decl;
8414 node = TREE_CHAIN (node))
8416 tree type = TREE_PURPOSE (node);
8417 types_used_by_var_decl_insert (type, decl);
8419 types_used_by_cur_var_decl = NULL;
8423 #include "gt-c-common.h"