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;
3401 /* If we still have a decl, it is possible for its address to
3402 be NULL, so we cannot optimize. */
3405 gcc_assert (DECL_WEAK (inner));
3409 if (TREE_SIDE_EFFECTS (inner))
3410 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3411 inner, truthvalue_true_node);
3413 return truthvalue_true_node;
3417 return build_binary_op (EXPR_LOCATION (expr),
3418 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3419 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3420 c_common_truthvalue_conversion (location,
3421 TREE_OPERAND (expr, 0)),
3422 c_common_truthvalue_conversion (location,
3423 TREE_OPERAND (expr, 1)),
3429 /* These don't change whether an object is nonzero or zero. */
3430 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
3434 /* These don't change whether an object is zero or nonzero, but
3435 we can't ignore them if their second arg has side-effects. */
3436 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3437 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3438 TREE_OPERAND (expr, 1),
3439 c_common_truthvalue_conversion
3440 (location, TREE_OPERAND (expr, 0)));
3442 return c_common_truthvalue_conversion (location,
3443 TREE_OPERAND (expr, 0));
3446 /* Distribute the conversion into the arms of a COND_EXPR. */
3447 return fold_build3 (COND_EXPR, truthvalue_type_node,
3448 TREE_OPERAND (expr, 0),
3449 c_common_truthvalue_conversion (location,
3450 TREE_OPERAND (expr, 1)),
3451 c_common_truthvalue_conversion (location,
3452 TREE_OPERAND (expr, 2)));
3455 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3456 since that affects how `default_conversion' will behave. */
3457 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3458 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3460 /* If this is widening the argument, we can ignore it. */
3461 if (TYPE_PRECISION (TREE_TYPE (expr))
3462 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3463 return c_common_truthvalue_conversion (location,
3464 TREE_OPERAND (expr, 0));
3468 if (!TREE_NO_WARNING (expr)
3469 && warn_parentheses)
3471 warning (OPT_Wparentheses,
3472 "suggest parentheses around assignment used as truth value");
3473 TREE_NO_WARNING (expr) = 1;
3481 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3483 tree t = save_expr (expr);
3484 return (build_binary_op
3485 (EXPR_LOCATION (expr),
3486 (TREE_SIDE_EFFECTS (expr)
3487 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3488 c_common_truthvalue_conversion
3490 build_unary_op (location, REALPART_EXPR, t, 0)),
3491 c_common_truthvalue_conversion
3493 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3497 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3499 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3501 (TREE_TYPE (expr))));
3502 return build_binary_op (EXPR_LOCATION (expr),
3503 NE_EXPR, expr, fixed_zero_node, 1);
3506 return build_binary_op (EXPR_LOCATION (expr),
3507 NE_EXPR, expr, integer_zero_node, 1);
3510 static void def_builtin_1 (enum built_in_function fncode,
3512 enum built_in_class fnclass,
3513 tree fntype, tree libtype,
3514 bool both_p, bool fallback_p, bool nonansi_p,
3515 tree fnattrs, bool implicit_p);
3518 /* Apply the TYPE_QUALS to the new DECL. */
3521 c_apply_type_quals_to_decl (int type_quals, tree decl)
3523 tree type = TREE_TYPE (decl);
3525 if (type == error_mark_node)
3528 if (((type_quals & TYPE_QUAL_CONST)
3529 || (type && TREE_CODE (type) == REFERENCE_TYPE))
3530 /* An object declared 'const' is only readonly after it is
3531 initialized. We don't have any way of expressing this currently,
3532 so we need to be conservative and unset TREE_READONLY for types
3533 with constructors. Otherwise aliasing code will ignore stores in
3534 an inline constructor. */
3535 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3536 TREE_READONLY (decl) = 1;
3537 if (type_quals & TYPE_QUAL_VOLATILE)
3539 TREE_SIDE_EFFECTS (decl) = 1;
3540 TREE_THIS_VOLATILE (decl) = 1;
3542 if (type_quals & TYPE_QUAL_RESTRICT)
3544 while (type && TREE_CODE (type) == ARRAY_TYPE)
3545 /* Allow 'restrict' on arrays of pointers.
3546 FIXME currently we just ignore it. */
3547 type = TREE_TYPE (type);
3549 || !POINTER_TYPE_P (type)
3550 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3551 error ("invalid use of %<restrict%>");
3552 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3553 /* Indicate we need to make a unique alias set for this pointer.
3554 We can't do it here because it might be pointing to an
3556 DECL_POINTER_ALIAS_SET (decl) = -2;
3560 /* Hash function for the problem of multiple type definitions in
3561 different files. This must hash all types that will compare
3562 equal via comptypes to the same value. In practice it hashes
3563 on some of the simple stuff and leaves the details to comptypes. */
3566 c_type_hash (const void *p)
3570 const_tree const t = (const_tree) p;
3572 switch (TREE_CODE (t))
3574 /* For pointers, hash on pointee type plus some swizzling. */
3576 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3577 /* Hash on number of elements and total size. */
3580 t2 = TYPE_VALUES (t);
3584 t2 = TYPE_FIELDS (t);
3586 case QUAL_UNION_TYPE:
3588 t2 = TYPE_FIELDS (t);
3592 t2 = TYPE_FIELDS (t);
3597 for (; t2; t2 = TREE_CHAIN (t2))
3599 /* We might have a VLA here. */
3600 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
3603 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3604 return ((size << 24) | (i << shift));
3607 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3609 /* Return the typed-based alias set for T, which may be an expression
3610 or a type. Return -1 if we don't do anything special. */
3613 c_common_get_alias_set (tree t)
3618 /* Permit type-punning when accessing a union, provided the access
3619 is directly through the union. For example, this code does not
3620 permit taking the address of a union member and then storing
3621 through it. Even the type-punning allowed here is a GCC
3622 extension, albeit a common and useful one; the C standard says
3623 that such accesses have implementation-defined behavior. */
3625 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3626 u = TREE_OPERAND (u, 0))
3627 if (TREE_CODE (u) == COMPONENT_REF
3628 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3631 /* That's all the expressions we handle specially. */
3635 /* The C standard guarantees that any object may be accessed via an
3636 lvalue that has character type. */
3637 if (t == char_type_node
3638 || t == signed_char_type_node
3639 || t == unsigned_char_type_node)
3642 /* The C standard specifically allows aliasing between signed and
3643 unsigned variants of the same type. We treat the signed
3644 variant as canonical. */
3645 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3647 tree t1 = c_common_signed_type (t);
3649 /* t1 == t can happen for boolean nodes which are always unsigned. */
3651 return get_alias_set (t1);
3653 else if (POINTER_TYPE_P (t))
3657 /* Unfortunately, there is no canonical form of a pointer type.
3658 In particular, if we have `typedef int I', then `int *', and
3659 `I *' are different types. So, we have to pick a canonical
3660 representative. We do this below.
3662 Technically, this approach is actually more conservative that
3663 it needs to be. In particular, `const int *' and `int *'
3664 should be in different alias sets, according to the C and C++
3665 standard, since their types are not the same, and so,
3666 technically, an `int **' and `const int **' cannot point at
3669 But, the standard is wrong. In particular, this code is
3674 const int* const* cipp = ipp;
3676 And, it doesn't make sense for that to be legal unless you
3677 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3678 the pointed-to types. This issue has been reported to the
3680 t1 = build_type_no_quals (t);
3682 return get_alias_set (t1);
3685 /* Handle the case of multiple type nodes referring to "the same" type,
3686 which occurs with IMA. These share an alias set. FIXME: Currently only
3687 C90 is handled. (In C99 type compatibility is not transitive, which
3688 complicates things mightily. The alias set splay trees can theoretically
3689 represent this, but insertion is tricky when you consider all the
3690 different orders things might arrive in.) */
3692 if (c_language != clk_c || flag_isoc99)
3695 /* Save time if there's only one input file. */
3696 if (num_in_fnames == 1)
3699 /* Pointers need special handling if they point to any type that
3700 needs special handling (below). */
3701 if (TREE_CODE (t) == POINTER_TYPE)
3704 /* Find bottom type under any nested POINTERs. */
3705 for (t2 = TREE_TYPE (t);
3706 TREE_CODE (t2) == POINTER_TYPE;
3707 t2 = TREE_TYPE (t2))
3709 if (TREE_CODE (t2) != RECORD_TYPE
3710 && TREE_CODE (t2) != ENUMERAL_TYPE
3711 && TREE_CODE (t2) != QUAL_UNION_TYPE
3712 && TREE_CODE (t2) != UNION_TYPE)
3714 if (TYPE_SIZE (t2) == 0)
3717 /* These are the only cases that need special handling. */
3718 if (TREE_CODE (t) != RECORD_TYPE
3719 && TREE_CODE (t) != ENUMERAL_TYPE
3720 && TREE_CODE (t) != QUAL_UNION_TYPE
3721 && TREE_CODE (t) != UNION_TYPE
3722 && TREE_CODE (t) != POINTER_TYPE)
3725 if (TYPE_SIZE (t) == 0)
3728 /* Look up t in hash table. Only one of the compatible types within each
3729 alias set is recorded in the table. */
3730 if (!type_hash_table)
3731 type_hash_table = htab_create_ggc (1021, c_type_hash,
3732 (htab_eq) lang_hooks.types_compatible_p,
3734 slot = htab_find_slot (type_hash_table, t, INSERT);
3737 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3738 return TYPE_ALIAS_SET ((tree)*slot);
3741 /* Our caller will assign and record (in t) a new alias set; all we need
3742 to do is remember t in the hash table. */
3748 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3749 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3750 flag controls whether we should diagnose possibly ill-formed
3751 constructs or not. */
3754 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3756 const char *op_name;
3758 enum tree_code type_code = TREE_CODE (type);
3760 op_name = is_sizeof ? "sizeof" : "__alignof__";
3762 if (type_code == FUNCTION_TYPE)
3766 if (complain && (pedantic || warn_pointer_arith))
3767 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3768 "invalid application of %<sizeof%> to a function type");
3770 return error_mark_node;
3771 value = size_one_node;
3774 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3776 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3778 if (type_code == VOID_TYPE
3779 && complain && (pedantic || warn_pointer_arith))
3780 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3781 "invalid application of %qs to a void type", op_name);
3783 return error_mark_node;
3784 value = size_one_node;
3786 else if (!COMPLETE_TYPE_P (type))
3789 error ("invalid application of %qs to incomplete type %qT ",
3791 value = size_zero_node;
3796 /* Convert in case a char is more than one unit. */
3797 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3798 size_int (TYPE_PRECISION (char_type_node)
3801 value = size_int (TYPE_ALIGN_UNIT (type));
3804 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3805 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3806 never happen. However, this node should really have type
3807 `size_t', which is just a typedef for an ordinary integer type. */
3808 value = fold_convert (size_type_node, value);
3809 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3814 /* Implement the __alignof keyword: Return the minimum required
3815 alignment of EXPR, measured in bytes. For VAR_DECLs,
3816 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3817 from an "aligned" __attribute__ specification). */
3820 c_alignof_expr (tree expr)
3824 if (VAR_OR_FUNCTION_DECL_P (expr))
3825 t = size_int (DECL_ALIGN_UNIT (expr));
3827 else if (TREE_CODE (expr) == COMPONENT_REF
3828 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3830 error ("%<__alignof%> applied to a bit-field");
3833 else if (TREE_CODE (expr) == COMPONENT_REF
3834 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3835 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3837 else if (TREE_CODE (expr) == INDIRECT_REF)
3839 tree t = TREE_OPERAND (expr, 0);
3841 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3843 while (CONVERT_EXPR_P (t)
3844 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3848 t = TREE_OPERAND (t, 0);
3849 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3850 if (thisalign > bestalign)
3851 best = t, bestalign = thisalign;
3853 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3856 return c_alignof (TREE_TYPE (expr));
3858 return fold_convert (size_type_node, t);
3861 /* Handle C and C++ default attributes. */
3863 enum built_in_attribute
3865 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3866 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3867 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3868 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3869 #include "builtin-attrs.def"
3870 #undef DEF_ATTR_NULL_TREE
3872 #undef DEF_ATTR_IDENT
3873 #undef DEF_ATTR_TREE_LIST
3877 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3879 static void c_init_attributes (void);
3883 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3884 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3885 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3886 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3887 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3888 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3889 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3890 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3891 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3892 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3893 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3894 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3895 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3896 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3897 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3899 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3900 #include "builtin-types.def"
3901 #undef DEF_PRIMITIVE_TYPE
3902 #undef DEF_FUNCTION_TYPE_0
3903 #undef DEF_FUNCTION_TYPE_1
3904 #undef DEF_FUNCTION_TYPE_2
3905 #undef DEF_FUNCTION_TYPE_3
3906 #undef DEF_FUNCTION_TYPE_4
3907 #undef DEF_FUNCTION_TYPE_5
3908 #undef DEF_FUNCTION_TYPE_6
3909 #undef DEF_FUNCTION_TYPE_7
3910 #undef DEF_FUNCTION_TYPE_VAR_0
3911 #undef DEF_FUNCTION_TYPE_VAR_1
3912 #undef DEF_FUNCTION_TYPE_VAR_2
3913 #undef DEF_FUNCTION_TYPE_VAR_3
3914 #undef DEF_FUNCTION_TYPE_VAR_4
3915 #undef DEF_FUNCTION_TYPE_VAR_5
3916 #undef DEF_POINTER_TYPE
3920 typedef enum c_builtin_type builtin_type;
3922 /* A temporary array for c_common_nodes_and_builtins. Used in
3923 communication with def_fn_type. */
3924 static tree builtin_types[(int) BT_LAST + 1];
3926 /* A helper function for c_common_nodes_and_builtins. Build function type
3927 for DEF with return type RET and N arguments. If VAR is true, then the
3928 function should be variadic after those N arguments.
3930 Takes special care not to ICE if any of the types involved are
3931 error_mark_node, which indicates that said type is not in fact available
3932 (see builtin_type_for_size). In which case the function type as a whole
3933 should be error_mark_node. */
3936 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3938 tree args = NULL, t;
3943 for (i = 0; i < n; ++i)
3945 builtin_type a = (builtin_type) va_arg (list, int);
3946 t = builtin_types[a];
3947 if (t == error_mark_node)
3949 args = tree_cons (NULL_TREE, t, args);
3953 args = nreverse (args);
3955 args = chainon (args, void_list_node);
3957 t = builtin_types[ret];
3958 if (t == error_mark_node)
3960 t = build_function_type (t, args);
3963 builtin_types[def] = t;
3966 /* Build builtin functions common to both C and C++ language
3970 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3972 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3973 builtin_types[ENUM] = VALUE;
3974 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3975 def_fn_type (ENUM, RETURN, 0, 0);
3976 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3977 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3978 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3979 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3980 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3981 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3982 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3983 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3984 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3985 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3986 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3988 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3989 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3991 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3992 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3993 def_fn_type (ENUM, RETURN, 1, 0);
3994 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3995 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3996 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3997 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3998 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3999 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4000 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4001 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4002 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4003 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4004 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4005 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4007 #include "builtin-types.def"
4009 #undef DEF_PRIMITIVE_TYPE
4010 #undef DEF_FUNCTION_TYPE_1
4011 #undef DEF_FUNCTION_TYPE_2
4012 #undef DEF_FUNCTION_TYPE_3
4013 #undef DEF_FUNCTION_TYPE_4
4014 #undef DEF_FUNCTION_TYPE_5
4015 #undef DEF_FUNCTION_TYPE_6
4016 #undef DEF_FUNCTION_TYPE_VAR_0
4017 #undef DEF_FUNCTION_TYPE_VAR_1
4018 #undef DEF_FUNCTION_TYPE_VAR_2
4019 #undef DEF_FUNCTION_TYPE_VAR_3
4020 #undef DEF_FUNCTION_TYPE_VAR_4
4021 #undef DEF_FUNCTION_TYPE_VAR_5
4022 #undef DEF_POINTER_TYPE
4023 builtin_types[(int) BT_LAST] = NULL_TREE;
4025 c_init_attributes ();
4027 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4028 NONANSI_P, ATTRS, IMPLICIT, COND) \
4030 def_builtin_1 (ENUM, NAME, CLASS, \
4031 builtin_types[(int) TYPE], \
4032 builtin_types[(int) LIBTYPE], \
4033 BOTH_P, FALLBACK_P, NONANSI_P, \
4034 built_in_attributes[(int) ATTRS], IMPLICIT);
4035 #include "builtins.def"
4038 targetm.init_builtins ();
4040 build_common_builtin_nodes ();
4046 /* Build tree nodes and builtin functions common to both C and C++ language
4050 c_common_nodes_and_builtins (void)
4052 int char16_type_size;
4053 int char32_type_size;
4054 int wchar_type_size;
4055 tree array_domain_type;
4056 tree va_list_ref_type_node;
4057 tree va_list_arg_type_node;
4059 /* Define `int' and `char' first so that dbx will output them first. */
4060 record_builtin_type (RID_INT, NULL, integer_type_node);
4061 record_builtin_type (RID_CHAR, "char", char_type_node);
4063 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4064 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4065 but not C. Are the conditionals here needed? */
4066 if (c_dialect_cxx ())
4067 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4068 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4069 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4070 record_builtin_type (RID_MAX, "long unsigned int",
4071 long_unsigned_type_node);
4072 if (c_dialect_cxx ())
4073 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4074 record_builtin_type (RID_MAX, "long long int",
4075 long_long_integer_type_node);
4076 record_builtin_type (RID_MAX, "long long unsigned int",
4077 long_long_unsigned_type_node);
4078 if (c_dialect_cxx ())
4079 record_builtin_type (RID_MAX, "long long unsigned",
4080 long_long_unsigned_type_node);
4081 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4082 record_builtin_type (RID_MAX, "short unsigned int",
4083 short_unsigned_type_node);
4084 if (c_dialect_cxx ())
4085 record_builtin_type (RID_MAX, "unsigned short",
4086 short_unsigned_type_node);
4088 /* Define both `signed char' and `unsigned char'. */
4089 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4090 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4092 /* These are types that c_common_type_for_size and
4093 c_common_type_for_mode use. */
4094 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4096 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4098 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4100 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4102 #if HOST_BITS_PER_WIDE_INT >= 64
4103 if (targetm.scalar_mode_supported_p (TImode))
4104 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4105 get_identifier ("__int128_t"),
4108 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4109 unsigned_intQI_type_node));
4110 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4111 unsigned_intHI_type_node));
4112 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4113 unsigned_intSI_type_node));
4114 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4115 unsigned_intDI_type_node));
4116 #if HOST_BITS_PER_WIDE_INT >= 64
4117 if (targetm.scalar_mode_supported_p (TImode))
4118 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4119 get_identifier ("__uint128_t"),
4120 unsigned_intTI_type_node));
4123 /* Create the widest literal types. */
4124 widest_integer_literal_type_node
4125 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4126 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4127 widest_integer_literal_type_node));
4129 widest_unsigned_literal_type_node
4130 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4131 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4132 widest_unsigned_literal_type_node));
4134 /* `unsigned long' is the standard type for sizeof.
4135 Note that stddef.h uses `unsigned long',
4136 and this must agree, even if long and int are the same size. */
4138 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4139 signed_size_type_node = c_common_signed_type (size_type_node);
4140 set_sizetype (size_type_node);
4143 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4145 build_common_tree_nodes_2 (flag_short_double);
4147 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4148 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4149 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4151 /* Only supported decimal floating point extension if the target
4152 actually supports underlying modes. */
4153 if (targetm.scalar_mode_supported_p (SDmode)
4154 && targetm.scalar_mode_supported_p (DDmode)
4155 && targetm.scalar_mode_supported_p (TDmode))
4157 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4158 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4159 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4162 if (targetm.fixed_point_supported_p ())
4164 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4165 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4166 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4167 record_builtin_type (RID_MAX, "long long _Fract",
4168 long_long_fract_type_node);
4169 record_builtin_type (RID_MAX, "unsigned short _Fract",
4170 unsigned_short_fract_type_node);
4171 record_builtin_type (RID_MAX, "unsigned _Fract",
4172 unsigned_fract_type_node);
4173 record_builtin_type (RID_MAX, "unsigned long _Fract",
4174 unsigned_long_fract_type_node);
4175 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4176 unsigned_long_long_fract_type_node);
4177 record_builtin_type (RID_MAX, "_Sat short _Fract",
4178 sat_short_fract_type_node);
4179 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4180 record_builtin_type (RID_MAX, "_Sat long _Fract",
4181 sat_long_fract_type_node);
4182 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4183 sat_long_long_fract_type_node);
4184 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4185 sat_unsigned_short_fract_type_node);
4186 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4187 sat_unsigned_fract_type_node);
4188 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4189 sat_unsigned_long_fract_type_node);
4190 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4191 sat_unsigned_long_long_fract_type_node);
4192 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4193 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4194 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4195 record_builtin_type (RID_MAX, "long long _Accum",
4196 long_long_accum_type_node);
4197 record_builtin_type (RID_MAX, "unsigned short _Accum",
4198 unsigned_short_accum_type_node);
4199 record_builtin_type (RID_MAX, "unsigned _Accum",
4200 unsigned_accum_type_node);
4201 record_builtin_type (RID_MAX, "unsigned long _Accum",
4202 unsigned_long_accum_type_node);
4203 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4204 unsigned_long_long_accum_type_node);
4205 record_builtin_type (RID_MAX, "_Sat short _Accum",
4206 sat_short_accum_type_node);
4207 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4208 record_builtin_type (RID_MAX, "_Sat long _Accum",
4209 sat_long_accum_type_node);
4210 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4211 sat_long_long_accum_type_node);
4212 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4213 sat_unsigned_short_accum_type_node);
4214 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4215 sat_unsigned_accum_type_node);
4216 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4217 sat_unsigned_long_accum_type_node);
4218 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4219 sat_unsigned_long_long_accum_type_node);
4223 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4224 get_identifier ("complex int"),
4225 complex_integer_type_node));
4226 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4227 get_identifier ("complex float"),
4228 complex_float_type_node));
4229 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4230 get_identifier ("complex double"),
4231 complex_double_type_node));
4232 lang_hooks.decls.pushdecl
4233 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4234 complex_long_double_type_node));
4236 if (c_dialect_cxx ())
4237 /* For C++, make fileptr_type_node a distinct void * type until
4238 FILE type is defined. */
4239 fileptr_type_node = build_variant_type_copy (ptr_type_node);
4241 record_builtin_type (RID_VOID, NULL, void_type_node);
4243 /* Set the TYPE_NAME for any variants that were built before
4244 record_builtin_type gave names to the built-in types. */
4246 tree void_name = TYPE_NAME (void_type_node);
4247 TYPE_NAME (void_type_node) = NULL_TREE;
4248 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4250 TYPE_NAME (void_type_node) = void_name;
4253 /* This node must not be shared. */
4254 void_zero_node = make_node (INTEGER_CST);
4255 TREE_TYPE (void_zero_node) = void_type_node;
4257 void_list_node = build_void_list_node ();
4259 /* Make a type to be the domain of a few array types
4260 whose domains don't really matter.
4261 200 is small enough that it always fits in size_t
4262 and large enough that it can hold most function names for the
4263 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4264 array_domain_type = build_index_type (size_int (200));
4266 /* Make a type for arrays of characters.
4267 With luck nothing will ever really depend on the length of this
4269 char_array_type_node
4270 = build_array_type (char_type_node, array_domain_type);
4272 /* Likewise for arrays of ints. */
4274 = build_array_type (integer_type_node, array_domain_type);
4276 string_type_node = build_pointer_type (char_type_node);
4277 const_string_type_node
4278 = build_pointer_type (build_qualified_type
4279 (char_type_node, TYPE_QUAL_CONST));
4281 /* This is special for C++ so functions can be overloaded. */
4282 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4283 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4284 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4285 if (c_dialect_cxx ())
4287 if (TYPE_UNSIGNED (wchar_type_node))
4288 wchar_type_node = make_unsigned_type (wchar_type_size);
4290 wchar_type_node = make_signed_type (wchar_type_size);
4291 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4295 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
4296 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
4299 /* This is for wide string constants. */
4300 wchar_array_type_node
4301 = build_array_type (wchar_type_node, array_domain_type);
4303 /* Define 'char16_t'. */
4304 char16_type_node = get_identifier (CHAR16_TYPE);
4305 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4306 char16_type_size = TYPE_PRECISION (char16_type_node);
4307 if (c_dialect_cxx ())
4309 char16_type_node = make_unsigned_type (char16_type_size);
4311 if (cxx_dialect == cxx0x)
4312 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4315 /* This is for UTF-16 string constants. */
4316 char16_array_type_node
4317 = build_array_type (char16_type_node, array_domain_type);
4319 /* Define 'char32_t'. */
4320 char32_type_node = get_identifier (CHAR32_TYPE);
4321 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4322 char32_type_size = TYPE_PRECISION (char32_type_node);
4323 if (c_dialect_cxx ())
4325 char32_type_node = make_unsigned_type (char32_type_size);
4327 if (cxx_dialect == cxx0x)
4328 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4331 /* This is for UTF-32 string constants. */
4332 char32_array_type_node
4333 = build_array_type (char32_type_node, array_domain_type);
4336 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4339 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4341 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4343 default_function_type = build_function_type (integer_type_node, NULL_TREE);
4345 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
4346 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
4348 lang_hooks.decls.pushdecl
4349 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
4350 va_list_type_node));
4351 #ifdef TARGET_ENUM_VA_LIST
4356 for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
4358 lang_hooks.decls.pushdecl
4359 (build_decl (TYPE_DECL, get_identifier (pname),
4366 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4368 va_list_arg_type_node = va_list_ref_type_node =
4369 build_pointer_type (TREE_TYPE (va_list_type_node));
4373 va_list_arg_type_node = va_list_type_node;
4374 va_list_ref_type_node = build_reference_type (va_list_type_node);
4377 if (!flag_preprocess_only)
4378 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4380 main_identifier_node = get_identifier ("main");
4382 /* Create the built-in __null node. It is important that this is
4384 null_node = make_node (INTEGER_CST);
4385 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
4387 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4388 memset (builtin_types, 0, sizeof (builtin_types));
4391 /* Look up the function in built_in_decls that corresponds to DECL
4392 and set ASMSPEC as its user assembler name. DECL must be a
4393 function decl that declares a builtin. */
4396 set_builtin_user_assembler_name (tree decl, const char *asmspec)
4399 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
4400 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
4403 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
4404 set_user_assembler_name (builtin, asmspec);
4405 switch (DECL_FUNCTION_CODE (decl))
4407 case BUILT_IN_MEMCPY:
4408 init_block_move_fn (asmspec);
4409 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
4411 case BUILT_IN_MEMSET:
4412 init_block_clear_fn (asmspec);
4413 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
4415 case BUILT_IN_MEMMOVE:
4416 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
4418 case BUILT_IN_MEMCMP:
4419 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
4421 case BUILT_IN_ABORT:
4422 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
4429 /* The number of named compound-literals generated thus far. */
4430 static GTY(()) int compound_literal_number;
4432 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4435 set_compound_literal_name (tree decl)
4438 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4439 compound_literal_number);
4440 compound_literal_number++;
4441 DECL_NAME (decl) = get_identifier (name);
4445 build_va_arg (tree expr, tree type)
4447 return build1 (VA_ARG_EXPR, type, expr);
4451 /* Linked list of disabled built-in functions. */
4453 typedef struct disabled_builtin
4456 struct disabled_builtin *next;
4458 static disabled_builtin *disabled_builtins = NULL;
4460 static bool builtin_function_disabled_p (const char *);
4462 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4463 begins with "__builtin_", give an error. */
4466 disable_builtin_function (const char *name)
4468 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4469 error ("cannot disable built-in function %qs", name);
4472 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4473 new_disabled_builtin->name = name;
4474 new_disabled_builtin->next = disabled_builtins;
4475 disabled_builtins = new_disabled_builtin;
4480 /* Return true if the built-in function NAME has been disabled, false
4484 builtin_function_disabled_p (const char *name)
4486 disabled_builtin *p;
4487 for (p = disabled_builtins; p != NULL; p = p->next)
4489 if (strcmp (name, p->name) == 0)
4496 /* Worker for DEF_BUILTIN.
4497 Possibly define a builtin function with one or two names.
4498 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4499 nonansi_p and flag_no_nonansi_builtin. */
4502 def_builtin_1 (enum built_in_function fncode,
4504 enum built_in_class fnclass,
4505 tree fntype, tree libtype,
4506 bool both_p, bool fallback_p, bool nonansi_p,
4507 tree fnattrs, bool implicit_p)
4510 const char *libname;
4512 if (fntype == error_mark_node)
4515 gcc_assert ((!both_p && !fallback_p)
4516 || !strncmp (name, "__builtin_",
4517 strlen ("__builtin_")));
4519 libname = name + strlen ("__builtin_");
4520 decl = add_builtin_function (name, fntype, fncode, fnclass,
4521 (fallback_p ? libname : NULL),
4524 && !flag_no_builtin && !builtin_function_disabled_p (libname)
4525 && !(nonansi_p && flag_no_nonansi_builtin))
4526 add_builtin_function (libname, libtype, fncode, fnclass,
4529 built_in_decls[(int) fncode] = decl;
4531 implicit_built_in_decls[(int) fncode] = decl;
4534 /* Nonzero if the type T promotes to int. This is (nearly) the
4535 integral promotions defined in ISO C99 6.3.1.1/2. */
4538 c_promoting_integer_type_p (const_tree t)
4540 switch (TREE_CODE (t))
4543 return (TYPE_MAIN_VARIANT (t) == char_type_node
4544 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
4545 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
4546 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
4547 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
4548 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
4551 /* ??? Technically all enumerations not larger than an int
4552 promote to an int. But this is used along code paths
4553 that only want to notice a size change. */
4554 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
4564 /* Return 1 if PARMS specifies a fixed number of parameters
4565 and none of their types is affected by default promotions. */
4568 self_promoting_args_p (const_tree parms)
4571 for (t = parms; t; t = TREE_CHAIN (t))
4573 tree type = TREE_VALUE (t);
4575 if (type == error_mark_node)
4578 if (TREE_CHAIN (t) == 0 && type != void_type_node)
4584 if (TYPE_MAIN_VARIANT (type) == float_type_node)
4587 if (c_promoting_integer_type_p (type))
4593 /* Recursively remove any '*' or '&' operator from TYPE. */
4595 strip_pointer_operator (tree t)
4597 while (POINTER_TYPE_P (t))
4602 /* Recursively remove pointer or array type from TYPE. */
4604 strip_pointer_or_array_types (tree t)
4606 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
4611 /* Used to compare case labels. K1 and K2 are actually tree nodes
4612 representing case labels, or NULL_TREE for a `default' label.
4613 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4614 K2, and 0 if K1 and K2 are equal. */
4617 case_compare (splay_tree_key k1, splay_tree_key k2)
4619 /* Consider a NULL key (such as arises with a `default' label) to be
4620 smaller than anything else. */
4626 return tree_int_cst_compare ((tree) k1, (tree) k2);
4629 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4630 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4631 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4632 case label was declared using the usual C/C++ syntax, rather than
4633 the GNU case range extension. CASES is a tree containing all the
4634 case ranges processed so far; COND is the condition for the
4635 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
4636 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
4639 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
4640 tree low_value, tree high_value)
4645 splay_tree_node node;
4647 /* Create the LABEL_DECL itself. */
4648 label = create_artificial_label ();
4650 /* If there was an error processing the switch condition, bail now
4651 before we get more confused. */
4652 if (!cond || cond == error_mark_node)
4655 if ((low_value && TREE_TYPE (low_value)
4656 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4657 || (high_value && TREE_TYPE (high_value)
4658 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4660 error ("pointers are not permitted as case values");
4664 /* Case ranges are a GNU extension. */
4666 pedwarn (input_location, OPT_pedantic,
4667 "range expressions in switch statements are non-standard");
4669 type = TREE_TYPE (cond);
4672 low_value = check_case_value (low_value);
4673 low_value = convert_and_check (type, low_value);
4674 if (low_value == error_mark_node)
4679 high_value = check_case_value (high_value);
4680 high_value = convert_and_check (type, high_value);
4681 if (high_value == error_mark_node)
4685 if (low_value && high_value)
4687 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4688 really a case range, even though it was written that way.
4689 Remove the HIGH_VALUE to simplify later processing. */
4690 if (tree_int_cst_equal (low_value, high_value))
4691 high_value = NULL_TREE;
4692 else if (!tree_int_cst_lt (low_value, high_value))
4693 warning (0, "empty range specified");
4696 /* See if the case is in range of the type of the original testing
4697 expression. If both low_value and high_value are out of range,
4698 don't insert the case label and return NULL_TREE. */
4700 && !check_case_bounds (type, orig_type,
4701 &low_value, high_value ? &high_value : NULL))
4704 /* Look up the LOW_VALUE in the table of case labels we already
4706 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4707 /* If there was not an exact match, check for overlapping ranges.
4708 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4709 that's a `default' label and the only overlap is an exact match. */
4710 if (!node && (low_value || high_value))
4712 splay_tree_node low_bound;
4713 splay_tree_node high_bound;
4715 /* Even though there wasn't an exact match, there might be an
4716 overlap between this case range and another case range.
4717 Since we've (inductively) not allowed any overlapping case
4718 ranges, we simply need to find the greatest low case label
4719 that is smaller that LOW_VALUE, and the smallest low case
4720 label that is greater than LOW_VALUE. If there is an overlap
4721 it will occur in one of these two ranges. */
4722 low_bound = splay_tree_predecessor (cases,
4723 (splay_tree_key) low_value);
4724 high_bound = splay_tree_successor (cases,
4725 (splay_tree_key) low_value);
4727 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4728 the LOW_VALUE, so there is no need to check unless the
4729 LOW_BOUND is in fact itself a case range. */
4731 && CASE_HIGH ((tree) low_bound->value)
4732 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4735 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4736 range is bigger than the low end of the current range, so we
4737 are only interested if the current range is a real range, and
4738 not an ordinary case label. */
4741 && (tree_int_cst_compare ((tree) high_bound->key,
4746 /* If there was an overlap, issue an error. */
4749 tree duplicate = CASE_LABEL ((tree) node->value);
4753 error ("duplicate (or overlapping) case value");
4754 error ("%Jthis is the first entry overlapping that value", duplicate);
4758 error ("duplicate case value") ;
4759 error ("%Jpreviously used here", duplicate);
4763 error ("multiple default labels in one switch");
4764 error ("%Jthis is the first default label", duplicate);
4769 /* Add a CASE_LABEL to the statement-tree. */
4770 case_label = add_stmt (build_case_label (low_value, high_value, label));
4771 /* Register this case label in the splay tree. */
4772 splay_tree_insert (cases,
4773 (splay_tree_key) low_value,
4774 (splay_tree_value) case_label);
4779 /* Add a label so that the back-end doesn't think that the beginning of
4780 the switch is unreachable. Note that we do not add a case label, as
4781 that just leads to duplicates and thence to failure later on. */
4784 tree t = create_artificial_label ();
4785 add_stmt (build_stmt (LABEL_EXPR, t));
4787 return error_mark_node;
4790 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4791 Used to verify that case values match up with enumerator values. */
4794 match_case_to_enum_1 (tree key, tree type, tree label)
4796 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4798 /* ??? Not working too hard to print the double-word value.
4799 Should perhaps be done with %lwd in the diagnostic routines? */
4800 if (TREE_INT_CST_HIGH (key) == 0)
4801 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4802 TREE_INT_CST_LOW (key));
4803 else if (!TYPE_UNSIGNED (type)
4804 && TREE_INT_CST_HIGH (key) == -1
4805 && TREE_INT_CST_LOW (key) != 0)
4806 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4807 -TREE_INT_CST_LOW (key));
4809 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4810 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
4811 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
4813 if (TYPE_NAME (type) == 0)
4814 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4815 "%Jcase value %qs not in enumerated type",
4816 CASE_LABEL (label), buf);
4818 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4819 "%Jcase value %qs not in enumerated type %qT",
4820 CASE_LABEL (label), buf, type);
4823 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4824 Used to verify that case values match up with enumerator values. */
4827 match_case_to_enum (splay_tree_node node, void *data)
4829 tree label = (tree) node->value;
4830 tree type = (tree) data;
4832 /* Skip default case. */
4833 if (!CASE_LOW (label))
4836 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4837 when we did our enum->case scan. Reset our scratch bit after. */
4838 if (!CASE_LOW_SEEN (label))
4839 match_case_to_enum_1 (CASE_LOW (label), type, label);
4841 CASE_LOW_SEEN (label) = 0;
4843 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4844 not set, that means that CASE_HIGH did not appear when we did our
4845 enum->case scan. Reset our scratch bit after. */
4846 if (CASE_HIGH (label))
4848 if (!CASE_HIGH_SEEN (label))
4849 match_case_to_enum_1 (CASE_HIGH (label), type, label);
4851 CASE_HIGH_SEEN (label) = 0;
4857 /* Handle -Wswitch*. Called from the front end after parsing the
4858 switch construct. */
4859 /* ??? Should probably be somewhere generic, since other languages
4860 besides C and C++ would want this. At the moment, however, C/C++
4861 are the only tree-ssa languages that support enumerations at all,
4862 so the point is moot. */
4865 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4866 tree type, tree cond)
4868 splay_tree_node default_node;
4869 splay_tree_node node;
4871 int saved_warn_switch;
4873 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4876 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4878 warning (OPT_Wswitch_default, "%Hswitch missing default case",
4881 /* From here on, we only care about about enumerated types. */
4882 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4885 /* If the switch expression was an enumerated type, check that
4886 exactly all enumeration literals are covered by the cases.
4887 The check is made when -Wswitch was specified and there is no
4888 default case, or when -Wswitch-enum was specified. */
4890 if (!warn_switch_enum
4891 && !(warn_switch && !default_node))
4894 /* Clearing COND if it is not an integer constant simplifies
4895 the tests inside the loop below. */
4896 if (TREE_CODE (cond) != INTEGER_CST)
4899 /* The time complexity here is O(N*lg(N)) worst case, but for the
4900 common case of monotonically increasing enumerators, it is
4901 O(N), since the nature of the splay tree will keep the next
4902 element adjacent to the root at all times. */
4904 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4906 tree value = TREE_VALUE (chain);
4907 if (TREE_CODE (value) == CONST_DECL)
4908 value = DECL_INITIAL (value);
4909 node = splay_tree_lookup (cases, (splay_tree_key) value);
4912 /* Mark the CASE_LOW part of the case entry as seen. */
4913 tree label = (tree) node->value;
4914 CASE_LOW_SEEN (label) = 1;
4918 /* Even though there wasn't an exact match, there might be a
4919 case range which includes the enumerator's value. */
4920 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4921 if (node && CASE_HIGH ((tree) node->value))
4923 tree label = (tree) node->value;
4924 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4927 /* If we match the upper bound exactly, mark the CASE_HIGH
4928 part of the case entry as seen. */
4930 CASE_HIGH_SEEN (label) = 1;
4935 /* We've now determined that this enumerated literal isn't
4936 handled by the case labels of the switch statement. */
4938 /* If the switch expression is a constant, we only really care
4939 about whether that constant is handled by the switch. */
4940 if (cond && tree_int_cst_compare (cond, value))
4943 /* If there is a default_node, the only relevant option is
4944 Wswitch-enum. Otherwise, if both are enabled then we prefer
4945 to warn using -Wswitch because -Wswitch is enabled by -Wall
4946 while -Wswitch-enum is explicit. */
4947 warning ((default_node || !warn_switch)
4948 ? OPT_Wswitch_enum : OPT_Wswitch,
4949 "%Henumeration value %qE not handled in switch",
4950 &switch_location, TREE_PURPOSE (chain));
4953 /* Warn if there are case expressions that don't correspond to
4954 enumerators. This can occur since C and C++ don't enforce
4955 type-checking of assignments to enumeration variables.
4957 The time complexity here is now always O(N) worst case, since
4958 we should have marked both the lower bound and upper bound of
4959 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4960 above. This scan also resets those fields. */
4962 /* If there is a default_node, the only relevant option is
4963 Wswitch-enum. Otherwise, if both are enabled then we prefer
4964 to warn using -Wswitch because -Wswitch is enabled by -Wall
4965 while -Wswitch-enum is explicit. */
4966 saved_warn_switch = warn_switch;
4969 splay_tree_foreach (cases, match_case_to_enum, type);
4970 warn_switch = saved_warn_switch;
4974 /* Finish an expression taking the address of LABEL (an
4975 IDENTIFIER_NODE). Returns an expression for the address.
4977 LOC is the location for the expression returned. */
4980 finish_label_address_expr (tree label, location_t loc)
4984 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
4986 if (label == error_mark_node)
4987 return error_mark_node;
4989 label = lookup_label (label);
4990 if (label == NULL_TREE)
4991 result = null_pointer_node;
4994 TREE_USED (label) = 1;
4995 result = build1 (ADDR_EXPR, ptr_type_node, label);
4996 /* The current function in not necessarily uninlinable.
4997 Computed gotos are incompatible with inlining, but the value
4998 here could be used only in a diagnostic, for example. */
4999 protected_set_expr_location (result, loc);
5005 /* Hook used by expand_expr to expand language-specific tree codes. */
5006 /* The only things that should go here are bits needed to expand
5007 constant initializers. Everything else should be handled by the
5008 gimplification routines. */
5011 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
5012 int modifiera /* Actually enum expand_modifier. */,
5015 enum expand_modifier modifier = (enum expand_modifier) modifiera;
5016 switch (TREE_CODE (exp))
5018 case COMPOUND_LITERAL_EXPR:
5020 /* Initialize the anonymous variable declared in the compound
5021 literal, then return the variable. */
5022 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
5023 emit_local_var (decl);
5024 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
5032 /* Hook used by staticp to handle language-specific tree codes. */
5035 c_staticp (tree exp)
5037 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
5038 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
5043 /* Given a boolean expression ARG, return a tree representing an increment
5044 or decrement (as indicated by CODE) of ARG. The front end must check for
5045 invalid cases (e.g., decrement in C++). */
5047 boolean_increment (enum tree_code code, tree arg)
5050 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5052 arg = stabilize_reference (arg);
5055 case PREINCREMENT_EXPR:
5056 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5058 case POSTINCREMENT_EXPR:
5059 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5060 arg = save_expr (arg);
5061 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5062 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5064 case PREDECREMENT_EXPR:
5065 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5066 invert_truthvalue (arg));
5068 case POSTDECREMENT_EXPR:
5069 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5070 invert_truthvalue (arg));
5071 arg = save_expr (arg);
5072 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5073 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5078 TREE_SIDE_EFFECTS (val) = 1;
5082 /* Built-in macros for stddef.h, that require macros defined in this
5085 c_stddef_cpp_builtins(void)
5087 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5088 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5089 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5090 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5091 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5092 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5093 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5094 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5098 c_init_attributes (void)
5100 /* Fill in the built_in_attributes array. */
5101 #define DEF_ATTR_NULL_TREE(ENUM) \
5102 built_in_attributes[(int) ENUM] = NULL_TREE;
5103 #define DEF_ATTR_INT(ENUM, VALUE) \
5104 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5105 #define DEF_ATTR_IDENT(ENUM, STRING) \
5106 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5107 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5108 built_in_attributes[(int) ENUM] \
5109 = tree_cons (built_in_attributes[(int) PURPOSE], \
5110 built_in_attributes[(int) VALUE], \
5111 built_in_attributes[(int) CHAIN]);
5112 #include "builtin-attrs.def"
5113 #undef DEF_ATTR_NULL_TREE
5115 #undef DEF_ATTR_IDENT
5116 #undef DEF_ATTR_TREE_LIST
5119 /* Attribute handlers common to C front ends. */
5121 /* Handle a "packed" attribute; arguments as in
5122 struct attribute_spec.handler. */
5125 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5126 int flags, bool *no_add_attrs)
5130 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5131 *node = build_variant_type_copy (*node);
5132 TYPE_PACKED (*node) = 1;
5134 else if (TREE_CODE (*node) == FIELD_DECL)
5136 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5137 /* Still pack bitfields. */
5138 && ! DECL_INITIAL (*node))
5139 warning (OPT_Wattributes,
5140 "%qE attribute ignored for field of type %qT",
5141 name, TREE_TYPE (*node));
5143 DECL_PACKED (*node) = 1;
5145 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5146 used for DECL_REGISTER. It wouldn't mean anything anyway.
5147 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5148 that changes what the typedef is typing. */
5151 warning (OPT_Wattributes, "%qE attribute ignored", name);
5152 *no_add_attrs = true;
5158 /* Handle a "nocommon" attribute; arguments as in
5159 struct attribute_spec.handler. */
5162 handle_nocommon_attribute (tree *node, tree name,
5163 tree ARG_UNUSED (args),
5164 int ARG_UNUSED (flags), bool *no_add_attrs)
5166 if (TREE_CODE (*node) == VAR_DECL)
5167 DECL_COMMON (*node) = 0;
5170 warning (OPT_Wattributes, "%qE attribute ignored", name);
5171 *no_add_attrs = true;
5177 /* Handle a "common" attribute; arguments as in
5178 struct attribute_spec.handler. */
5181 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5182 int ARG_UNUSED (flags), bool *no_add_attrs)
5184 if (TREE_CODE (*node) == VAR_DECL)
5185 DECL_COMMON (*node) = 1;
5188 warning (OPT_Wattributes, "%qE attribute ignored", name);
5189 *no_add_attrs = true;
5195 /* Handle a "noreturn" attribute; arguments as in
5196 struct attribute_spec.handler. */
5199 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5200 int ARG_UNUSED (flags), bool *no_add_attrs)
5202 tree type = TREE_TYPE (*node);
5204 /* See FIXME comment in c_common_attribute_table. */
5205 if (TREE_CODE (*node) == FUNCTION_DECL)
5206 TREE_THIS_VOLATILE (*node) = 1;
5207 else if (TREE_CODE (type) == POINTER_TYPE
5208 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5210 = build_pointer_type
5211 (build_type_variant (TREE_TYPE (type),
5212 TYPE_READONLY (TREE_TYPE (type)), 1));
5215 warning (OPT_Wattributes, "%qE attribute ignored", name);
5216 *no_add_attrs = true;
5222 /* Handle a "hot" and attribute; arguments as in
5223 struct attribute_spec.handler. */
5226 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5227 int ARG_UNUSED (flags), bool *no_add_attrs)
5229 if (TREE_CODE (*node) == FUNCTION_DECL)
5231 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5233 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5235 *no_add_attrs = true;
5237 /* Most of the rest of the hot processing is done later with
5238 lookup_attribute. */
5242 warning (OPT_Wattributes, "%qE attribute ignored", name);
5243 *no_add_attrs = true;
5248 /* Handle a "cold" and attribute; arguments as in
5249 struct attribute_spec.handler. */
5252 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5253 int ARG_UNUSED (flags), bool *no_add_attrs)
5255 if (TREE_CODE (*node) == FUNCTION_DECL)
5257 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5259 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5261 *no_add_attrs = true;
5263 /* Most of the rest of the cold processing is done later with
5264 lookup_attribute. */
5268 warning (OPT_Wattributes, "%qE attribute ignored", name);
5269 *no_add_attrs = true;
5275 /* Handle a "noinline" attribute; arguments as in
5276 struct attribute_spec.handler. */
5279 handle_noinline_attribute (tree *node, tree name,
5280 tree ARG_UNUSED (args),
5281 int ARG_UNUSED (flags), bool *no_add_attrs)
5283 if (TREE_CODE (*node) == FUNCTION_DECL)
5284 DECL_UNINLINABLE (*node) = 1;
5287 warning (OPT_Wattributes, "%qE attribute ignored", name);
5288 *no_add_attrs = true;
5294 /* Handle a "always_inline" attribute; arguments as in
5295 struct attribute_spec.handler. */
5298 handle_always_inline_attribute (tree *node, tree name,
5299 tree ARG_UNUSED (args),
5300 int ARG_UNUSED (flags),
5303 if (TREE_CODE (*node) == FUNCTION_DECL)
5305 /* Set the attribute and mark it for disregarding inline
5307 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
5311 warning (OPT_Wattributes, "%qE attribute ignored", name);
5312 *no_add_attrs = true;
5318 /* Handle a "gnu_inline" attribute; arguments as in
5319 struct attribute_spec.handler. */
5322 handle_gnu_inline_attribute (tree *node, tree name,
5323 tree ARG_UNUSED (args),
5324 int ARG_UNUSED (flags),
5327 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5329 /* Do nothing else, just set the attribute. We'll get at
5330 it later with lookup_attribute. */
5334 warning (OPT_Wattributes, "%qE attribute ignored", name);
5335 *no_add_attrs = true;
5341 /* Handle an "artificial" attribute; arguments as in
5342 struct attribute_spec.handler. */
5345 handle_artificial_attribute (tree *node, tree name,
5346 tree ARG_UNUSED (args),
5347 int ARG_UNUSED (flags),
5350 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5352 /* Do nothing else, just set the attribute. We'll get at
5353 it later with lookup_attribute. */
5357 warning (OPT_Wattributes, "%qE attribute ignored", name);
5358 *no_add_attrs = true;
5364 /* Handle a "flatten" attribute; arguments as in
5365 struct attribute_spec.handler. */
5368 handle_flatten_attribute (tree *node, tree name,
5369 tree args ATTRIBUTE_UNUSED,
5370 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5372 if (TREE_CODE (*node) == FUNCTION_DECL)
5373 /* Do nothing else, just set the attribute. We'll get at
5374 it later with lookup_attribute. */
5378 warning (OPT_Wattributes, "%qE attribute ignored", name);
5379 *no_add_attrs = true;
5385 /* Handle a "warning" or "error" attribute; arguments as in
5386 struct attribute_spec.handler. */
5389 handle_error_attribute (tree *node, tree name, tree args,
5390 int ARG_UNUSED (flags), bool *no_add_attrs)
5392 if (TREE_CODE (*node) == FUNCTION_DECL
5393 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5394 /* Do nothing else, just set the attribute. We'll get at
5395 it later with lookup_attribute. */
5399 warning (OPT_Wattributes, "%qE attribute ignored", name);
5400 *no_add_attrs = true;
5406 /* Handle a "used" attribute; arguments as in
5407 struct attribute_spec.handler. */
5410 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
5411 int ARG_UNUSED (flags), bool *no_add_attrs)
5415 if (TREE_CODE (node) == FUNCTION_DECL
5416 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
5418 TREE_USED (node) = 1;
5419 DECL_PRESERVE_P (node) = 1;
5423 warning (OPT_Wattributes, "%qE attribute ignored", name);
5424 *no_add_attrs = true;
5430 /* Handle a "unused" attribute; arguments as in
5431 struct attribute_spec.handler. */
5434 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5435 int flags, bool *no_add_attrs)
5441 if (TREE_CODE (decl) == PARM_DECL
5442 || TREE_CODE (decl) == VAR_DECL
5443 || TREE_CODE (decl) == FUNCTION_DECL
5444 || TREE_CODE (decl) == LABEL_DECL
5445 || TREE_CODE (decl) == TYPE_DECL)
5446 TREE_USED (decl) = 1;
5449 warning (OPT_Wattributes, "%qE attribute ignored", name);
5450 *no_add_attrs = true;
5455 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5456 *node = build_variant_type_copy (*node);
5457 TREE_USED (*node) = 1;
5463 /* Handle a "externally_visible" attribute; arguments as in
5464 struct attribute_spec.handler. */
5467 handle_externally_visible_attribute (tree *pnode, tree name,
5468 tree ARG_UNUSED (args),
5469 int ARG_UNUSED (flags),
5474 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
5476 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
5477 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
5479 warning (OPT_Wattributes,
5480 "%qE attribute have effect only on public objects", name);
5481 *no_add_attrs = true;
5486 warning (OPT_Wattributes, "%qE attribute ignored", name);
5487 *no_add_attrs = true;
5493 /* Handle a "const" attribute; arguments as in
5494 struct attribute_spec.handler. */
5497 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5498 int ARG_UNUSED (flags), bool *no_add_attrs)
5500 tree type = TREE_TYPE (*node);
5502 /* See FIXME comment on noreturn in c_common_attribute_table. */
5503 if (TREE_CODE (*node) == FUNCTION_DECL)
5504 TREE_READONLY (*node) = 1;
5505 else if (TREE_CODE (type) == POINTER_TYPE
5506 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5508 = build_pointer_type
5509 (build_type_variant (TREE_TYPE (type), 1,
5510 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5513 warning (OPT_Wattributes, "%qE attribute ignored", name);
5514 *no_add_attrs = true;
5520 /* Handle a "transparent_union" attribute; arguments as in
5521 struct attribute_spec.handler. */
5524 handle_transparent_union_attribute (tree *node, tree name,
5525 tree ARG_UNUSED (args), int flags,
5530 *no_add_attrs = true;
5532 if (TREE_CODE (*node) == TYPE_DECL)
5533 node = &TREE_TYPE (*node);
5536 if (TREE_CODE (type) == UNION_TYPE)
5538 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5539 the code in finish_struct. */
5540 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5542 if (TYPE_FIELDS (type) == NULL_TREE
5543 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
5546 /* A type variant isn't good enough, since we don't a cast
5547 to such a type removed as a no-op. */
5548 *node = type = build_duplicate_type (type);
5551 TYPE_TRANSPARENT_UNION (type) = 1;
5556 warning (OPT_Wattributes, "%qE attribute ignored", name);
5560 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
5561 get the requested priority for a constructor or destructor,
5562 possibly issuing diagnostics for invalid or reserved
5565 static priority_type
5566 get_priority (tree args, bool is_destructor)
5572 return DEFAULT_INIT_PRIORITY;
5574 if (!SUPPORTS_INIT_PRIORITY)
5577 error ("destructor priorities are not supported");
5579 error ("constructor priorities are not supported");
5580 return DEFAULT_INIT_PRIORITY;
5583 arg = TREE_VALUE (args);
5584 if (!host_integerp (arg, /*pos=*/0)
5585 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
5588 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
5589 if (pri < 0 || pri > MAX_INIT_PRIORITY)
5592 if (pri <= MAX_RESERVED_INIT_PRIORITY)
5596 "destructor priorities from 0 to %d are reserved "
5597 "for the implementation",
5598 MAX_RESERVED_INIT_PRIORITY);
5601 "constructor priorities from 0 to %d are reserved "
5602 "for the implementation",
5603 MAX_RESERVED_INIT_PRIORITY);
5609 error ("destructor priorities must be integers from 0 to %d inclusive",
5612 error ("constructor priorities must be integers from 0 to %d inclusive",
5614 return DEFAULT_INIT_PRIORITY;
5617 /* Handle a "constructor" attribute; arguments as in
5618 struct attribute_spec.handler. */
5621 handle_constructor_attribute (tree *node, tree name, tree args,
5622 int ARG_UNUSED (flags),
5626 tree type = TREE_TYPE (decl);
5628 if (TREE_CODE (decl) == FUNCTION_DECL
5629 && TREE_CODE (type) == FUNCTION_TYPE
5630 && decl_function_context (decl) == 0)
5632 priority_type priority;
5633 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5634 priority = get_priority (args, /*is_destructor=*/false);
5635 SET_DECL_INIT_PRIORITY (decl, priority);
5636 TREE_USED (decl) = 1;
5640 warning (OPT_Wattributes, "%qE attribute ignored", name);
5641 *no_add_attrs = true;
5647 /* Handle a "destructor" attribute; arguments as in
5648 struct attribute_spec.handler. */
5651 handle_destructor_attribute (tree *node, tree name, tree args,
5652 int ARG_UNUSED (flags),
5656 tree type = TREE_TYPE (decl);
5658 if (TREE_CODE (decl) == FUNCTION_DECL
5659 && TREE_CODE (type) == FUNCTION_TYPE
5660 && decl_function_context (decl) == 0)
5662 priority_type priority;
5663 DECL_STATIC_DESTRUCTOR (decl) = 1;
5664 priority = get_priority (args, /*is_destructor=*/true);
5665 SET_DECL_FINI_PRIORITY (decl, priority);
5666 TREE_USED (decl) = 1;
5670 warning (OPT_Wattributes, "%qE attribute ignored", name);
5671 *no_add_attrs = true;
5677 /* Handle a "mode" attribute; arguments as in
5678 struct attribute_spec.handler. */
5681 handle_mode_attribute (tree *node, tree name, tree args,
5682 int ARG_UNUSED (flags), bool *no_add_attrs)
5686 *no_add_attrs = true;
5688 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5689 warning (OPT_Wattributes, "%qE attribute ignored", name);
5693 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5694 int len = strlen (p);
5695 enum machine_mode mode = VOIDmode;
5699 if (len > 4 && p[0] == '_' && p[1] == '_'
5700 && p[len - 1] == '_' && p[len - 2] == '_')
5702 char *newp = (char *) alloca (len - 1);
5704 strcpy (newp, &p[2]);
5705 newp[len - 4] = '\0';
5709 /* Change this type to have a type with the specified mode.
5710 First check for the special modes. */
5711 if (!strcmp (p, "byte"))
5713 else if (!strcmp (p, "word"))
5715 else if (!strcmp (p, "pointer"))
5717 else if (!strcmp (p, "libgcc_cmp_return"))
5718 mode = targetm.libgcc_cmp_return_mode ();
5719 else if (!strcmp (p, "libgcc_shift_count"))
5720 mode = targetm.libgcc_shift_count_mode ();
5721 else if (!strcmp (p, "unwind_word"))
5722 mode = targetm.unwind_word_mode ();
5724 for (j = 0; j < NUM_MACHINE_MODES; j++)
5725 if (!strcmp (p, GET_MODE_NAME (j)))
5727 mode = (enum machine_mode) j;
5731 if (mode == VOIDmode)
5733 error ("unknown machine mode %qs", p);
5738 switch (GET_MODE_CLASS (mode))
5741 case MODE_PARTIAL_INT:
5743 case MODE_DECIMAL_FLOAT:
5748 valid_mode = targetm.scalar_mode_supported_p (mode);
5751 case MODE_COMPLEX_INT:
5752 case MODE_COMPLEX_FLOAT:
5753 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5756 case MODE_VECTOR_INT:
5757 case MODE_VECTOR_FLOAT:
5758 case MODE_VECTOR_FRACT:
5759 case MODE_VECTOR_UFRACT:
5760 case MODE_VECTOR_ACCUM:
5761 case MODE_VECTOR_UACCUM:
5762 warning (OPT_Wattributes, "specifying vector types with "
5763 "__attribute__ ((mode)) is deprecated");
5764 warning (OPT_Wattributes,
5765 "use __attribute__ ((vector_size)) instead");
5766 valid_mode = vector_mode_valid_p (mode);
5774 error ("unable to emulate %qs", p);
5778 if (POINTER_TYPE_P (type))
5780 tree (*fn)(tree, enum machine_mode, bool);
5782 if (!targetm.valid_pointer_mode (mode))
5784 error ("invalid pointer mode %qs", p);
5788 if (TREE_CODE (type) == POINTER_TYPE)
5789 fn = build_pointer_type_for_mode;
5791 fn = build_reference_type_for_mode;
5792 typefm = fn (TREE_TYPE (type), mode, false);
5796 /* For fixed-point modes, we need to test if the signness of type
5797 and the machine mode are consistent. */
5798 if (ALL_FIXED_POINT_MODE_P (mode)
5799 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
5801 error ("signness of type and machine mode %qs don't match", p);
5804 /* For fixed-point modes, we need to pass saturating info. */
5805 typefm = lang_hooks.types.type_for_mode (mode,
5806 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
5807 : TYPE_UNSIGNED (type));
5810 if (typefm == NULL_TREE)
5812 error ("no data type for mode %qs", p);
5815 else if (TREE_CODE (type) == ENUMERAL_TYPE)
5817 /* For enumeral types, copy the precision from the integer
5818 type returned above. If not an INTEGER_TYPE, we can't use
5819 this mode for this type. */
5820 if (TREE_CODE (typefm) != INTEGER_TYPE)
5822 error ("cannot use mode %qs for enumeral types", p);
5826 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5828 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5833 /* We cannot build a type variant, as there's code that assumes
5834 that TYPE_MAIN_VARIANT has the same mode. This includes the
5835 debug generators. Instead, create a subrange type. This
5836 results in all of the enumeral values being emitted only once
5837 in the original, and the subtype gets them by reference. */
5838 if (TYPE_UNSIGNED (type))
5839 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5841 typefm = make_signed_type (TYPE_PRECISION (typefm));
5842 TREE_TYPE (typefm) = type;
5845 else if (VECTOR_MODE_P (mode)
5846 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5847 : TREE_CODE (type) != TREE_CODE (typefm))
5849 error ("mode %qs applied to inappropriate type", p);
5859 /* Handle a "section" attribute; arguments as in
5860 struct attribute_spec.handler. */
5863 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5864 int ARG_UNUSED (flags), bool *no_add_attrs)
5868 if (targetm.have_named_sections)
5870 user_defined_section_attribute = true;
5872 if ((TREE_CODE (decl) == FUNCTION_DECL
5873 || TREE_CODE (decl) == VAR_DECL)
5874 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5876 if (TREE_CODE (decl) == VAR_DECL
5877 && current_function_decl != NULL_TREE
5878 && !TREE_STATIC (decl))
5880 error ("%Jsection attribute cannot be specified for "
5881 "local variables", decl);
5882 *no_add_attrs = true;
5885 /* The decl may have already been given a section attribute
5886 from a previous declaration. Ensure they match. */
5887 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5888 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5889 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5891 error ("section of %q+D conflicts with previous declaration",
5893 *no_add_attrs = true;
5895 else if (TREE_CODE (decl) == VAR_DECL
5896 && !targetm.have_tls && targetm.emutls.tmpl_section
5897 && DECL_THREAD_LOCAL_P (decl))
5899 error ("section of %q+D cannot be overridden", *node);
5900 *no_add_attrs = true;
5903 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5907 error ("section attribute not allowed for %q+D", *node);
5908 *no_add_attrs = true;
5913 error ("%Jsection attributes are not supported for this target", *node);
5914 *no_add_attrs = true;
5920 /* Handle a "aligned" attribute; arguments as in
5921 struct attribute_spec.handler. */
5924 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5925 int flags, bool *no_add_attrs)
5927 tree decl = NULL_TREE;
5930 tree align_expr = (args ? TREE_VALUE (args)
5931 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
5937 type = &TREE_TYPE (decl);
5938 is_type = TREE_CODE (*node) == TYPE_DECL;
5940 else if (TYPE_P (*node))
5941 type = node, is_type = 1;
5943 if (TREE_CODE (align_expr) != INTEGER_CST)
5945 error ("requested alignment is not a constant");
5946 *no_add_attrs = true;
5948 else if ((i = tree_log2 (align_expr)) == -1)
5950 error ("requested alignment is not a power of 2");
5951 *no_add_attrs = true;
5953 else if (i > HOST_BITS_PER_INT - 2)
5955 error ("requested alignment is too large");
5956 *no_add_attrs = true;
5960 /* If we have a TYPE_DECL, then copy the type, so that we
5961 don't accidentally modify a builtin type. See pushdecl. */
5962 if (decl && TREE_TYPE (decl) != error_mark_node
5963 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5965 tree tt = TREE_TYPE (decl);
5966 *type = build_variant_type_copy (*type);
5967 DECL_ORIGINAL_TYPE (decl) = tt;
5968 TYPE_NAME (*type) = decl;
5969 TREE_USED (*type) = TREE_USED (decl);
5970 TREE_TYPE (decl) = *type;
5972 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5973 *type = build_variant_type_copy (*type);
5975 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5976 TYPE_USER_ALIGN (*type) = 1;
5978 else if (! VAR_OR_FUNCTION_DECL_P (decl)
5979 && TREE_CODE (decl) != FIELD_DECL)
5981 error ("alignment may not be specified for %q+D", decl);
5982 *no_add_attrs = true;
5984 else if (TREE_CODE (decl) == FUNCTION_DECL
5985 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
5987 if (DECL_USER_ALIGN (decl))
5988 error ("alignment for %q+D was previously specified as %d "
5989 "and may not be decreased", decl,
5990 DECL_ALIGN (decl) / BITS_PER_UNIT);
5992 error ("alignment for %q+D must be at least %d", decl,
5993 DECL_ALIGN (decl) / BITS_PER_UNIT);
5994 *no_add_attrs = true;
5998 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5999 DECL_USER_ALIGN (decl) = 1;
6005 /* Handle a "weak" attribute; arguments as in
6006 struct attribute_spec.handler. */
6009 handle_weak_attribute (tree *node, tree name,
6010 tree ARG_UNUSED (args),
6011 int ARG_UNUSED (flags),
6012 bool * ARG_UNUSED (no_add_attrs))
6014 if (TREE_CODE (*node) == FUNCTION_DECL
6015 && DECL_DECLARED_INLINE_P (*node))
6017 error ("inline function %q+D cannot be declared weak", *node);
6018 *no_add_attrs = true;
6020 else if (TREE_CODE (*node) == FUNCTION_DECL
6021 || TREE_CODE (*node) == VAR_DECL)
6022 declare_weak (*node);
6024 warning (OPT_Wattributes, "%qE attribute ignored", name);
6029 /* Handle an "alias" attribute; arguments as in
6030 struct attribute_spec.handler. */
6033 handle_alias_attribute (tree *node, tree name, tree args,
6034 int ARG_UNUSED (flags), bool *no_add_attrs)
6038 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6040 warning (OPT_Wattributes, "%qE attribute ignored", name);
6041 *no_add_attrs = true;
6043 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6044 || (TREE_CODE (decl) != FUNCTION_DECL
6045 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6046 /* A static variable declaration is always a tentative definition,
6047 but the alias is a non-tentative definition which overrides. */
6048 || (TREE_CODE (decl) != FUNCTION_DECL
6049 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6051 error ("%q+D defined both normally and as an alias", decl);
6052 *no_add_attrs = true;
6055 /* Note that the very first time we process a nested declaration,
6056 decl_function_context will not be set. Indeed, *would* never
6057 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6058 we do below. After such frobbery, pushdecl would set the context.
6059 In any case, this is never what we want. */
6060 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6064 id = TREE_VALUE (args);
6065 if (TREE_CODE (id) != STRING_CST)
6067 error ("alias argument not a string");
6068 *no_add_attrs = true;
6071 id = get_identifier (TREE_STRING_POINTER (id));
6072 /* This counts as a use of the object pointed to. */
6075 if (TREE_CODE (decl) == FUNCTION_DECL)
6076 DECL_INITIAL (decl) = error_mark_node;
6079 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6080 DECL_EXTERNAL (decl) = 1;
6082 DECL_EXTERNAL (decl) = 0;
6083 TREE_STATIC (decl) = 1;
6088 warning (OPT_Wattributes, "%qE attribute ignored", name);
6089 *no_add_attrs = true;
6095 /* Handle a "weakref" attribute; arguments as in struct
6096 attribute_spec.handler. */
6099 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6100 int flags, bool *no_add_attrs)
6102 tree attr = NULL_TREE;
6104 /* We must ignore the attribute when it is associated with
6105 local-scoped decls, since attribute alias is ignored and many
6106 such symbols do not even have a DECL_WEAK field. */
6107 if (decl_function_context (*node)
6108 || current_function_decl
6109 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6111 warning (OPT_Wattributes, "%qE attribute ignored", name);
6112 *no_add_attrs = true;
6116 /* The idea here is that `weakref("name")' mutates into `weakref,
6117 alias("name")', and weakref without arguments, in turn,
6118 implicitly adds weak. */
6122 attr = tree_cons (get_identifier ("alias"), args, attr);
6123 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6125 *no_add_attrs = true;
6127 decl_attributes (node, attr, flags);
6131 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6132 error ("%Jweakref attribute must appear before alias attribute",
6135 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6136 and that isn't supported; and because it wants to add it to
6137 the list of weak decls, which isn't helpful. */
6138 DECL_WEAK (*node) = 1;
6144 /* Handle an "visibility" attribute; arguments as in
6145 struct attribute_spec.handler. */
6148 handle_visibility_attribute (tree *node, tree name, tree args,
6149 int ARG_UNUSED (flags),
6150 bool *ARG_UNUSED (no_add_attrs))
6153 tree id = TREE_VALUE (args);
6154 enum symbol_visibility vis;
6158 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6160 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6162 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6166 else if (TYPE_FIELDS (*node))
6168 error ("%qE attribute ignored because %qT is already defined",
6173 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6175 warning (OPT_Wattributes, "%qE attribute ignored", name);
6179 if (TREE_CODE (id) != STRING_CST)
6181 error ("visibility argument not a string");
6185 /* If this is a type, set the visibility on the type decl. */
6188 decl = TYPE_NAME (decl);
6191 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6193 warning (OPT_Wattributes, "%qE attribute ignored on types",
6199 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6200 vis = VISIBILITY_DEFAULT;
6201 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6202 vis = VISIBILITY_INTERNAL;
6203 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6204 vis = VISIBILITY_HIDDEN;
6205 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6206 vis = VISIBILITY_PROTECTED;
6209 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6210 vis = VISIBILITY_DEFAULT;
6213 if (DECL_VISIBILITY_SPECIFIED (decl)
6214 && vis != DECL_VISIBILITY (decl))
6216 tree attributes = (TYPE_P (*node)
6217 ? TYPE_ATTRIBUTES (*node)
6218 : DECL_ATTRIBUTES (decl));
6219 if (lookup_attribute ("visibility", attributes))
6220 error ("%qD redeclared with different visibility", decl);
6221 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6222 && lookup_attribute ("dllimport", attributes))
6223 error ("%qD was declared %qs which implies default visibility",
6225 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6226 && lookup_attribute ("dllexport", attributes))
6227 error ("%qD was declared %qs which implies default visibility",
6231 DECL_VISIBILITY (decl) = vis;
6232 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6234 /* Go ahead and attach the attribute to the node as well. This is needed
6235 so we can determine whether we have VISIBILITY_DEFAULT because the
6236 visibility was not specified, or because it was explicitly overridden
6237 from the containing scope. */
6242 /* Determine the ELF symbol visibility for DECL, which is either a
6243 variable or a function. It is an error to use this function if a
6244 definition of DECL is not available in this translation unit.
6245 Returns true if the final visibility has been determined by this
6246 function; false if the caller is free to make additional
6250 c_determine_visibility (tree decl)
6252 gcc_assert (TREE_CODE (decl) == VAR_DECL
6253 || TREE_CODE (decl) == FUNCTION_DECL);
6255 /* If the user explicitly specified the visibility with an
6256 attribute, honor that. DECL_VISIBILITY will have been set during
6257 the processing of the attribute. We check for an explicit
6258 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6259 to distinguish the use of an attribute from the use of a "#pragma
6260 GCC visibility push(...)"; in the latter case we still want other
6261 considerations to be able to overrule the #pragma. */
6262 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6263 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6264 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6265 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6268 /* Set default visibility to whatever the user supplied with
6269 visibility_specified depending on #pragma GCC visibility. */
6270 if (!DECL_VISIBILITY_SPECIFIED (decl))
6272 if (visibility_options.inpragma
6273 || DECL_VISIBILITY (decl) != default_visibility)
6275 DECL_VISIBILITY (decl) = default_visibility;
6276 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6277 /* If visibility changed and DECL already has DECL_RTL, ensure
6278 symbol flags are updated. */
6279 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6280 || TREE_CODE (decl) == FUNCTION_DECL)
6281 && DECL_RTL_SET_P (decl))
6282 make_decl_rtl (decl);
6288 /* Handle an "tls_model" attribute; arguments as in
6289 struct attribute_spec.handler. */
6292 handle_tls_model_attribute (tree *node, tree name, tree args,
6293 int ARG_UNUSED (flags), bool *no_add_attrs)
6297 enum tls_model kind;
6299 *no_add_attrs = true;
6301 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
6303 warning (OPT_Wattributes, "%qE attribute ignored", name);
6307 kind = DECL_TLS_MODEL (decl);
6308 id = TREE_VALUE (args);
6309 if (TREE_CODE (id) != STRING_CST)
6311 error ("tls_model argument not a string");
6315 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
6316 kind = TLS_MODEL_LOCAL_EXEC;
6317 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
6318 kind = TLS_MODEL_INITIAL_EXEC;
6319 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
6320 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
6321 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
6322 kind = TLS_MODEL_GLOBAL_DYNAMIC;
6324 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6326 DECL_TLS_MODEL (decl) = kind;
6330 /* Handle a "no_instrument_function" attribute; arguments as in
6331 struct attribute_spec.handler. */
6334 handle_no_instrument_function_attribute (tree *node, tree name,
6335 tree ARG_UNUSED (args),
6336 int ARG_UNUSED (flags),
6341 if (TREE_CODE (decl) != FUNCTION_DECL)
6343 error ("%J%qE attribute applies only to functions", decl, name);
6344 *no_add_attrs = true;
6346 else if (DECL_INITIAL (decl))
6348 error ("%Jcan%'t set %qE attribute after definition", decl, name);
6349 *no_add_attrs = true;
6352 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6357 /* Handle a "malloc" attribute; arguments as in
6358 struct attribute_spec.handler. */
6361 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6362 int ARG_UNUSED (flags), bool *no_add_attrs)
6364 if (TREE_CODE (*node) == FUNCTION_DECL
6365 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
6366 DECL_IS_MALLOC (*node) = 1;
6369 warning (OPT_Wattributes, "%qE attribute ignored", name);
6370 *no_add_attrs = true;
6376 /* Handle a "alloc_size" attribute; arguments as in
6377 struct attribute_spec.handler. */
6380 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6381 int ARG_UNUSED (flags), bool *no_add_attrs)
6383 unsigned arg_count = type_num_arguments (*node);
6384 for (; args; args = TREE_CHAIN (args))
6386 tree position = TREE_VALUE (args);
6388 if (TREE_CODE (position) != INTEGER_CST
6389 || TREE_INT_CST_HIGH (position)
6390 || TREE_INT_CST_LOW (position) < 1
6391 || TREE_INT_CST_LOW (position) > arg_count )
6393 warning (OPT_Wattributes,
6394 "alloc_size parameter outside range");
6395 *no_add_attrs = true;
6402 /* Handle a "returns_twice" attribute; arguments as in
6403 struct attribute_spec.handler. */
6406 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6407 int ARG_UNUSED (flags), bool *no_add_attrs)
6409 if (TREE_CODE (*node) == FUNCTION_DECL)
6410 DECL_IS_RETURNS_TWICE (*node) = 1;
6413 warning (OPT_Wattributes, "%qE attribute ignored", name);
6414 *no_add_attrs = true;
6420 /* Handle a "no_limit_stack" attribute; arguments as in
6421 struct attribute_spec.handler. */
6424 handle_no_limit_stack_attribute (tree *node, tree name,
6425 tree ARG_UNUSED (args),
6426 int ARG_UNUSED (flags),
6431 if (TREE_CODE (decl) != FUNCTION_DECL)
6433 error ("%J%qE attribute applies only to functions", decl, name);
6434 *no_add_attrs = true;
6436 else if (DECL_INITIAL (decl))
6438 error ("%Jcan%'t set %qE attribute after definition", decl, name);
6439 *no_add_attrs = true;
6442 DECL_NO_LIMIT_STACK (decl) = 1;
6447 /* Handle a "pure" attribute; arguments as in
6448 struct attribute_spec.handler. */
6451 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6452 int ARG_UNUSED (flags), bool *no_add_attrs)
6454 if (TREE_CODE (*node) == FUNCTION_DECL)
6455 DECL_PURE_P (*node) = 1;
6456 /* ??? TODO: Support types. */
6459 warning (OPT_Wattributes, "%qE attribute ignored", name);
6460 *no_add_attrs = true;
6466 /* Handle a "no vops" attribute; arguments as in
6467 struct attribute_spec.handler. */
6470 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
6471 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6472 bool *ARG_UNUSED (no_add_attrs))
6474 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
6475 DECL_IS_NOVOPS (*node) = 1;
6479 /* Handle a "deprecated" attribute; arguments as in
6480 struct attribute_spec.handler. */
6483 handle_deprecated_attribute (tree *node, tree name,
6484 tree ARG_UNUSED (args), int flags,
6487 tree type = NULL_TREE;
6489 tree what = NULL_TREE;
6494 type = TREE_TYPE (decl);
6496 if (TREE_CODE (decl) == TYPE_DECL
6497 || TREE_CODE (decl) == PARM_DECL
6498 || TREE_CODE (decl) == VAR_DECL
6499 || TREE_CODE (decl) == FUNCTION_DECL
6500 || TREE_CODE (decl) == FIELD_DECL)
6501 TREE_DEPRECATED (decl) = 1;
6505 else if (TYPE_P (*node))
6507 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6508 *node = build_variant_type_copy (*node);
6509 TREE_DEPRECATED (*node) = 1;
6517 *no_add_attrs = true;
6518 if (type && TYPE_NAME (type))
6520 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6521 what = TYPE_NAME (*node);
6522 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6523 && DECL_NAME (TYPE_NAME (type)))
6524 what = DECL_NAME (TYPE_NAME (type));
6527 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
6529 warning (OPT_Wattributes, "%qE attribute ignored", name);
6535 /* Handle a "vector_size" attribute; arguments as in
6536 struct attribute_spec.handler. */
6539 handle_vector_size_attribute (tree *node, tree name, tree args,
6540 int ARG_UNUSED (flags),
6543 unsigned HOST_WIDE_INT vecsize, nunits;
6544 enum machine_mode orig_mode;
6545 tree type = *node, new_type, size;
6547 *no_add_attrs = true;
6549 size = TREE_VALUE (args);
6551 if (!host_integerp (size, 1))
6553 warning (OPT_Wattributes, "%qE attribute ignored", name);
6557 /* Get the vector size (in bytes). */
6558 vecsize = tree_low_cst (size, 1);
6560 /* We need to provide for vector pointers, vector arrays, and
6561 functions returning vectors. For example:
6563 __attribute__((vector_size(16))) short *foo;
6565 In this case, the mode is SI, but the type being modified is
6566 HI, so we need to look further. */
6568 while (POINTER_TYPE_P (type)
6569 || TREE_CODE (type) == FUNCTION_TYPE
6570 || TREE_CODE (type) == METHOD_TYPE
6571 || TREE_CODE (type) == ARRAY_TYPE
6572 || TREE_CODE (type) == OFFSET_TYPE)
6573 type = TREE_TYPE (type);
6575 /* Get the mode of the type being modified. */
6576 orig_mode = TYPE_MODE (type);
6578 if ((!INTEGRAL_TYPE_P (type)
6579 && !SCALAR_FLOAT_TYPE_P (type)
6580 && !FIXED_POINT_TYPE_P (type))
6581 || (!SCALAR_FLOAT_MODE_P (orig_mode)
6582 && GET_MODE_CLASS (orig_mode) != MODE_INT
6583 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
6584 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
6585 || TREE_CODE (type) == BOOLEAN_TYPE)
6587 error ("invalid vector type for attribute %qE", name);
6591 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
6593 error ("vector size not an integral multiple of component size");
6599 error ("zero vector size");
6603 /* Calculate how many units fit in the vector. */
6604 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6605 if (nunits & (nunits - 1))
6607 error ("number of components of the vector not a power of two");
6611 new_type = build_vector_type (type, nunits);
6613 /* Build back pointers if needed. */
6614 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
6619 /* Handle the "nonnull" attribute. */
6621 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
6622 tree args, int ARG_UNUSED (flags),
6626 unsigned HOST_WIDE_INT attr_arg_num;
6628 /* If no arguments are specified, all pointer arguments should be
6629 non-null. Verify a full prototype is given so that the arguments
6630 will have the correct types when we actually check them later. */
6633 if (!TYPE_ARG_TYPES (type))
6635 error ("nonnull attribute without arguments on a non-prototype");
6636 *no_add_attrs = true;
6641 /* Argument list specified. Verify that each argument number references
6642 a pointer argument. */
6643 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6646 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
6648 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
6650 error ("nonnull argument has invalid operand number (argument %lu)",
6651 (unsigned long) attr_arg_num);
6652 *no_add_attrs = true;
6656 argument = TYPE_ARG_TYPES (type);
6659 for (ck_num = 1; ; ck_num++)
6661 if (!argument || ck_num == arg_num)
6663 argument = TREE_CHAIN (argument);
6667 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6669 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6670 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6671 *no_add_attrs = true;
6675 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6677 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6678 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6679 *no_add_attrs = true;
6688 /* Check the argument list of a function call for null in argument slots
6689 that are marked as requiring a non-null pointer argument. The NARGS
6690 arguments are passed in the array ARGARRAY.
6694 check_function_nonnull (tree attrs, int nargs, tree *argarray)
6699 for (a = attrs; a; a = TREE_CHAIN (a))
6701 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6703 args = TREE_VALUE (a);
6705 /* Walk the argument list. If we encounter an argument number we
6706 should check for non-null, do it. If the attribute has no args,
6707 then every pointer argument is checked (in which case the check
6708 for pointer type is done in check_nonnull_arg). */
6709 for (i = 0; i < nargs; i++)
6711 if (!args || nonnull_check_p (args, i + 1))
6712 check_function_arguments_recurse (check_nonnull_arg, NULL,
6720 /* Check that the Nth argument of a function call (counting backwards
6721 from the end) is a (pointer)0. The NARGS arguments are passed in the
6725 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
6727 tree attr = lookup_attribute ("sentinel", attrs);
6735 /* Skip over the named arguments. */
6736 while (typelist && len < nargs)
6738 typelist = TREE_CHAIN (typelist);
6742 if (TREE_VALUE (attr))
6744 tree p = TREE_VALUE (TREE_VALUE (attr));
6745 pos = TREE_INT_CST_LOW (p);
6748 /* The sentinel must be one of the varargs, i.e.
6749 in position >= the number of fixed arguments. */
6750 if ((nargs - 1 - pos) < len)
6752 warning (OPT_Wformat,
6753 "not enough variable arguments to fit a sentinel");
6757 /* Validate the sentinel. */
6758 sentinel = argarray[nargs - 1 - pos];
6759 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
6760 || !integer_zerop (sentinel))
6761 /* Although __null (in C++) is only an integer we allow it
6762 nevertheless, as we are guaranteed that it's exactly
6763 as wide as a pointer, and we don't want to force
6764 users to cast the NULL they have written there.
6765 We warn with -Wstrict-null-sentinel, though. */
6766 && (warn_strict_null_sentinel || null_node != sentinel))
6767 warning (OPT_Wformat, "missing sentinel in function call");
6771 /* Helper for check_function_nonnull; given a list of operands which
6772 must be non-null in ARGS, determine if operand PARAM_NUM should be
6776 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6778 unsigned HOST_WIDE_INT arg_num = 0;
6780 for (; args; args = TREE_CHAIN (args))
6782 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6786 if (arg_num == param_num)
6792 /* Check that the function argument PARAM (which is operand number
6793 PARAM_NUM) is non-null. This is called by check_function_nonnull
6794 via check_function_arguments_recurse. */
6797 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6798 unsigned HOST_WIDE_INT param_num)
6800 /* Just skip checking the argument if it's not a pointer. This can
6801 happen if the "nonnull" attribute was given without an operand
6802 list (which means to check every pointer argument). */
6804 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6807 if (integer_zerop (param))
6808 warning (OPT_Wnonnull, "null argument where non-null required "
6809 "(argument %lu)", (unsigned long) param_num);
6812 /* Helper for nonnull attribute handling; fetch the operand number
6813 from the attribute argument list. */
6816 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6818 /* Verify the arg number is a constant. */
6819 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6820 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6823 *valp = TREE_INT_CST_LOW (arg_num_expr);
6827 /* Handle a "nothrow" attribute; arguments as in
6828 struct attribute_spec.handler. */
6831 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6832 int ARG_UNUSED (flags), bool *no_add_attrs)
6834 if (TREE_CODE (*node) == FUNCTION_DECL)
6835 TREE_NOTHROW (*node) = 1;
6836 /* ??? TODO: Support types. */
6839 warning (OPT_Wattributes, "%qE attribute ignored", name);
6840 *no_add_attrs = true;
6846 /* Handle a "cleanup" attribute; arguments as in
6847 struct attribute_spec.handler. */
6850 handle_cleanup_attribute (tree *node, tree name, tree args,
6851 int ARG_UNUSED (flags), bool *no_add_attrs)
6854 tree cleanup_id, cleanup_decl;
6856 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6857 for global destructors in C++. This requires infrastructure that
6858 we don't have generically at the moment. It's also not a feature
6859 we'd be missing too much, since we do have attribute constructor. */
6860 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6862 warning (OPT_Wattributes, "%qE attribute ignored", name);
6863 *no_add_attrs = true;
6867 /* Verify that the argument is a function in scope. */
6868 /* ??? We could support pointers to functions here as well, if
6869 that was considered desirable. */
6870 cleanup_id = TREE_VALUE (args);
6871 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6873 error ("cleanup argument not an identifier");
6874 *no_add_attrs = true;
6877 cleanup_decl = lookup_name (cleanup_id);
6878 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6880 error ("cleanup argument not a function");
6881 *no_add_attrs = true;
6885 /* That the function has proper type is checked with the
6886 eventual call to build_function_call. */
6891 /* Handle a "warn_unused_result" attribute. No special handling. */
6894 handle_warn_unused_result_attribute (tree *node, tree name,
6895 tree ARG_UNUSED (args),
6896 int ARG_UNUSED (flags), bool *no_add_attrs)
6898 /* Ignore the attribute for functions not returning any value. */
6899 if (VOID_TYPE_P (TREE_TYPE (*node)))
6901 warning (OPT_Wattributes, "%qE attribute ignored", name);
6902 *no_add_attrs = true;
6908 /* Handle a "sentinel" attribute. */
6911 handle_sentinel_attribute (tree *node, tree name, tree args,
6912 int ARG_UNUSED (flags), bool *no_add_attrs)
6914 tree params = TYPE_ARG_TYPES (*node);
6918 warning (OPT_Wattributes,
6919 "%qE attribute requires prototypes with named arguments", name);
6920 *no_add_attrs = true;
6924 while (TREE_CHAIN (params))
6925 params = TREE_CHAIN (params);
6927 if (VOID_TYPE_P (TREE_VALUE (params)))
6929 warning (OPT_Wattributes,
6930 "%qE attribute only applies to variadic functions", name);
6931 *no_add_attrs = true;
6937 tree position = TREE_VALUE (args);
6939 if (TREE_CODE (position) != INTEGER_CST)
6941 warning (OPT_Wattributes,
6942 "requested position is not an integer constant");
6943 *no_add_attrs = true;
6947 if (tree_int_cst_lt (position, integer_zero_node))
6949 warning (OPT_Wattributes,
6950 "requested position is less than zero");
6951 *no_add_attrs = true;
6959 /* Handle a "type_generic" attribute. */
6962 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6963 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6964 bool * ARG_UNUSED (no_add_attrs))
6968 /* Ensure we have a function type. */
6969 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
6971 params = TYPE_ARG_TYPES (*node);
6972 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
6973 params = TREE_CHAIN (params);
6975 /* Ensure we have a variadic function. */
6976 gcc_assert (!params);
6981 /* Handle a "target" attribute. */
6984 handle_target_attribute (tree *node, tree name, tree args, int flags,
6987 /* Ensure we have a function type. */
6988 if (TREE_CODE (*node) != FUNCTION_DECL)
6990 warning (OPT_Wattributes, "%qE attribute ignored", name);
6991 *no_add_attrs = true;
6993 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
6995 *no_add_attrs = true;
7000 /* Arguments being collected for optimization. */
7001 typedef const char *const_char_p; /* For DEF_VEC_P. */
7002 DEF_VEC_P(const_char_p);
7003 DEF_VEC_ALLOC_P(const_char_p, gc);
7004 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7007 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7008 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7009 false for #pragma GCC optimize. */
7012 parse_optimize_options (tree args, bool attr_p)
7017 int saved_flag_strict_aliasing;
7018 const char **opt_argv;
7021 /* Build up argv vector. Just in case the string is stored away, use garbage
7022 collected strings. */
7023 VEC_truncate (const_char_p, optimize_args, 0);
7024 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7026 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7028 tree value = TREE_VALUE (ap);
7030 if (TREE_CODE (value) == INTEGER_CST)
7033 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7034 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7037 else if (TREE_CODE (value) == STRING_CST)
7039 /* Split string into multiple substrings. */
7040 size_t len = TREE_STRING_LENGTH (value);
7041 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7042 char *end = p + len;
7046 while (next_p != NULL)
7052 comma = strchr (p, ',');
7065 r = q = (char *) ggc_alloc (len2 + 3);
7067 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7069 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7073 warning (OPT_Wattributes,
7074 "Bad option %s to optimize attribute.", p);
7076 warning (OPT_Wpragmas,
7077 "Bad option %s to pragma attribute", p);
7085 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7086 itself is -Os, and any other switch begins with a -f. */
7087 if ((*p >= '0' && *p <= '9')
7088 || (p[0] == 's' && p[1] == '\0'))
7094 memcpy (r, p, len2);
7096 VEC_safe_push (const_char_p, gc, optimize_args, q);
7102 opt_argc = VEC_length (const_char_p, optimize_args);
7103 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7105 for (i = 1; i < opt_argc; i++)
7106 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7108 saved_flag_strict_aliasing = flag_strict_aliasing;
7110 /* Now parse the options. */
7111 decode_options (opt_argc, opt_argv);
7113 /* Don't allow changing -fstrict-aliasing. */
7114 flag_strict_aliasing = saved_flag_strict_aliasing;
7116 VEC_truncate (const_char_p, optimize_args, 0);
7120 /* For handling "optimize" attribute. arguments as in
7121 struct attribute_spec.handler. */
7124 handle_optimize_attribute (tree *node, tree name, tree args,
7125 int ARG_UNUSED (flags), bool *no_add_attrs)
7127 /* Ensure we have a function type. */
7128 if (TREE_CODE (*node) != FUNCTION_DECL)
7130 warning (OPT_Wattributes, "%qE attribute ignored", name);
7131 *no_add_attrs = true;
7135 struct cl_optimization cur_opts;
7136 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7138 /* Save current options. */
7139 cl_optimization_save (&cur_opts);
7141 /* If we previously had some optimization options, use them as the
7144 cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7146 /* Parse options, and update the vector. */
7147 parse_optimize_options (args, true);
7148 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7149 = build_optimization_node ();
7151 /* Restore current options. */
7152 cl_optimization_restore (&cur_opts);
7158 /* Check for valid arguments being passed to a function.
7159 ATTRS is a list of attributes. There are NARGS arguments in the array
7160 ARGARRAY. TYPELIST is the list of argument types for the function.
7163 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7165 /* Check for null being passed in a pointer argument that must be
7166 non-null. We also need to do this if format checking is enabled. */
7169 check_function_nonnull (attrs, nargs, argarray);
7171 /* Check for errors in format strings. */
7173 if (warn_format || warn_missing_format_attribute)
7174 check_function_format (attrs, nargs, argarray);
7177 check_function_sentinel (attrs, nargs, argarray, typelist);
7180 /* Generic argument checking recursion routine. PARAM is the argument to
7181 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7182 once the argument is resolved. CTX is context for the callback. */
7184 check_function_arguments_recurse (void (*callback)
7185 (void *, tree, unsigned HOST_WIDE_INT),
7186 void *ctx, tree param,
7187 unsigned HOST_WIDE_INT param_num)
7189 if (CONVERT_EXPR_P (param)
7190 && (TYPE_PRECISION (TREE_TYPE (param))
7191 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7193 /* Strip coercion. */
7194 check_function_arguments_recurse (callback, ctx,
7195 TREE_OPERAND (param, 0), param_num);
7199 if (TREE_CODE (param) == CALL_EXPR)
7201 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7203 bool found_format_arg = false;
7205 /* See if this is a call to a known internationalization function
7206 that modifies a format arg. Such a function may have multiple
7207 format_arg attributes (for example, ngettext). */
7209 for (attrs = TYPE_ATTRIBUTES (type);
7211 attrs = TREE_CHAIN (attrs))
7212 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7215 tree format_num_expr;
7218 call_expr_arg_iterator iter;
7220 /* Extract the argument number, which was previously checked
7222 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7224 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7225 && !TREE_INT_CST_HIGH (format_num_expr));
7227 format_num = TREE_INT_CST_LOW (format_num_expr);
7229 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7231 inner_arg = next_call_expr_arg (&iter), i++)
7232 if (i == format_num)
7234 check_function_arguments_recurse (callback, ctx,
7235 inner_arg, param_num);
7236 found_format_arg = true;
7241 /* If we found a format_arg attribute and did a recursive check,
7242 we are done with checking this argument. Otherwise, we continue
7243 and this will be considered a non-literal. */
7244 if (found_format_arg)
7248 if (TREE_CODE (param) == COND_EXPR)
7250 /* Check both halves of the conditional expression. */
7251 check_function_arguments_recurse (callback, ctx,
7252 TREE_OPERAND (param, 1), param_num);
7253 check_function_arguments_recurse (callback, ctx,
7254 TREE_OPERAND (param, 2), param_num);
7258 (*callback) (ctx, param, param_num);
7261 /* Checks the number of arguments NARGS against the required number
7262 REQUIRED and issues an error if there is a mismatch. Returns true
7263 if the number of arguments is correct, otherwise false. */
7266 validate_nargs (tree fndecl, int nargs, int required)
7268 if (nargs < required)
7270 error ("not enough arguments to function %qE", fndecl);
7273 else if (nargs > required)
7275 error ("too many arguments to function %qE", fndecl);
7281 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7282 Returns false if there was an error, otherwise true. */
7285 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
7287 if (!DECL_BUILT_IN (fndecl)
7288 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
7291 switch (DECL_FUNCTION_CODE (fndecl))
7293 case BUILT_IN_CONSTANT_P:
7294 return validate_nargs (fndecl, nargs, 1);
7296 case BUILT_IN_ISFINITE:
7297 case BUILT_IN_ISINF:
7298 case BUILT_IN_ISINF_SIGN:
7299 case BUILT_IN_ISNAN:
7300 case BUILT_IN_ISNORMAL:
7301 if (validate_nargs (fndecl, nargs, 1))
7303 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
7305 error ("non-floating-point argument in call to "
7306 "function %qE", fndecl);
7313 case BUILT_IN_ISGREATER:
7314 case BUILT_IN_ISGREATEREQUAL:
7315 case BUILT_IN_ISLESS:
7316 case BUILT_IN_ISLESSEQUAL:
7317 case BUILT_IN_ISLESSGREATER:
7318 case BUILT_IN_ISUNORDERED:
7319 if (validate_nargs (fndecl, nargs, 2))
7321 enum tree_code code0, code1;
7322 code0 = TREE_CODE (TREE_TYPE (args[0]));
7323 code1 = TREE_CODE (TREE_TYPE (args[1]));
7324 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
7325 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7326 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
7328 error ("non-floating-point arguments in call to "
7329 "function %qE", fndecl);
7336 case BUILT_IN_FPCLASSIFY:
7337 if (validate_nargs (fndecl, nargs, 6))
7342 if (TREE_CODE (args[i]) != INTEGER_CST)
7344 error ("non-const integer argument %u in call to function %qE",
7349 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
7351 error ("non-floating-point argument in call to function %qE",
7364 /* Function to help qsort sort FIELD_DECLs by name order. */
7367 field_decl_cmp (const void *x_p, const void *y_p)
7369 const tree *const x = (const tree *const) x_p;
7370 const tree *const y = (const tree *const) y_p;
7372 if (DECL_NAME (*x) == DECL_NAME (*y))
7373 /* A nontype is "greater" than a type. */
7374 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7375 if (DECL_NAME (*x) == NULL_TREE)
7377 if (DECL_NAME (*y) == NULL_TREE)
7379 if (DECL_NAME (*x) < DECL_NAME (*y))
7385 gt_pointer_operator new_value;
7389 /* This routine compares two fields like field_decl_cmp but using the
7390 pointer operator in resort_data. */
7393 resort_field_decl_cmp (const void *x_p, const void *y_p)
7395 const tree *const x = (const tree *const) x_p;
7396 const tree *const y = (const tree *const) y_p;
7398 if (DECL_NAME (*x) == DECL_NAME (*y))
7399 /* A nontype is "greater" than a type. */
7400 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7401 if (DECL_NAME (*x) == NULL_TREE)
7403 if (DECL_NAME (*y) == NULL_TREE)
7406 tree d1 = DECL_NAME (*x);
7407 tree d2 = DECL_NAME (*y);
7408 resort_data.new_value (&d1, resort_data.cookie);
7409 resort_data.new_value (&d2, resort_data.cookie);
7416 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
7419 resort_sorted_fields (void *obj,
7420 void * ARG_UNUSED (orig_obj),
7421 gt_pointer_operator new_value,
7424 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
7425 resort_data.new_value = new_value;
7426 resort_data.cookie = cookie;
7427 qsort (&sf->elts[0], sf->len, sizeof (tree),
7428 resort_field_decl_cmp);
7431 /* Subroutine of c_parse_error.
7432 Return the result of concatenating LHS and RHS. RHS is really
7433 a string literal, its first character is indicated by RHS_START and
7434 RHS_SIZE is its length (including the terminating NUL character).
7436 The caller is responsible for deleting the returned pointer. */
7439 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
7441 const int lhs_size = strlen (lhs);
7442 char *result = XNEWVEC (char, lhs_size + rhs_size);
7443 strncpy (result, lhs, lhs_size);
7444 strncpy (result + lhs_size, rhs_start, rhs_size);
7448 /* Issue the error given by GMSGID, indicating that it occurred before
7449 TOKEN, which had the associated VALUE. */
7452 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
7454 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
7456 char *message = NULL;
7458 if (token == CPP_EOF)
7459 message = catenate_messages (gmsgid, " at end of input");
7460 else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
7461 || token == CPP_CHAR32)
7463 unsigned int val = TREE_INT_CST_LOW (value);
7482 if (val <= UCHAR_MAX && ISGRAPH (val))
7483 message = catenate_messages (gmsgid, " before %s'%c'");
7485 message = catenate_messages (gmsgid, " before %s'\\x%x'");
7487 error (message, prefix, val);
7491 else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
7492 || token == CPP_STRING32)
7493 message = catenate_messages (gmsgid, " before string constant");
7494 else if (token == CPP_NUMBER)
7495 message = catenate_messages (gmsgid, " before numeric constant");
7496 else if (token == CPP_NAME)
7498 message = catenate_messages (gmsgid, " before %qE");
7499 error (message, value);
7503 else if (token == CPP_PRAGMA)
7504 message = catenate_messages (gmsgid, " before %<#pragma%>");
7505 else if (token == CPP_PRAGMA_EOL)
7506 message = catenate_messages (gmsgid, " before end of line");
7507 else if (token < N_TTYPES)
7509 message = catenate_messages (gmsgid, " before %qs token");
7510 error (message, cpp_type2name (token));
7522 #undef catenate_messages
7525 /* Walk a gimplified function and warn for functions whose return value is
7526 ignored and attribute((warn_unused_result)) is set. This is done before
7527 inlining, so we don't have to worry about that. */
7530 c_warn_unused_result (gimple_seq seq)
7533 gimple_stmt_iterator i;
7535 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
7537 gimple g = gsi_stmt (i);
7539 switch (gimple_code (g))
7542 c_warn_unused_result (gimple_bind_body (g));
7545 c_warn_unused_result (gimple_try_eval (g));
7546 c_warn_unused_result (gimple_try_cleanup (g));
7549 c_warn_unused_result (gimple_catch_handler (g));
7551 case GIMPLE_EH_FILTER:
7552 c_warn_unused_result (gimple_eh_filter_failure (g));
7556 if (gimple_call_lhs (g))
7559 /* This is a naked call, as opposed to a GIMPLE_CALL with an
7560 LHS. All calls whose value is ignored should be
7561 represented like this. Look for the attribute. */
7562 fdecl = gimple_call_fndecl (g);
7563 ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
7565 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
7567 location_t loc = gimple_location (g);
7570 warning (0, "%Hignoring return value of %qD, "
7571 "declared with attribute warn_unused_result",
7574 warning (0, "%Hignoring return value of function "
7575 "declared with attribute warn_unused_result",
7581 /* Not a container, not a call, or a call whose value is used. */
7587 /* Convert a character from the host to the target execution character
7588 set. cpplib handles this, mostly. */
7591 c_common_to_target_charset (HOST_WIDE_INT c)
7593 /* Character constants in GCC proper are sign-extended under -fsigned-char,
7594 zero-extended under -fno-signed-char. cpplib insists that characters
7595 and character constants are always unsigned. Hence we must convert
7597 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
7599 uc = cpp_host_to_exec_charset (parse_in, uc);
7601 if (flag_signed_char)
7602 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
7603 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
7608 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
7609 component references, with STOP_REF, or alternatively an INDIRECT_REF of
7610 NULL, at the bottom; much like the traditional rendering of offsetof as a
7611 macro. Returns the folded and properly cast result. */
7614 fold_offsetof_1 (tree expr, tree stop_ref)
7616 enum tree_code code = PLUS_EXPR;
7619 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
7620 return size_zero_node;
7622 switch (TREE_CODE (expr))
7628 error ("cannot apply %<offsetof%> to static data member %qD", expr);
7629 return error_mark_node;
7633 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7634 return error_mark_node;
7637 gcc_assert (integer_zerop (expr));
7638 return size_zero_node;
7642 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7643 gcc_assert (base == error_mark_node || base == size_zero_node);
7647 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7648 if (base == error_mark_node)
7651 t = TREE_OPERAND (expr, 1);
7652 if (DECL_C_BIT_FIELD (t))
7654 error ("attempt to take address of bit-field structure "
7656 return error_mark_node;
7658 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
7659 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
7664 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7665 if (base == error_mark_node)
7668 t = TREE_OPERAND (expr, 1);
7669 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
7672 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
7674 t = convert (sizetype, t);
7675 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
7679 /* Handle static members of volatile structs. */
7680 t = TREE_OPERAND (expr, 1);
7681 gcc_assert (TREE_CODE (t) == VAR_DECL);
7682 return fold_offsetof_1 (t, stop_ref);
7688 return size_binop (code, base, off);
7692 fold_offsetof (tree expr, tree stop_ref)
7694 /* Convert back from the internal sizetype to size_t. */
7695 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
7698 /* Print an error message for an invalid lvalue. USE says
7699 how the lvalue is being used and so selects the error message. */
7702 lvalue_error (enum lvalue_use use)
7707 error ("lvalue required as left operand of assignment");
7710 error ("lvalue required as increment operand");
7713 error ("lvalue required as decrement operand");
7716 error ("lvalue required as unary %<&%> operand");
7719 error ("lvalue required in asm statement");
7726 /* *PTYPE is an incomplete array. Complete it with a domain based on
7727 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7728 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7729 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
7732 complete_array_type (tree *ptype, tree initial_value, bool do_default)
7734 tree maxindex, type, main_type, elt, unqual_elt;
7735 int failure = 0, quals;
7736 hashval_t hashcode = 0;
7738 maxindex = size_zero_node;
7741 if (TREE_CODE (initial_value) == STRING_CST)
7744 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7745 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
7747 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7749 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
7751 if (VEC_empty (constructor_elt, v))
7755 maxindex = integer_minus_one_node;
7760 unsigned HOST_WIDE_INT cnt;
7761 constructor_elt *ce;
7762 bool fold_p = false;
7764 if (VEC_index (constructor_elt, v, 0)->index)
7765 maxindex = fold_convert (sizetype,
7766 VEC_index (constructor_elt,
7768 curindex = maxindex;
7771 VEC_iterate (constructor_elt, v, cnt, ce);
7774 bool curfold_p = false;
7776 curindex = ce->index, curfold_p = true;
7780 curindex = fold_convert (sizetype, curindex);
7781 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
7783 if (tree_int_cst_lt (maxindex, curindex))
7784 maxindex = curindex, fold_p = curfold_p;
7787 maxindex = fold_convert (sizetype, maxindex);
7792 /* Make an error message unless that happened already. */
7793 if (initial_value != error_mark_node)
7805 elt = TREE_TYPE (type);
7806 quals = TYPE_QUALS (strip_array_types (elt));
7810 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
7812 /* Using build_distinct_type_copy and modifying things afterward instead
7813 of using build_array_type to create a new type preserves all of the
7814 TYPE_LANG_FLAG_? bits that the front end may have set. */
7815 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7816 TREE_TYPE (main_type) = unqual_elt;
7817 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
7818 layout_type (main_type);
7820 /* Make sure we have the canonical MAIN_TYPE. */
7821 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
7822 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
7824 main_type = type_hash_canon (hashcode, main_type);
7826 /* Fix the canonical type. */
7827 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
7828 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
7829 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
7830 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
7831 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
7832 != TYPE_DOMAIN (main_type)))
7833 TYPE_CANONICAL (main_type)
7834 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
7835 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
7837 TYPE_CANONICAL (main_type) = main_type;
7842 type = c_build_qualified_type (main_type, quals);
7844 if (COMPLETE_TYPE_P (type)
7845 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7846 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7848 error ("size of array is too large");
7849 /* If we proceed with the array type as it is, we'll eventually
7850 crash in tree_low_cst(). */
7851 type = error_mark_node;
7859 /* Used to help initialize the builtin-types.def table. When a type of
7860 the correct size doesn't exist, use error_mark_node instead of NULL.
7861 The later results in segfaults even when a decl using the type doesn't
7865 builtin_type_for_size (int size, bool unsignedp)
7867 tree type = lang_hooks.types.type_for_size (size, unsignedp);
7868 return type ? type : error_mark_node;
7871 /* A helper function for resolve_overloaded_builtin in resolving the
7872 overloaded __sync_ builtins. Returns a positive power of 2 if the
7873 first operand of PARAMS is a pointer to a supported data type.
7874 Returns 0 if an error is encountered. */
7877 sync_resolve_size (tree function, tree params)
7884 error ("too few arguments to function %qE", function);
7888 type = TREE_TYPE (TREE_VALUE (params));
7889 if (TREE_CODE (type) != POINTER_TYPE)
7892 type = TREE_TYPE (type);
7893 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
7896 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7897 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
7901 error ("incompatible type for argument %d of %qE", 1, function);
7905 /* A helper function for resolve_overloaded_builtin. Adds casts to
7906 PARAMS to make arguments match up with those of FUNCTION. Drops
7907 the variadic arguments at the end. Returns false if some error
7908 was encountered; true on success. */
7911 sync_resolve_params (tree orig_function, tree function, tree params)
7913 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
7917 /* We've declared the implementation functions to use "volatile void *"
7918 as the pointer parameter, so we shouldn't get any complaints from the
7919 call to check_function_arguments what ever type the user used. */
7920 arg_types = TREE_CHAIN (arg_types);
7921 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7924 /* For the rest of the values, we need to cast these to FTYPE, so that we
7925 don't get warnings for passing pointer types, etc. */
7926 while (arg_types != void_list_node)
7930 params = TREE_CHAIN (params);
7933 error ("too few arguments to function %qE", orig_function);
7937 /* ??? Ideally for the first conversion we'd use convert_for_assignment
7938 so that we get warnings for anything that doesn't match the pointer
7939 type. This isn't portable across the C and C++ front ends atm. */
7940 val = TREE_VALUE (params);
7941 val = convert (ptype, val);
7942 val = convert (TREE_VALUE (arg_types), val);
7943 TREE_VALUE (params) = val;
7945 arg_types = TREE_CHAIN (arg_types);
7949 /* The definition of these primitives is variadic, with the remaining
7950 being "an optional list of variables protected by the memory barrier".
7951 No clue what that's supposed to mean, precisely, but we consider all
7952 call-clobbered variables to be protected so we're safe. */
7953 TREE_CHAIN (params) = NULL;
7958 /* A helper function for resolve_overloaded_builtin. Adds a cast to
7959 RESULT to make it match the type of the first pointer argument in
7963 sync_resolve_return (tree params, tree result)
7965 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7966 ptype = TYPE_MAIN_VARIANT (ptype);
7967 return convert (ptype, result);
7970 /* Some builtin functions are placeholders for other expressions. This
7971 function should be called immediately after parsing the call expression
7972 before surrounding code has committed to the type of the expression.
7974 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7975 PARAMS is the argument list for the call. The return value is non-null
7976 when expansion is complete, and null if normal processing should
7980 resolve_overloaded_builtin (tree function, tree params)
7982 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
7983 switch (DECL_BUILT_IN_CLASS (function))
7985 case BUILT_IN_NORMAL:
7988 if (targetm.resolve_overloaded_builtin)
7989 return targetm.resolve_overloaded_builtin (function, params);
7996 /* Handle BUILT_IN_NORMAL here. */
7999 case BUILT_IN_FETCH_AND_ADD_N:
8000 case BUILT_IN_FETCH_AND_SUB_N:
8001 case BUILT_IN_FETCH_AND_OR_N:
8002 case BUILT_IN_FETCH_AND_AND_N:
8003 case BUILT_IN_FETCH_AND_XOR_N:
8004 case BUILT_IN_FETCH_AND_NAND_N:
8005 case BUILT_IN_ADD_AND_FETCH_N:
8006 case BUILT_IN_SUB_AND_FETCH_N:
8007 case BUILT_IN_OR_AND_FETCH_N:
8008 case BUILT_IN_AND_AND_FETCH_N:
8009 case BUILT_IN_XOR_AND_FETCH_N:
8010 case BUILT_IN_NAND_AND_FETCH_N:
8011 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8012 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8013 case BUILT_IN_LOCK_TEST_AND_SET_N:
8014 case BUILT_IN_LOCK_RELEASE_N:
8016 int n = sync_resolve_size (function, params);
8017 tree new_function, result;
8020 return error_mark_node;
8022 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8023 if (!sync_resolve_params (function, new_function, params))
8024 return error_mark_node;
8026 result = build_function_call (new_function, params);
8027 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8028 && orig_code != BUILT_IN_LOCK_RELEASE_N)
8029 result = sync_resolve_return (params, result);
8039 /* Ignoring their sign, return true if two scalar types are the same. */
8041 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8043 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8045 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8046 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8047 || c2 == FIXED_POINT_TYPE));
8049 /* Equality works here because c_common_signed_type uses
8050 TYPE_MAIN_VARIANT. */
8051 return c_common_signed_type (t1)
8052 == c_common_signed_type (t2);
8055 /* Check for missing format attributes on function pointers. LTYPE is
8056 the new type or left-hand side type. RTYPE is the old type or
8057 right-hand side type. Returns TRUE if LTYPE is missing the desired
8061 check_missing_format_attribute (tree ltype, tree rtype)
8063 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8066 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8067 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8072 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8073 if (is_attribute_p ("format", TREE_PURPOSE (la)))
8081 /* Subscripting with type char is likely to lose on a machine where
8082 chars are signed. So warn on any machine, but optionally. Don't
8083 warn for unsigned char since that type is safe. Don't warn for
8084 signed char because anyone who uses that must have done so
8085 deliberately. Furthermore, we reduce the false positive load by
8086 warning only for non-constant value of type char. */
8089 warn_array_subscript_with_type_char (tree index)
8091 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8092 && TREE_CODE (index) != INTEGER_CST)
8093 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8096 /* Implement -Wparentheses for the unexpected C precedence rules, to
8097 cover cases like x + y << z which readers are likely to
8098 misinterpret. We have seen an expression in which CODE is a binary
8099 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8100 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8101 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8102 expression was not formed using a binary or unary operator, or it
8103 was enclosed in parentheses. */
8106 warn_about_parentheses (enum tree_code code,
8107 enum tree_code code_left, tree arg_left,
8108 enum tree_code code_right, tree arg_right)
8110 if (!warn_parentheses)
8113 /* This macro tests that the expression ARG with original tree code
8114 CODE appears to be a boolean expression. or the result of folding a
8115 boolean expression. */
8116 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8117 (truth_value_p (TREE_CODE (ARG)) \
8118 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8119 /* Folding may create 0 or 1 integers from other expressions. */ \
8120 || ((CODE) != INTEGER_CST \
8121 && (integer_onep (ARG) || integer_zerop (ARG))))
8126 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8127 warning (OPT_Wparentheses,
8128 "suggest parentheses around %<+%> inside %<<<%>");
8129 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8130 warning (OPT_Wparentheses,
8131 "suggest parentheses around %<-%> inside %<<<%>");
8135 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8136 warning (OPT_Wparentheses,
8137 "suggest parentheses around %<+%> inside %<>>%>");
8138 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8139 warning (OPT_Wparentheses,
8140 "suggest parentheses around %<-%> inside %<>>%>");
8143 case TRUTH_ORIF_EXPR:
8144 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8145 warning (OPT_Wparentheses,
8146 "suggest parentheses around %<&&%> within %<||%>");
8150 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8151 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8152 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8153 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8154 warning (OPT_Wparentheses,
8155 "suggest parentheses around arithmetic in operand of %<|%>");
8156 /* Check cases like x|y==z */
8157 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8158 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8159 warning (OPT_Wparentheses,
8160 "suggest parentheses around comparison in operand of %<|%>");
8161 /* Check cases like !x | y */
8162 else if (code_left == TRUTH_NOT_EXPR
8163 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8164 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8165 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8169 if (code_left == BIT_AND_EXPR
8170 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8171 || code_right == BIT_AND_EXPR
8172 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8173 warning (OPT_Wparentheses,
8174 "suggest parentheses around arithmetic in operand of %<^%>");
8175 /* Check cases like x^y==z */
8176 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8177 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8178 warning (OPT_Wparentheses,
8179 "suggest parentheses around comparison in operand of %<^%>");
8183 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8184 warning (OPT_Wparentheses,
8185 "suggest parentheses around %<+%> in operand of %<&%>");
8186 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8187 warning (OPT_Wparentheses,
8188 "suggest parentheses around %<-%> in operand of %<&%>");
8189 /* Check cases like x&y==z */
8190 else 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 %<&%>");
8194 /* Check cases like !x & y */
8195 else if (code_left == TRUTH_NOT_EXPR
8196 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8197 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8198 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8202 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8203 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8204 warning (OPT_Wparentheses,
8205 "suggest parentheses around comparison in operand of %<==%>");
8208 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8209 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8210 warning (OPT_Wparentheses,
8211 "suggest parentheses around comparison in operand of %<!=%>");
8215 if (TREE_CODE_CLASS (code) == tcc_comparison
8216 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
8217 && code_left != NE_EXPR && code_left != EQ_EXPR
8218 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
8219 || (TREE_CODE_CLASS (code_right) == tcc_comparison
8220 && code_right != NE_EXPR && code_right != EQ_EXPR
8221 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
8222 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
8223 "have their mathematical meaning");
8226 #undef NOT_A_BOOLEAN_EXPR_P
8229 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8232 warn_for_unused_label (tree label)
8234 if (!TREE_USED (label))
8236 if (DECL_INITIAL (label))
8237 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
8239 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
8243 #ifndef TARGET_HAS_TARGETCM
8244 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
8247 /* Warn for division by zero according to the value of DIVISOR. LOC
8248 is the location of the division operator. */
8251 warn_for_div_by_zero (location_t loc, tree divisor)
8253 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8254 about division by zero. Do not issue a warning if DIVISOR has a
8255 floating-point type, since we consider 0.0/0.0 a valid way of
8256 generating a NaN. */
8257 if (skip_evaluation == 0
8258 && (integer_zerop (divisor) || fixed_zerop (divisor)))
8259 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
8262 /* Subroutine of build_binary_op. Give warnings for comparisons
8263 between signed and unsigned quantities that may fail. Do the
8264 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8265 so that casts will be considered, but default promotions won't
8268 LOCATION is the location of the comparison operator.
8270 The arguments of this function map directly to local variables
8271 of build_binary_op. */
8274 warn_for_sign_compare (location_t location,
8275 tree orig_op0, tree orig_op1,
8277 tree result_type, enum tree_code resultcode)
8279 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
8280 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
8281 int unsignedp0, unsignedp1;
8283 /* In C++, check for comparison of different enum types. */
8285 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
8286 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
8287 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
8288 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
8290 warning_at (location,
8291 OPT_Wsign_compare, "comparison between types %qT and %qT",
8292 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
8295 /* Do not warn if the comparison is being done in a signed type,
8296 since the signed type will only be chosen if it can represent
8297 all the values of the unsigned type. */
8298 if (!TYPE_UNSIGNED (result_type))
8300 /* Do not warn if both operands are unsigned. */
8301 else if (op0_signed == op1_signed)
8305 tree sop, uop, base_type;
8309 sop = orig_op0, uop = orig_op1;
8311 sop = orig_op1, uop = orig_op0;
8313 STRIP_TYPE_NOPS (sop);
8314 STRIP_TYPE_NOPS (uop);
8315 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
8316 ? TREE_TYPE (result_type) : result_type);
8318 /* Do not warn if the signed quantity is an unsuffixed integer
8319 literal (or some static constant expression involving such
8320 literals or a conditional expression involving such literals)
8321 and it is non-negative. */
8322 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
8324 /* Do not warn if the comparison is an equality operation, the
8325 unsigned quantity is an integral constant, and it would fit
8326 in the result if the result were signed. */
8327 else if (TREE_CODE (uop) == INTEGER_CST
8328 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
8329 && int_fits_type_p (uop, c_common_signed_type (base_type)))
8331 /* In C, do not warn if the unsigned quantity is an enumeration
8332 constant and its maximum value would fit in the result if the
8333 result were signed. */
8334 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
8335 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
8336 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
8337 c_common_signed_type (base_type)))
8340 warning_at (location,
8342 "comparison between signed and unsigned integer expressions");
8345 /* Warn if two unsigned values are being compared in a size larger
8346 than their original size, and one (and only one) is the result of
8347 a `~' operator. This comparison will always fail.
8349 Also warn if one operand is a constant, and the constant does not
8350 have all bits set that are set in the ~ operand when it is
8353 op0 = get_narrower (op0, &unsignedp0);
8354 op1 = get_narrower (op1, &unsignedp1);
8356 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
8357 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
8359 if (TREE_CODE (op0) == BIT_NOT_EXPR)
8360 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
8361 if (TREE_CODE (op1) == BIT_NOT_EXPR)
8362 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
8364 if (host_integerp (op0, 0) || host_integerp (op1, 0))
8367 HOST_WIDE_INT constant, mask;
8371 if (host_integerp (op0, 0))
8374 unsignedp = unsignedp1;
8375 constant = tree_low_cst (op0, 0);
8380 unsignedp = unsignedp0;
8381 constant = tree_low_cst (op1, 0);
8384 bits = TYPE_PRECISION (TREE_TYPE (primop));
8385 if (bits < TYPE_PRECISION (result_type)
8386 && bits < HOST_BITS_PER_LONG && unsignedp)
8388 mask = (~ (HOST_WIDE_INT) 0) << bits;
8389 if ((mask & constant) != mask)
8392 warning (OPT_Wsign_compare,
8393 "promoted ~unsigned is always non-zero");
8395 warning_at (location, OPT_Wsign_compare,
8396 "comparison of promoted ~unsigned with constant");
8400 else if (unsignedp0 && unsignedp1
8401 && (TYPE_PRECISION (TREE_TYPE (op0))
8402 < TYPE_PRECISION (result_type))
8403 && (TYPE_PRECISION (TREE_TYPE (op1))
8404 < TYPE_PRECISION (result_type)))
8405 warning_at (location, OPT_Wsign_compare,
8406 "comparison of promoted ~unsigned with unsigned");
8410 #include "gt-c-common.h"