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 (location_t location, enum tree_code resultcode,
3215 tree ptrop, tree intop)
3219 /* The result is a pointer of the same type that is being added. */
3220 tree result_type = TREE_TYPE (ptrop);
3222 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3224 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3225 "pointer of type %<void *%> used in arithmetic");
3226 size_exp = integer_one_node;
3228 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3230 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3231 "pointer to a function used in arithmetic");
3232 size_exp = integer_one_node;
3234 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3236 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3237 "pointer to member function used in arithmetic");
3238 size_exp = integer_one_node;
3241 size_exp = size_in_bytes (TREE_TYPE (result_type));
3243 /* We are manipulating pointer values, so we don't need to warn
3244 about relying on undefined signed overflow. We disable the
3245 warning here because we use integer types so fold won't know that
3246 they are really pointers. */
3247 fold_defer_overflow_warnings ();
3249 /* If what we are about to multiply by the size of the elements
3250 contains a constant term, apply distributive law
3251 and multiply that constant term separately.
3252 This helps produce common subexpressions. */
3253 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3254 && !TREE_CONSTANT (intop)
3255 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3256 && TREE_CONSTANT (size_exp)
3257 /* If the constant comes from pointer subtraction,
3258 skip this optimization--it would cause an error. */
3259 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3260 /* If the constant is unsigned, and smaller than the pointer size,
3261 then we must skip this optimization. This is because it could cause
3262 an overflow error if the constant is negative but INTOP is not. */
3263 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3264 || (TYPE_PRECISION (TREE_TYPE (intop))
3265 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3267 enum tree_code subcode = resultcode;
3268 tree int_type = TREE_TYPE (intop);
3269 if (TREE_CODE (intop) == MINUS_EXPR)
3270 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3271 /* Convert both subexpression types to the type of intop,
3272 because weird cases involving pointer arithmetic
3273 can result in a sum or difference with different type args. */
3274 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3276 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3277 intop = convert (int_type, TREE_OPERAND (intop, 0));
3280 /* Convert the integer argument to a type the same size as sizetype
3281 so the multiply won't overflow spuriously. */
3282 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3283 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3284 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3285 TYPE_UNSIGNED (sizetype)), intop);
3287 /* Replace the integer argument with a suitable product by the object size.
3288 Do this multiplication as signed, then convert to the appropriate
3289 type for the pointer operation. */
3290 intop = convert (sizetype,
3291 build_binary_op (EXPR_LOCATION (intop),
3293 convert (TREE_TYPE (intop), size_exp), 1));
3295 /* Create the sum or difference. */
3296 if (resultcode == MINUS_EXPR)
3297 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3299 if (TREE_CODE (intop) == INTEGER_CST)
3302 tree string_cst = string_constant (ptrop, &offset_node);
3305 && !(offset_node && TREE_CODE (offset_node) != INTEGER_CST))
3307 HOST_WIDE_INT max = TREE_STRING_LENGTH (string_cst);
3308 HOST_WIDE_INT offset;
3309 if (offset_node == 0)
3311 else if (! host_integerp (offset_node, 0))
3314 offset = tree_low_cst (offset_node, 0);
3316 offset = offset + tree_low_cst (intop, 0);
3317 if (offset < 0 || offset > max)
3318 warning_at (location, 0, "offset %<" HOST_WIDE_INT_PRINT_DEC
3319 "%> outside bounds of constant string",
3320 tree_low_cst (intop, 0));
3324 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3326 fold_undefer_and_ignore_overflow_warnings ();
3331 /* Return whether EXPR is a declaration whose address can never be
3335 decl_with_nonnull_addr_p (const_tree expr)
3337 return (DECL_P (expr)
3338 && (TREE_CODE (expr) == PARM_DECL
3339 || TREE_CODE (expr) == LABEL_DECL
3340 || !DECL_WEAK (expr)));
3343 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3344 or for an `if' or `while' statement or ?..: exp. It should already
3345 have been validated to be of suitable type; otherwise, a bad
3346 diagnostic may result.
3348 The EXPR is located at LOCATION.
3350 This preparation consists of taking the ordinary
3351 representation of an expression expr and producing a valid tree
3352 boolean expression describing whether expr is nonzero. We could
3353 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3354 but we optimize comparisons, &&, ||, and !.
3356 The resulting type should always be `truthvalue_type_node'. */
3359 c_common_truthvalue_conversion (location_t location, tree expr)
3361 switch (TREE_CODE (expr))
3363 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
3364 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3365 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3366 case ORDERED_EXPR: case UNORDERED_EXPR:
3367 if (TREE_TYPE (expr) == truthvalue_type_node)
3369 return build2 (TREE_CODE (expr), truthvalue_type_node,
3370 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3372 case TRUTH_ANDIF_EXPR:
3373 case TRUTH_ORIF_EXPR:
3374 case TRUTH_AND_EXPR:
3376 case TRUTH_XOR_EXPR:
3377 if (TREE_TYPE (expr) == truthvalue_type_node)
3379 return build2 (TREE_CODE (expr), truthvalue_type_node,
3380 c_common_truthvalue_conversion (location,
3381 TREE_OPERAND (expr, 0)),
3382 c_common_truthvalue_conversion (location,
3383 TREE_OPERAND (expr, 1)));
3385 case TRUTH_NOT_EXPR:
3386 if (TREE_TYPE (expr) == truthvalue_type_node)
3388 return build1 (TREE_CODE (expr), truthvalue_type_node,
3389 c_common_truthvalue_conversion (location,
3390 TREE_OPERAND (expr, 0)));
3396 return integer_zerop (expr) ? truthvalue_false_node
3397 : truthvalue_true_node;
3400 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3401 ? truthvalue_true_node
3402 : truthvalue_false_node;
3405 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3406 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3407 ? truthvalue_true_node
3408 : truthvalue_false_node;
3411 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3416 tree inner = TREE_OPERAND (expr, 0);
3417 if (decl_with_nonnull_addr_p (inner))
3419 /* Common Ada/Pascal programmer's mistake. */
3420 warning_at (location,
3422 "the address of %qD will always evaluate as %<true%>",
3424 return truthvalue_true_node;
3427 /* If we still have a decl, it is possible for its address to
3428 be NULL, so we cannot optimize. */
3431 gcc_assert (DECL_WEAK (inner));
3435 if (TREE_SIDE_EFFECTS (inner))
3436 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3437 inner, truthvalue_true_node);
3439 return truthvalue_true_node;
3443 return build_binary_op (EXPR_LOCATION (expr),
3444 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3445 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3446 c_common_truthvalue_conversion (location,
3447 TREE_OPERAND (expr, 0)),
3448 c_common_truthvalue_conversion (location,
3449 TREE_OPERAND (expr, 1)),
3455 /* These don't change whether an object is nonzero or zero. */
3456 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
3460 /* These don't change whether an object is zero or nonzero, but
3461 we can't ignore them if their second arg has side-effects. */
3462 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3463 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3464 TREE_OPERAND (expr, 1),
3465 c_common_truthvalue_conversion
3466 (location, TREE_OPERAND (expr, 0)));
3468 return c_common_truthvalue_conversion (location,
3469 TREE_OPERAND (expr, 0));
3472 /* Distribute the conversion into the arms of a COND_EXPR. */
3473 return fold_build3 (COND_EXPR, truthvalue_type_node,
3474 TREE_OPERAND (expr, 0),
3475 c_common_truthvalue_conversion (location,
3476 TREE_OPERAND (expr, 1)),
3477 c_common_truthvalue_conversion (location,
3478 TREE_OPERAND (expr, 2)));
3481 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3482 since that affects how `default_conversion' will behave. */
3483 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3484 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3486 /* If this is widening the argument, we can ignore it. */
3487 if (TYPE_PRECISION (TREE_TYPE (expr))
3488 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3489 return c_common_truthvalue_conversion (location,
3490 TREE_OPERAND (expr, 0));
3494 if (!TREE_NO_WARNING (expr)
3495 && warn_parentheses)
3497 warning (OPT_Wparentheses,
3498 "suggest parentheses around assignment used as truth value");
3499 TREE_NO_WARNING (expr) = 1;
3507 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3509 tree t = save_expr (expr);
3510 return (build_binary_op
3511 (EXPR_LOCATION (expr),
3512 (TREE_SIDE_EFFECTS (expr)
3513 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3514 c_common_truthvalue_conversion
3516 build_unary_op (location, REALPART_EXPR, t, 0)),
3517 c_common_truthvalue_conversion
3519 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3523 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3525 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3527 (TREE_TYPE (expr))));
3528 return build_binary_op (EXPR_LOCATION (expr),
3529 NE_EXPR, expr, fixed_zero_node, 1);
3532 return build_binary_op (EXPR_LOCATION (expr),
3533 NE_EXPR, expr, integer_zero_node, 1);
3536 static void def_builtin_1 (enum built_in_function fncode,
3538 enum built_in_class fnclass,
3539 tree fntype, tree libtype,
3540 bool both_p, bool fallback_p, bool nonansi_p,
3541 tree fnattrs, bool implicit_p);
3544 /* Apply the TYPE_QUALS to the new DECL. */
3547 c_apply_type_quals_to_decl (int type_quals, tree decl)
3549 tree type = TREE_TYPE (decl);
3551 if (type == error_mark_node)
3554 if (((type_quals & TYPE_QUAL_CONST)
3555 || (type && TREE_CODE (type) == REFERENCE_TYPE))
3556 /* An object declared 'const' is only readonly after it is
3557 initialized. We don't have any way of expressing this currently,
3558 so we need to be conservative and unset TREE_READONLY for types
3559 with constructors. Otherwise aliasing code will ignore stores in
3560 an inline constructor. */
3561 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3562 TREE_READONLY (decl) = 1;
3563 if (type_quals & TYPE_QUAL_VOLATILE)
3565 TREE_SIDE_EFFECTS (decl) = 1;
3566 TREE_THIS_VOLATILE (decl) = 1;
3568 if (type_quals & TYPE_QUAL_RESTRICT)
3570 while (type && TREE_CODE (type) == ARRAY_TYPE)
3571 /* Allow 'restrict' on arrays of pointers.
3572 FIXME currently we just ignore it. */
3573 type = TREE_TYPE (type);
3575 || !POINTER_TYPE_P (type)
3576 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3577 error ("invalid use of %<restrict%>");
3578 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3579 /* Indicate we need to make a unique alias set for this pointer.
3580 We can't do it here because it might be pointing to an
3582 DECL_POINTER_ALIAS_SET (decl) = -2;
3586 /* Hash function for the problem of multiple type definitions in
3587 different files. This must hash all types that will compare
3588 equal via comptypes to the same value. In practice it hashes
3589 on some of the simple stuff and leaves the details to comptypes. */
3592 c_type_hash (const void *p)
3596 const_tree const t = (const_tree) p;
3598 switch (TREE_CODE (t))
3600 /* For pointers, hash on pointee type plus some swizzling. */
3602 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3603 /* Hash on number of elements and total size. */
3606 t2 = TYPE_VALUES (t);
3610 t2 = TYPE_FIELDS (t);
3612 case QUAL_UNION_TYPE:
3614 t2 = TYPE_FIELDS (t);
3618 t2 = TYPE_FIELDS (t);
3623 for (; t2; t2 = TREE_CHAIN (t2))
3625 /* We might have a VLA here. */
3626 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
3629 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3630 return ((size << 24) | (i << shift));
3633 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3635 /* Return the typed-based alias set for T, which may be an expression
3636 or a type. Return -1 if we don't do anything special. */
3639 c_common_get_alias_set (tree t)
3644 /* Permit type-punning when accessing a union, provided the access
3645 is directly through the union. For example, this code does not
3646 permit taking the address of a union member and then storing
3647 through it. Even the type-punning allowed here is a GCC
3648 extension, albeit a common and useful one; the C standard says
3649 that such accesses have implementation-defined behavior. */
3651 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3652 u = TREE_OPERAND (u, 0))
3653 if (TREE_CODE (u) == COMPONENT_REF
3654 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3657 /* That's all the expressions we handle specially. */
3661 /* The C standard guarantees that any object may be accessed via an
3662 lvalue that has character type. */
3663 if (t == char_type_node
3664 || t == signed_char_type_node
3665 || t == unsigned_char_type_node)
3668 /* The C standard specifically allows aliasing between signed and
3669 unsigned variants of the same type. We treat the signed
3670 variant as canonical. */
3671 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3673 tree t1 = c_common_signed_type (t);
3675 /* t1 == t can happen for boolean nodes which are always unsigned. */
3677 return get_alias_set (t1);
3679 else if (POINTER_TYPE_P (t))
3683 /* Unfortunately, there is no canonical form of a pointer type.
3684 In particular, if we have `typedef int I', then `int *', and
3685 `I *' are different types. So, we have to pick a canonical
3686 representative. We do this below.
3688 Technically, this approach is actually more conservative that
3689 it needs to be. In particular, `const int *' and `int *'
3690 should be in different alias sets, according to the C and C++
3691 standard, since their types are not the same, and so,
3692 technically, an `int **' and `const int **' cannot point at
3695 But, the standard is wrong. In particular, this code is
3700 const int* const* cipp = ipp;
3702 And, it doesn't make sense for that to be legal unless you
3703 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3704 the pointed-to types. This issue has been reported to the
3706 t1 = build_type_no_quals (t);
3708 return get_alias_set (t1);
3711 /* Handle the case of multiple type nodes referring to "the same" type,
3712 which occurs with IMA. These share an alias set. FIXME: Currently only
3713 C90 is handled. (In C99 type compatibility is not transitive, which
3714 complicates things mightily. The alias set splay trees can theoretically
3715 represent this, but insertion is tricky when you consider all the
3716 different orders things might arrive in.) */
3718 if (c_language != clk_c || flag_isoc99)
3721 /* Save time if there's only one input file. */
3722 if (num_in_fnames == 1)
3725 /* Pointers need special handling if they point to any type that
3726 needs special handling (below). */
3727 if (TREE_CODE (t) == POINTER_TYPE)
3730 /* Find bottom type under any nested POINTERs. */
3731 for (t2 = TREE_TYPE (t);
3732 TREE_CODE (t2) == POINTER_TYPE;
3733 t2 = TREE_TYPE (t2))
3735 if (TREE_CODE (t2) != RECORD_TYPE
3736 && TREE_CODE (t2) != ENUMERAL_TYPE
3737 && TREE_CODE (t2) != QUAL_UNION_TYPE
3738 && TREE_CODE (t2) != UNION_TYPE)
3740 if (TYPE_SIZE (t2) == 0)
3743 /* These are the only cases that need special handling. */
3744 if (TREE_CODE (t) != RECORD_TYPE
3745 && TREE_CODE (t) != ENUMERAL_TYPE
3746 && TREE_CODE (t) != QUAL_UNION_TYPE
3747 && TREE_CODE (t) != UNION_TYPE
3748 && TREE_CODE (t) != POINTER_TYPE)
3751 if (TYPE_SIZE (t) == 0)
3754 /* Look up t in hash table. Only one of the compatible types within each
3755 alias set is recorded in the table. */
3756 if (!type_hash_table)
3757 type_hash_table = htab_create_ggc (1021, c_type_hash,
3758 (htab_eq) lang_hooks.types_compatible_p,
3760 slot = htab_find_slot (type_hash_table, t, INSERT);
3763 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3764 return TYPE_ALIAS_SET ((tree)*slot);
3767 /* Our caller will assign and record (in t) a new alias set; all we need
3768 to do is remember t in the hash table. */
3774 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3775 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3776 flag controls whether we should diagnose possibly ill-formed
3777 constructs or not. */
3780 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3782 const char *op_name;
3784 enum tree_code type_code = TREE_CODE (type);
3786 op_name = is_sizeof ? "sizeof" : "__alignof__";
3788 if (type_code == FUNCTION_TYPE)
3792 if (complain && (pedantic || warn_pointer_arith))
3793 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3794 "invalid application of %<sizeof%> to a function type");
3796 return error_mark_node;
3797 value = size_one_node;
3800 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3802 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3804 if (type_code == VOID_TYPE
3805 && complain && (pedantic || warn_pointer_arith))
3806 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3807 "invalid application of %qs to a void type", op_name);
3809 return error_mark_node;
3810 value = size_one_node;
3812 else if (!COMPLETE_TYPE_P (type))
3815 error ("invalid application of %qs to incomplete type %qT ",
3817 value = size_zero_node;
3822 /* Convert in case a char is more than one unit. */
3823 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3824 size_int (TYPE_PRECISION (char_type_node)
3827 value = size_int (TYPE_ALIGN_UNIT (type));
3830 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3831 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3832 never happen. However, this node should really have type
3833 `size_t', which is just a typedef for an ordinary integer type. */
3834 value = fold_convert (size_type_node, value);
3835 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3840 /* Implement the __alignof keyword: Return the minimum required
3841 alignment of EXPR, measured in bytes. For VAR_DECLs,
3842 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3843 from an "aligned" __attribute__ specification). */
3846 c_alignof_expr (tree expr)
3850 if (VAR_OR_FUNCTION_DECL_P (expr))
3851 t = size_int (DECL_ALIGN_UNIT (expr));
3853 else if (TREE_CODE (expr) == COMPONENT_REF
3854 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3856 error ("%<__alignof%> applied to a bit-field");
3859 else if (TREE_CODE (expr) == COMPONENT_REF
3860 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3861 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3863 else if (TREE_CODE (expr) == INDIRECT_REF)
3865 tree t = TREE_OPERAND (expr, 0);
3867 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3869 while (CONVERT_EXPR_P (t)
3870 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3874 t = TREE_OPERAND (t, 0);
3875 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3876 if (thisalign > bestalign)
3877 best = t, bestalign = thisalign;
3879 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3882 return c_alignof (TREE_TYPE (expr));
3884 return fold_convert (size_type_node, t);
3887 /* Handle C and C++ default attributes. */
3889 enum built_in_attribute
3891 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3892 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3893 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3894 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3895 #include "builtin-attrs.def"
3896 #undef DEF_ATTR_NULL_TREE
3898 #undef DEF_ATTR_IDENT
3899 #undef DEF_ATTR_TREE_LIST
3903 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3905 static void c_init_attributes (void);
3909 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3910 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3911 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3912 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3913 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3914 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3915 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3916 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3917 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3918 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3919 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3920 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3921 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3922 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3923 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3925 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3926 #include "builtin-types.def"
3927 #undef DEF_PRIMITIVE_TYPE
3928 #undef DEF_FUNCTION_TYPE_0
3929 #undef DEF_FUNCTION_TYPE_1
3930 #undef DEF_FUNCTION_TYPE_2
3931 #undef DEF_FUNCTION_TYPE_3
3932 #undef DEF_FUNCTION_TYPE_4
3933 #undef DEF_FUNCTION_TYPE_5
3934 #undef DEF_FUNCTION_TYPE_6
3935 #undef DEF_FUNCTION_TYPE_7
3936 #undef DEF_FUNCTION_TYPE_VAR_0
3937 #undef DEF_FUNCTION_TYPE_VAR_1
3938 #undef DEF_FUNCTION_TYPE_VAR_2
3939 #undef DEF_FUNCTION_TYPE_VAR_3
3940 #undef DEF_FUNCTION_TYPE_VAR_4
3941 #undef DEF_FUNCTION_TYPE_VAR_5
3942 #undef DEF_POINTER_TYPE
3946 typedef enum c_builtin_type builtin_type;
3948 /* A temporary array for c_common_nodes_and_builtins. Used in
3949 communication with def_fn_type. */
3950 static tree builtin_types[(int) BT_LAST + 1];
3952 /* A helper function for c_common_nodes_and_builtins. Build function type
3953 for DEF with return type RET and N arguments. If VAR is true, then the
3954 function should be variadic after those N arguments.
3956 Takes special care not to ICE if any of the types involved are
3957 error_mark_node, which indicates that said type is not in fact available
3958 (see builtin_type_for_size). In which case the function type as a whole
3959 should be error_mark_node. */
3962 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3964 tree args = NULL, t;
3969 for (i = 0; i < n; ++i)
3971 builtin_type a = (builtin_type) va_arg (list, int);
3972 t = builtin_types[a];
3973 if (t == error_mark_node)
3975 args = tree_cons (NULL_TREE, t, args);
3979 args = nreverse (args);
3981 args = chainon (args, void_list_node);
3983 t = builtin_types[ret];
3984 if (t == error_mark_node)
3986 t = build_function_type (t, args);
3989 builtin_types[def] = t;
3992 /* Build builtin functions common to both C and C++ language
3996 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3998 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3999 builtin_types[ENUM] = VALUE;
4000 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4001 def_fn_type (ENUM, RETURN, 0, 0);
4002 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4003 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4004 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4005 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4006 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4007 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4008 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4009 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4010 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4011 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4012 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4014 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4015 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4017 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4018 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4019 def_fn_type (ENUM, RETURN, 1, 0);
4020 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4021 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4022 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4023 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4024 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4025 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4026 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4027 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4028 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4029 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4030 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4031 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4033 #include "builtin-types.def"
4035 #undef DEF_PRIMITIVE_TYPE
4036 #undef DEF_FUNCTION_TYPE_1
4037 #undef DEF_FUNCTION_TYPE_2
4038 #undef DEF_FUNCTION_TYPE_3
4039 #undef DEF_FUNCTION_TYPE_4
4040 #undef DEF_FUNCTION_TYPE_5
4041 #undef DEF_FUNCTION_TYPE_6
4042 #undef DEF_FUNCTION_TYPE_VAR_0
4043 #undef DEF_FUNCTION_TYPE_VAR_1
4044 #undef DEF_FUNCTION_TYPE_VAR_2
4045 #undef DEF_FUNCTION_TYPE_VAR_3
4046 #undef DEF_FUNCTION_TYPE_VAR_4
4047 #undef DEF_FUNCTION_TYPE_VAR_5
4048 #undef DEF_POINTER_TYPE
4049 builtin_types[(int) BT_LAST] = NULL_TREE;
4051 c_init_attributes ();
4053 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4054 NONANSI_P, ATTRS, IMPLICIT, COND) \
4056 def_builtin_1 (ENUM, NAME, CLASS, \
4057 builtin_types[(int) TYPE], \
4058 builtin_types[(int) LIBTYPE], \
4059 BOTH_P, FALLBACK_P, NONANSI_P, \
4060 built_in_attributes[(int) ATTRS], IMPLICIT);
4061 #include "builtins.def"
4064 targetm.init_builtins ();
4066 build_common_builtin_nodes ();
4072 /* Build tree nodes and builtin functions common to both C and C++ language
4076 c_common_nodes_and_builtins (void)
4078 int char16_type_size;
4079 int char32_type_size;
4080 int wchar_type_size;
4081 tree array_domain_type;
4082 tree va_list_ref_type_node;
4083 tree va_list_arg_type_node;
4085 /* Define `int' and `char' first so that dbx will output them first. */
4086 record_builtin_type (RID_INT, NULL, integer_type_node);
4087 record_builtin_type (RID_CHAR, "char", char_type_node);
4089 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4090 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4091 but not C. Are the conditionals here needed? */
4092 if (c_dialect_cxx ())
4093 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4094 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4095 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4096 record_builtin_type (RID_MAX, "long unsigned int",
4097 long_unsigned_type_node);
4098 if (c_dialect_cxx ())
4099 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4100 record_builtin_type (RID_MAX, "long long int",
4101 long_long_integer_type_node);
4102 record_builtin_type (RID_MAX, "long long unsigned int",
4103 long_long_unsigned_type_node);
4104 if (c_dialect_cxx ())
4105 record_builtin_type (RID_MAX, "long long unsigned",
4106 long_long_unsigned_type_node);
4107 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4108 record_builtin_type (RID_MAX, "short unsigned int",
4109 short_unsigned_type_node);
4110 if (c_dialect_cxx ())
4111 record_builtin_type (RID_MAX, "unsigned short",
4112 short_unsigned_type_node);
4114 /* Define both `signed char' and `unsigned char'. */
4115 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4116 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4118 /* These are types that c_common_type_for_size and
4119 c_common_type_for_mode use. */
4120 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4122 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4124 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4126 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4128 #if HOST_BITS_PER_WIDE_INT >= 64
4129 if (targetm.scalar_mode_supported_p (TImode))
4130 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4131 get_identifier ("__int128_t"),
4134 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4135 unsigned_intQI_type_node));
4136 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4137 unsigned_intHI_type_node));
4138 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4139 unsigned_intSI_type_node));
4140 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4141 unsigned_intDI_type_node));
4142 #if HOST_BITS_PER_WIDE_INT >= 64
4143 if (targetm.scalar_mode_supported_p (TImode))
4144 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4145 get_identifier ("__uint128_t"),
4146 unsigned_intTI_type_node));
4149 /* Create the widest literal types. */
4150 widest_integer_literal_type_node
4151 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4152 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4153 widest_integer_literal_type_node));
4155 widest_unsigned_literal_type_node
4156 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4157 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4158 widest_unsigned_literal_type_node));
4160 /* `unsigned long' is the standard type for sizeof.
4161 Note that stddef.h uses `unsigned long',
4162 and this must agree, even if long and int are the same size. */
4164 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4165 signed_size_type_node = c_common_signed_type (size_type_node);
4166 set_sizetype (size_type_node);
4169 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4171 build_common_tree_nodes_2 (flag_short_double);
4173 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4174 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4175 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4177 /* Only supported decimal floating point extension if the target
4178 actually supports underlying modes. */
4179 if (targetm.scalar_mode_supported_p (SDmode)
4180 && targetm.scalar_mode_supported_p (DDmode)
4181 && targetm.scalar_mode_supported_p (TDmode))
4183 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4184 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4185 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4188 if (targetm.fixed_point_supported_p ())
4190 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4191 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4192 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4193 record_builtin_type (RID_MAX, "long long _Fract",
4194 long_long_fract_type_node);
4195 record_builtin_type (RID_MAX, "unsigned short _Fract",
4196 unsigned_short_fract_type_node);
4197 record_builtin_type (RID_MAX, "unsigned _Fract",
4198 unsigned_fract_type_node);
4199 record_builtin_type (RID_MAX, "unsigned long _Fract",
4200 unsigned_long_fract_type_node);
4201 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4202 unsigned_long_long_fract_type_node);
4203 record_builtin_type (RID_MAX, "_Sat short _Fract",
4204 sat_short_fract_type_node);
4205 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4206 record_builtin_type (RID_MAX, "_Sat long _Fract",
4207 sat_long_fract_type_node);
4208 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4209 sat_long_long_fract_type_node);
4210 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4211 sat_unsigned_short_fract_type_node);
4212 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4213 sat_unsigned_fract_type_node);
4214 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4215 sat_unsigned_long_fract_type_node);
4216 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4217 sat_unsigned_long_long_fract_type_node);
4218 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4219 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4220 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4221 record_builtin_type (RID_MAX, "long long _Accum",
4222 long_long_accum_type_node);
4223 record_builtin_type (RID_MAX, "unsigned short _Accum",
4224 unsigned_short_accum_type_node);
4225 record_builtin_type (RID_MAX, "unsigned _Accum",
4226 unsigned_accum_type_node);
4227 record_builtin_type (RID_MAX, "unsigned long _Accum",
4228 unsigned_long_accum_type_node);
4229 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4230 unsigned_long_long_accum_type_node);
4231 record_builtin_type (RID_MAX, "_Sat short _Accum",
4232 sat_short_accum_type_node);
4233 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4234 record_builtin_type (RID_MAX, "_Sat long _Accum",
4235 sat_long_accum_type_node);
4236 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4237 sat_long_long_accum_type_node);
4238 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4239 sat_unsigned_short_accum_type_node);
4240 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4241 sat_unsigned_accum_type_node);
4242 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4243 sat_unsigned_long_accum_type_node);
4244 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4245 sat_unsigned_long_long_accum_type_node);
4249 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4250 get_identifier ("complex int"),
4251 complex_integer_type_node));
4252 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4253 get_identifier ("complex float"),
4254 complex_float_type_node));
4255 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4256 get_identifier ("complex double"),
4257 complex_double_type_node));
4258 lang_hooks.decls.pushdecl
4259 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4260 complex_long_double_type_node));
4262 if (c_dialect_cxx ())
4263 /* For C++, make fileptr_type_node a distinct void * type until
4264 FILE type is defined. */
4265 fileptr_type_node = build_variant_type_copy (ptr_type_node);
4267 record_builtin_type (RID_VOID, NULL, void_type_node);
4269 /* Set the TYPE_NAME for any variants that were built before
4270 record_builtin_type gave names to the built-in types. */
4272 tree void_name = TYPE_NAME (void_type_node);
4273 TYPE_NAME (void_type_node) = NULL_TREE;
4274 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4276 TYPE_NAME (void_type_node) = void_name;
4279 /* This node must not be shared. */
4280 void_zero_node = make_node (INTEGER_CST);
4281 TREE_TYPE (void_zero_node) = void_type_node;
4283 void_list_node = build_void_list_node ();
4285 /* Make a type to be the domain of a few array types
4286 whose domains don't really matter.
4287 200 is small enough that it always fits in size_t
4288 and large enough that it can hold most function names for the
4289 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4290 array_domain_type = build_index_type (size_int (200));
4292 /* Make a type for arrays of characters.
4293 With luck nothing will ever really depend on the length of this
4295 char_array_type_node
4296 = build_array_type (char_type_node, array_domain_type);
4298 /* Likewise for arrays of ints. */
4300 = build_array_type (integer_type_node, array_domain_type);
4302 string_type_node = build_pointer_type (char_type_node);
4303 const_string_type_node
4304 = build_pointer_type (build_qualified_type
4305 (char_type_node, TYPE_QUAL_CONST));
4307 /* This is special for C++ so functions can be overloaded. */
4308 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4309 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4310 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4311 if (c_dialect_cxx ())
4313 if (TYPE_UNSIGNED (wchar_type_node))
4314 wchar_type_node = make_unsigned_type (wchar_type_size);
4316 wchar_type_node = make_signed_type (wchar_type_size);
4317 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4321 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
4322 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
4325 /* This is for wide string constants. */
4326 wchar_array_type_node
4327 = build_array_type (wchar_type_node, array_domain_type);
4329 /* Define 'char16_t'. */
4330 char16_type_node = get_identifier (CHAR16_TYPE);
4331 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4332 char16_type_size = TYPE_PRECISION (char16_type_node);
4333 if (c_dialect_cxx ())
4335 char16_type_node = make_unsigned_type (char16_type_size);
4337 if (cxx_dialect == cxx0x)
4338 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4341 /* This is for UTF-16 string constants. */
4342 char16_array_type_node
4343 = build_array_type (char16_type_node, array_domain_type);
4345 /* Define 'char32_t'. */
4346 char32_type_node = get_identifier (CHAR32_TYPE);
4347 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4348 char32_type_size = TYPE_PRECISION (char32_type_node);
4349 if (c_dialect_cxx ())
4351 char32_type_node = make_unsigned_type (char32_type_size);
4353 if (cxx_dialect == cxx0x)
4354 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4357 /* This is for UTF-32 string constants. */
4358 char32_array_type_node
4359 = build_array_type (char32_type_node, array_domain_type);
4362 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4365 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4367 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4369 default_function_type = build_function_type (integer_type_node, NULL_TREE);
4371 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
4372 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
4374 lang_hooks.decls.pushdecl
4375 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
4376 va_list_type_node));
4377 #ifdef TARGET_ENUM_VA_LIST
4382 for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
4384 lang_hooks.decls.pushdecl
4385 (build_decl (TYPE_DECL, get_identifier (pname),
4392 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4394 va_list_arg_type_node = va_list_ref_type_node =
4395 build_pointer_type (TREE_TYPE (va_list_type_node));
4399 va_list_arg_type_node = va_list_type_node;
4400 va_list_ref_type_node = build_reference_type (va_list_type_node);
4403 if (!flag_preprocess_only)
4404 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4406 main_identifier_node = get_identifier ("main");
4408 /* Create the built-in __null node. It is important that this is
4410 null_node = make_node (INTEGER_CST);
4411 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
4413 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4414 memset (builtin_types, 0, sizeof (builtin_types));
4417 /* Look up the function in built_in_decls that corresponds to DECL
4418 and set ASMSPEC as its user assembler name. DECL must be a
4419 function decl that declares a builtin. */
4422 set_builtin_user_assembler_name (tree decl, const char *asmspec)
4425 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
4426 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
4429 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
4430 set_user_assembler_name (builtin, asmspec);
4431 switch (DECL_FUNCTION_CODE (decl))
4433 case BUILT_IN_MEMCPY:
4434 init_block_move_fn (asmspec);
4435 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
4437 case BUILT_IN_MEMSET:
4438 init_block_clear_fn (asmspec);
4439 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
4441 case BUILT_IN_MEMMOVE:
4442 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
4444 case BUILT_IN_MEMCMP:
4445 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
4447 case BUILT_IN_ABORT:
4448 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
4455 /* The number of named compound-literals generated thus far. */
4456 static GTY(()) int compound_literal_number;
4458 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4461 set_compound_literal_name (tree decl)
4464 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4465 compound_literal_number);
4466 compound_literal_number++;
4467 DECL_NAME (decl) = get_identifier (name);
4471 build_va_arg (tree expr, tree type)
4473 return build1 (VA_ARG_EXPR, type, expr);
4477 /* Linked list of disabled built-in functions. */
4479 typedef struct disabled_builtin
4482 struct disabled_builtin *next;
4484 static disabled_builtin *disabled_builtins = NULL;
4486 static bool builtin_function_disabled_p (const char *);
4488 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4489 begins with "__builtin_", give an error. */
4492 disable_builtin_function (const char *name)
4494 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4495 error ("cannot disable built-in function %qs", name);
4498 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4499 new_disabled_builtin->name = name;
4500 new_disabled_builtin->next = disabled_builtins;
4501 disabled_builtins = new_disabled_builtin;
4506 /* Return true if the built-in function NAME has been disabled, false
4510 builtin_function_disabled_p (const char *name)
4512 disabled_builtin *p;
4513 for (p = disabled_builtins; p != NULL; p = p->next)
4515 if (strcmp (name, p->name) == 0)
4522 /* Worker for DEF_BUILTIN.
4523 Possibly define a builtin function with one or two names.
4524 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4525 nonansi_p and flag_no_nonansi_builtin. */
4528 def_builtin_1 (enum built_in_function fncode,
4530 enum built_in_class fnclass,
4531 tree fntype, tree libtype,
4532 bool both_p, bool fallback_p, bool nonansi_p,
4533 tree fnattrs, bool implicit_p)
4536 const char *libname;
4538 if (fntype == error_mark_node)
4541 gcc_assert ((!both_p && !fallback_p)
4542 || !strncmp (name, "__builtin_",
4543 strlen ("__builtin_")));
4545 libname = name + strlen ("__builtin_");
4546 decl = add_builtin_function (name, fntype, fncode, fnclass,
4547 (fallback_p ? libname : NULL),
4550 && !flag_no_builtin && !builtin_function_disabled_p (libname)
4551 && !(nonansi_p && flag_no_nonansi_builtin))
4552 add_builtin_function (libname, libtype, fncode, fnclass,
4555 built_in_decls[(int) fncode] = decl;
4557 implicit_built_in_decls[(int) fncode] = decl;
4560 /* Nonzero if the type T promotes to int. This is (nearly) the
4561 integral promotions defined in ISO C99 6.3.1.1/2. */
4564 c_promoting_integer_type_p (const_tree t)
4566 switch (TREE_CODE (t))
4569 return (TYPE_MAIN_VARIANT (t) == char_type_node
4570 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
4571 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
4572 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
4573 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
4574 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
4577 /* ??? Technically all enumerations not larger than an int
4578 promote to an int. But this is used along code paths
4579 that only want to notice a size change. */
4580 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
4590 /* Return 1 if PARMS specifies a fixed number of parameters
4591 and none of their types is affected by default promotions. */
4594 self_promoting_args_p (const_tree parms)
4597 for (t = parms; t; t = TREE_CHAIN (t))
4599 tree type = TREE_VALUE (t);
4601 if (type == error_mark_node)
4604 if (TREE_CHAIN (t) == 0 && type != void_type_node)
4610 if (TYPE_MAIN_VARIANT (type) == float_type_node)
4613 if (c_promoting_integer_type_p (type))
4619 /* Recursively remove any '*' or '&' operator from TYPE. */
4621 strip_pointer_operator (tree t)
4623 while (POINTER_TYPE_P (t))
4628 /* Recursively remove pointer or array type from TYPE. */
4630 strip_pointer_or_array_types (tree t)
4632 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
4637 /* Used to compare case labels. K1 and K2 are actually tree nodes
4638 representing case labels, or NULL_TREE for a `default' label.
4639 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4640 K2, and 0 if K1 and K2 are equal. */
4643 case_compare (splay_tree_key k1, splay_tree_key k2)
4645 /* Consider a NULL key (such as arises with a `default' label) to be
4646 smaller than anything else. */
4652 return tree_int_cst_compare ((tree) k1, (tree) k2);
4655 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4656 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4657 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4658 case label was declared using the usual C/C++ syntax, rather than
4659 the GNU case range extension. CASES is a tree containing all the
4660 case ranges processed so far; COND is the condition for the
4661 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
4662 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
4665 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
4666 tree low_value, tree high_value)
4671 splay_tree_node node;
4673 /* Create the LABEL_DECL itself. */
4674 label = create_artificial_label ();
4676 /* If there was an error processing the switch condition, bail now
4677 before we get more confused. */
4678 if (!cond || cond == error_mark_node)
4681 if ((low_value && TREE_TYPE (low_value)
4682 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4683 || (high_value && TREE_TYPE (high_value)
4684 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4686 error ("pointers are not permitted as case values");
4690 /* Case ranges are a GNU extension. */
4692 pedwarn (input_location, OPT_pedantic,
4693 "range expressions in switch statements are non-standard");
4695 type = TREE_TYPE (cond);
4698 low_value = check_case_value (low_value);
4699 low_value = convert_and_check (type, low_value);
4700 if (low_value == error_mark_node)
4705 high_value = check_case_value (high_value);
4706 high_value = convert_and_check (type, high_value);
4707 if (high_value == error_mark_node)
4711 if (low_value && high_value)
4713 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4714 really a case range, even though it was written that way.
4715 Remove the HIGH_VALUE to simplify later processing. */
4716 if (tree_int_cst_equal (low_value, high_value))
4717 high_value = NULL_TREE;
4718 else if (!tree_int_cst_lt (low_value, high_value))
4719 warning (0, "empty range specified");
4722 /* See if the case is in range of the type of the original testing
4723 expression. If both low_value and high_value are out of range,
4724 don't insert the case label and return NULL_TREE. */
4726 && !check_case_bounds (type, orig_type,
4727 &low_value, high_value ? &high_value : NULL))
4730 /* Look up the LOW_VALUE in the table of case labels we already
4732 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4733 /* If there was not an exact match, check for overlapping ranges.
4734 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4735 that's a `default' label and the only overlap is an exact match. */
4736 if (!node && (low_value || high_value))
4738 splay_tree_node low_bound;
4739 splay_tree_node high_bound;
4741 /* Even though there wasn't an exact match, there might be an
4742 overlap between this case range and another case range.
4743 Since we've (inductively) not allowed any overlapping case
4744 ranges, we simply need to find the greatest low case label
4745 that is smaller that LOW_VALUE, and the smallest low case
4746 label that is greater than LOW_VALUE. If there is an overlap
4747 it will occur in one of these two ranges. */
4748 low_bound = splay_tree_predecessor (cases,
4749 (splay_tree_key) low_value);
4750 high_bound = splay_tree_successor (cases,
4751 (splay_tree_key) low_value);
4753 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4754 the LOW_VALUE, so there is no need to check unless the
4755 LOW_BOUND is in fact itself a case range. */
4757 && CASE_HIGH ((tree) low_bound->value)
4758 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4761 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4762 range is bigger than the low end of the current range, so we
4763 are only interested if the current range is a real range, and
4764 not an ordinary case label. */
4767 && (tree_int_cst_compare ((tree) high_bound->key,
4772 /* If there was an overlap, issue an error. */
4775 tree duplicate = CASE_LABEL ((tree) node->value);
4779 error ("duplicate (or overlapping) case value");
4780 error ("%Jthis is the first entry overlapping that value", duplicate);
4784 error ("duplicate case value") ;
4785 error ("%Jpreviously used here", duplicate);
4789 error ("multiple default labels in one switch");
4790 error ("%Jthis is the first default label", duplicate);
4795 /* Add a CASE_LABEL to the statement-tree. */
4796 case_label = add_stmt (build_case_label (low_value, high_value, label));
4797 /* Register this case label in the splay tree. */
4798 splay_tree_insert (cases,
4799 (splay_tree_key) low_value,
4800 (splay_tree_value) case_label);
4805 /* Add a label so that the back-end doesn't think that the beginning of
4806 the switch is unreachable. Note that we do not add a case label, as
4807 that just leads to duplicates and thence to failure later on. */
4810 tree t = create_artificial_label ();
4811 add_stmt (build_stmt (LABEL_EXPR, t));
4813 return error_mark_node;
4816 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4817 Used to verify that case values match up with enumerator values. */
4820 match_case_to_enum_1 (tree key, tree type, tree label)
4822 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4824 /* ??? Not working too hard to print the double-word value.
4825 Should perhaps be done with %lwd in the diagnostic routines? */
4826 if (TREE_INT_CST_HIGH (key) == 0)
4827 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4828 TREE_INT_CST_LOW (key));
4829 else if (!TYPE_UNSIGNED (type)
4830 && TREE_INT_CST_HIGH (key) == -1
4831 && TREE_INT_CST_LOW (key) != 0)
4832 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4833 -TREE_INT_CST_LOW (key));
4835 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4836 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
4837 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
4839 if (TYPE_NAME (type) == 0)
4840 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4841 "%Jcase value %qs not in enumerated type",
4842 CASE_LABEL (label), buf);
4844 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4845 "%Jcase value %qs not in enumerated type %qT",
4846 CASE_LABEL (label), buf, type);
4849 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4850 Used to verify that case values match up with enumerator values. */
4853 match_case_to_enum (splay_tree_node node, void *data)
4855 tree label = (tree) node->value;
4856 tree type = (tree) data;
4858 /* Skip default case. */
4859 if (!CASE_LOW (label))
4862 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4863 when we did our enum->case scan. Reset our scratch bit after. */
4864 if (!CASE_LOW_SEEN (label))
4865 match_case_to_enum_1 (CASE_LOW (label), type, label);
4867 CASE_LOW_SEEN (label) = 0;
4869 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4870 not set, that means that CASE_HIGH did not appear when we did our
4871 enum->case scan. Reset our scratch bit after. */
4872 if (CASE_HIGH (label))
4874 if (!CASE_HIGH_SEEN (label))
4875 match_case_to_enum_1 (CASE_HIGH (label), type, label);
4877 CASE_HIGH_SEEN (label) = 0;
4883 /* Handle -Wswitch*. Called from the front end after parsing the
4884 switch construct. */
4885 /* ??? Should probably be somewhere generic, since other languages
4886 besides C and C++ would want this. At the moment, however, C/C++
4887 are the only tree-ssa languages that support enumerations at all,
4888 so the point is moot. */
4891 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4892 tree type, tree cond)
4894 splay_tree_node default_node;
4895 splay_tree_node node;
4897 int saved_warn_switch;
4899 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4902 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4904 warning (OPT_Wswitch_default, "%Hswitch missing default case",
4907 /* From here on, we only care about about enumerated types. */
4908 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4911 /* If the switch expression was an enumerated type, check that
4912 exactly all enumeration literals are covered by the cases.
4913 The check is made when -Wswitch was specified and there is no
4914 default case, or when -Wswitch-enum was specified. */
4916 if (!warn_switch_enum
4917 && !(warn_switch && !default_node))
4920 /* Clearing COND if it is not an integer constant simplifies
4921 the tests inside the loop below. */
4922 if (TREE_CODE (cond) != INTEGER_CST)
4925 /* The time complexity here is O(N*lg(N)) worst case, but for the
4926 common case of monotonically increasing enumerators, it is
4927 O(N), since the nature of the splay tree will keep the next
4928 element adjacent to the root at all times. */
4930 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4932 tree value = TREE_VALUE (chain);
4933 if (TREE_CODE (value) == CONST_DECL)
4934 value = DECL_INITIAL (value);
4935 node = splay_tree_lookup (cases, (splay_tree_key) value);
4938 /* Mark the CASE_LOW part of the case entry as seen. */
4939 tree label = (tree) node->value;
4940 CASE_LOW_SEEN (label) = 1;
4944 /* Even though there wasn't an exact match, there might be a
4945 case range which includes the enumerator's value. */
4946 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4947 if (node && CASE_HIGH ((tree) node->value))
4949 tree label = (tree) node->value;
4950 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4953 /* If we match the upper bound exactly, mark the CASE_HIGH
4954 part of the case entry as seen. */
4956 CASE_HIGH_SEEN (label) = 1;
4961 /* We've now determined that this enumerated literal isn't
4962 handled by the case labels of the switch statement. */
4964 /* If the switch expression is a constant, we only really care
4965 about whether that constant is handled by the switch. */
4966 if (cond && tree_int_cst_compare (cond, value))
4969 /* If there is a default_node, the only relevant option is
4970 Wswitch-enum. Otherwise, if both are enabled then we prefer
4971 to warn using -Wswitch because -Wswitch is enabled by -Wall
4972 while -Wswitch-enum is explicit. */
4973 warning ((default_node || !warn_switch)
4974 ? OPT_Wswitch_enum : OPT_Wswitch,
4975 "%Henumeration value %qE not handled in switch",
4976 &switch_location, TREE_PURPOSE (chain));
4979 /* Warn if there are case expressions that don't correspond to
4980 enumerators. This can occur since C and C++ don't enforce
4981 type-checking of assignments to enumeration variables.
4983 The time complexity here is now always O(N) worst case, since
4984 we should have marked both the lower bound and upper bound of
4985 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4986 above. This scan also resets those fields. */
4988 /* If there is a default_node, the only relevant option is
4989 Wswitch-enum. Otherwise, if both are enabled then we prefer
4990 to warn using -Wswitch because -Wswitch is enabled by -Wall
4991 while -Wswitch-enum is explicit. */
4992 saved_warn_switch = warn_switch;
4995 splay_tree_foreach (cases, match_case_to_enum, type);
4996 warn_switch = saved_warn_switch;
5000 /* Finish an expression taking the address of LABEL (an
5001 IDENTIFIER_NODE). Returns an expression for the address.
5003 LOC is the location for the expression returned. */
5006 finish_label_address_expr (tree label, location_t loc)
5010 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5012 if (label == error_mark_node)
5013 return error_mark_node;
5015 label = lookup_label (label);
5016 if (label == NULL_TREE)
5017 result = null_pointer_node;
5020 TREE_USED (label) = 1;
5021 result = build1 (ADDR_EXPR, ptr_type_node, label);
5022 /* The current function in not necessarily uninlinable.
5023 Computed gotos are incompatible with inlining, but the value
5024 here could be used only in a diagnostic, for example. */
5025 protected_set_expr_location (result, loc);
5031 /* Hook used by expand_expr to expand language-specific tree codes. */
5032 /* The only things that should go here are bits needed to expand
5033 constant initializers. Everything else should be handled by the
5034 gimplification routines. */
5037 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
5038 int modifiera /* Actually enum expand_modifier. */,
5041 enum expand_modifier modifier = (enum expand_modifier) modifiera;
5042 switch (TREE_CODE (exp))
5044 case COMPOUND_LITERAL_EXPR:
5046 /* Initialize the anonymous variable declared in the compound
5047 literal, then return the variable. */
5048 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
5049 emit_local_var (decl);
5050 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
5058 /* Hook used by staticp to handle language-specific tree codes. */
5061 c_staticp (tree exp)
5063 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
5064 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
5069 /* Given a boolean expression ARG, return a tree representing an increment
5070 or decrement (as indicated by CODE) of ARG. The front end must check for
5071 invalid cases (e.g., decrement in C++). */
5073 boolean_increment (enum tree_code code, tree arg)
5076 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5078 arg = stabilize_reference (arg);
5081 case PREINCREMENT_EXPR:
5082 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5084 case POSTINCREMENT_EXPR:
5085 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5086 arg = save_expr (arg);
5087 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5088 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5090 case PREDECREMENT_EXPR:
5091 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5092 invert_truthvalue (arg));
5094 case POSTDECREMENT_EXPR:
5095 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5096 invert_truthvalue (arg));
5097 arg = save_expr (arg);
5098 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5099 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5104 TREE_SIDE_EFFECTS (val) = 1;
5108 /* Built-in macros for stddef.h, that require macros defined in this
5111 c_stddef_cpp_builtins(void)
5113 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5114 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5115 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5116 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5117 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5118 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5119 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5120 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5124 c_init_attributes (void)
5126 /* Fill in the built_in_attributes array. */
5127 #define DEF_ATTR_NULL_TREE(ENUM) \
5128 built_in_attributes[(int) ENUM] = NULL_TREE;
5129 #define DEF_ATTR_INT(ENUM, VALUE) \
5130 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5131 #define DEF_ATTR_IDENT(ENUM, STRING) \
5132 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5133 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5134 built_in_attributes[(int) ENUM] \
5135 = tree_cons (built_in_attributes[(int) PURPOSE], \
5136 built_in_attributes[(int) VALUE], \
5137 built_in_attributes[(int) CHAIN]);
5138 #include "builtin-attrs.def"
5139 #undef DEF_ATTR_NULL_TREE
5141 #undef DEF_ATTR_IDENT
5142 #undef DEF_ATTR_TREE_LIST
5145 /* Attribute handlers common to C front ends. */
5147 /* Handle a "packed" attribute; arguments as in
5148 struct attribute_spec.handler. */
5151 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5152 int flags, bool *no_add_attrs)
5156 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5157 *node = build_variant_type_copy (*node);
5158 TYPE_PACKED (*node) = 1;
5160 else if (TREE_CODE (*node) == FIELD_DECL)
5162 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5163 /* Still pack bitfields. */
5164 && ! DECL_INITIAL (*node))
5165 warning (OPT_Wattributes,
5166 "%qE attribute ignored for field of type %qT",
5167 name, TREE_TYPE (*node));
5169 DECL_PACKED (*node) = 1;
5171 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5172 used for DECL_REGISTER. It wouldn't mean anything anyway.
5173 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5174 that changes what the typedef is typing. */
5177 warning (OPT_Wattributes, "%qE attribute ignored", name);
5178 *no_add_attrs = true;
5184 /* Handle a "nocommon" attribute; arguments as in
5185 struct attribute_spec.handler. */
5188 handle_nocommon_attribute (tree *node, tree name,
5189 tree ARG_UNUSED (args),
5190 int ARG_UNUSED (flags), bool *no_add_attrs)
5192 if (TREE_CODE (*node) == VAR_DECL)
5193 DECL_COMMON (*node) = 0;
5196 warning (OPT_Wattributes, "%qE attribute ignored", name);
5197 *no_add_attrs = true;
5203 /* Handle a "common" attribute; arguments as in
5204 struct attribute_spec.handler. */
5207 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5208 int ARG_UNUSED (flags), bool *no_add_attrs)
5210 if (TREE_CODE (*node) == VAR_DECL)
5211 DECL_COMMON (*node) = 1;
5214 warning (OPT_Wattributes, "%qE attribute ignored", name);
5215 *no_add_attrs = true;
5221 /* Handle a "noreturn" attribute; arguments as in
5222 struct attribute_spec.handler. */
5225 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5226 int ARG_UNUSED (flags), bool *no_add_attrs)
5228 tree type = TREE_TYPE (*node);
5230 /* See FIXME comment in c_common_attribute_table. */
5231 if (TREE_CODE (*node) == FUNCTION_DECL)
5232 TREE_THIS_VOLATILE (*node) = 1;
5233 else if (TREE_CODE (type) == POINTER_TYPE
5234 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5236 = build_pointer_type
5237 (build_type_variant (TREE_TYPE (type),
5238 TYPE_READONLY (TREE_TYPE (type)), 1));
5241 warning (OPT_Wattributes, "%qE attribute ignored", name);
5242 *no_add_attrs = true;
5248 /* Handle a "hot" and attribute; arguments as in
5249 struct attribute_spec.handler. */
5252 handle_hot_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 ("cold", 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 hot processing is done later with
5264 lookup_attribute. */
5268 warning (OPT_Wattributes, "%qE attribute ignored", name);
5269 *no_add_attrs = true;
5274 /* Handle a "cold" and attribute; arguments as in
5275 struct attribute_spec.handler. */
5278 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5279 int ARG_UNUSED (flags), bool *no_add_attrs)
5281 if (TREE_CODE (*node) == FUNCTION_DECL)
5283 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5285 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5287 *no_add_attrs = true;
5289 /* Most of the rest of the cold processing is done later with
5290 lookup_attribute. */
5294 warning (OPT_Wattributes, "%qE attribute ignored", name);
5295 *no_add_attrs = true;
5301 /* Handle a "noinline" attribute; arguments as in
5302 struct attribute_spec.handler. */
5305 handle_noinline_attribute (tree *node, tree name,
5306 tree ARG_UNUSED (args),
5307 int ARG_UNUSED (flags), bool *no_add_attrs)
5309 if (TREE_CODE (*node) == FUNCTION_DECL)
5310 DECL_UNINLINABLE (*node) = 1;
5313 warning (OPT_Wattributes, "%qE attribute ignored", name);
5314 *no_add_attrs = true;
5320 /* Handle a "always_inline" attribute; arguments as in
5321 struct attribute_spec.handler. */
5324 handle_always_inline_attribute (tree *node, tree name,
5325 tree ARG_UNUSED (args),
5326 int ARG_UNUSED (flags),
5329 if (TREE_CODE (*node) == FUNCTION_DECL)
5331 /* Set the attribute and mark it for disregarding inline
5333 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
5337 warning (OPT_Wattributes, "%qE attribute ignored", name);
5338 *no_add_attrs = true;
5344 /* Handle a "gnu_inline" attribute; arguments as in
5345 struct attribute_spec.handler. */
5348 handle_gnu_inline_attribute (tree *node, tree name,
5349 tree ARG_UNUSED (args),
5350 int ARG_UNUSED (flags),
5353 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5355 /* Do nothing else, just set the attribute. We'll get at
5356 it later with lookup_attribute. */
5360 warning (OPT_Wattributes, "%qE attribute ignored", name);
5361 *no_add_attrs = true;
5367 /* Handle an "artificial" attribute; arguments as in
5368 struct attribute_spec.handler. */
5371 handle_artificial_attribute (tree *node, tree name,
5372 tree ARG_UNUSED (args),
5373 int ARG_UNUSED (flags),
5376 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5378 /* Do nothing else, just set the attribute. We'll get at
5379 it later with lookup_attribute. */
5383 warning (OPT_Wattributes, "%qE attribute ignored", name);
5384 *no_add_attrs = true;
5390 /* Handle a "flatten" attribute; arguments as in
5391 struct attribute_spec.handler. */
5394 handle_flatten_attribute (tree *node, tree name,
5395 tree args ATTRIBUTE_UNUSED,
5396 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5398 if (TREE_CODE (*node) == FUNCTION_DECL)
5399 /* Do nothing else, just set the attribute. We'll get at
5400 it later with lookup_attribute. */
5404 warning (OPT_Wattributes, "%qE attribute ignored", name);
5405 *no_add_attrs = true;
5411 /* Handle a "warning" or "error" attribute; arguments as in
5412 struct attribute_spec.handler. */
5415 handle_error_attribute (tree *node, tree name, tree args,
5416 int ARG_UNUSED (flags), bool *no_add_attrs)
5418 if (TREE_CODE (*node) == FUNCTION_DECL
5419 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5420 /* Do nothing else, just set the attribute. We'll get at
5421 it later with lookup_attribute. */
5425 warning (OPT_Wattributes, "%qE attribute ignored", name);
5426 *no_add_attrs = true;
5432 /* Handle a "used" attribute; arguments as in
5433 struct attribute_spec.handler. */
5436 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
5437 int ARG_UNUSED (flags), bool *no_add_attrs)
5441 if (TREE_CODE (node) == FUNCTION_DECL
5442 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
5444 TREE_USED (node) = 1;
5445 DECL_PRESERVE_P (node) = 1;
5449 warning (OPT_Wattributes, "%qE attribute ignored", name);
5450 *no_add_attrs = true;
5456 /* Handle a "unused" attribute; arguments as in
5457 struct attribute_spec.handler. */
5460 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5461 int flags, bool *no_add_attrs)
5467 if (TREE_CODE (decl) == PARM_DECL
5468 || TREE_CODE (decl) == VAR_DECL
5469 || TREE_CODE (decl) == FUNCTION_DECL
5470 || TREE_CODE (decl) == LABEL_DECL
5471 || TREE_CODE (decl) == TYPE_DECL)
5472 TREE_USED (decl) = 1;
5475 warning (OPT_Wattributes, "%qE attribute ignored", name);
5476 *no_add_attrs = true;
5481 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5482 *node = build_variant_type_copy (*node);
5483 TREE_USED (*node) = 1;
5489 /* Handle a "externally_visible" attribute; arguments as in
5490 struct attribute_spec.handler. */
5493 handle_externally_visible_attribute (tree *pnode, tree name,
5494 tree ARG_UNUSED (args),
5495 int ARG_UNUSED (flags),
5500 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
5502 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
5503 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
5505 warning (OPT_Wattributes,
5506 "%qE attribute have effect only on public objects", name);
5507 *no_add_attrs = true;
5512 warning (OPT_Wattributes, "%qE attribute ignored", name);
5513 *no_add_attrs = true;
5519 /* Handle a "const" attribute; arguments as in
5520 struct attribute_spec.handler. */
5523 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5524 int ARG_UNUSED (flags), bool *no_add_attrs)
5526 tree type = TREE_TYPE (*node);
5528 /* See FIXME comment on noreturn in c_common_attribute_table. */
5529 if (TREE_CODE (*node) == FUNCTION_DECL)
5530 TREE_READONLY (*node) = 1;
5531 else if (TREE_CODE (type) == POINTER_TYPE
5532 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5534 = build_pointer_type
5535 (build_type_variant (TREE_TYPE (type), 1,
5536 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5539 warning (OPT_Wattributes, "%qE attribute ignored", name);
5540 *no_add_attrs = true;
5546 /* Handle a "transparent_union" attribute; arguments as in
5547 struct attribute_spec.handler. */
5550 handle_transparent_union_attribute (tree *node, tree name,
5551 tree ARG_UNUSED (args), int flags,
5556 *no_add_attrs = true;
5558 if (TREE_CODE (*node) == TYPE_DECL)
5559 node = &TREE_TYPE (*node);
5562 if (TREE_CODE (type) == UNION_TYPE)
5564 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5565 the code in finish_struct. */
5566 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5568 if (TYPE_FIELDS (type) == NULL_TREE
5569 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
5572 /* A type variant isn't good enough, since we don't a cast
5573 to such a type removed as a no-op. */
5574 *node = type = build_duplicate_type (type);
5577 TYPE_TRANSPARENT_UNION (type) = 1;
5582 warning (OPT_Wattributes, "%qE attribute ignored", name);
5586 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
5587 get the requested priority for a constructor or destructor,
5588 possibly issuing diagnostics for invalid or reserved
5591 static priority_type
5592 get_priority (tree args, bool is_destructor)
5598 return DEFAULT_INIT_PRIORITY;
5600 if (!SUPPORTS_INIT_PRIORITY)
5603 error ("destructor priorities are not supported");
5605 error ("constructor priorities are not supported");
5606 return DEFAULT_INIT_PRIORITY;
5609 arg = TREE_VALUE (args);
5610 if (!host_integerp (arg, /*pos=*/0)
5611 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
5614 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
5615 if (pri < 0 || pri > MAX_INIT_PRIORITY)
5618 if (pri <= MAX_RESERVED_INIT_PRIORITY)
5622 "destructor priorities from 0 to %d are reserved "
5623 "for the implementation",
5624 MAX_RESERVED_INIT_PRIORITY);
5627 "constructor priorities from 0 to %d are reserved "
5628 "for the implementation",
5629 MAX_RESERVED_INIT_PRIORITY);
5635 error ("destructor priorities must be integers from 0 to %d inclusive",
5638 error ("constructor priorities must be integers from 0 to %d inclusive",
5640 return DEFAULT_INIT_PRIORITY;
5643 /* Handle a "constructor" attribute; arguments as in
5644 struct attribute_spec.handler. */
5647 handle_constructor_attribute (tree *node, tree name, tree args,
5648 int ARG_UNUSED (flags),
5652 tree type = TREE_TYPE (decl);
5654 if (TREE_CODE (decl) == FUNCTION_DECL
5655 && TREE_CODE (type) == FUNCTION_TYPE
5656 && decl_function_context (decl) == 0)
5658 priority_type priority;
5659 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5660 priority = get_priority (args, /*is_destructor=*/false);
5661 SET_DECL_INIT_PRIORITY (decl, priority);
5662 TREE_USED (decl) = 1;
5666 warning (OPT_Wattributes, "%qE attribute ignored", name);
5667 *no_add_attrs = true;
5673 /* Handle a "destructor" attribute; arguments as in
5674 struct attribute_spec.handler. */
5677 handle_destructor_attribute (tree *node, tree name, tree args,
5678 int ARG_UNUSED (flags),
5682 tree type = TREE_TYPE (decl);
5684 if (TREE_CODE (decl) == FUNCTION_DECL
5685 && TREE_CODE (type) == FUNCTION_TYPE
5686 && decl_function_context (decl) == 0)
5688 priority_type priority;
5689 DECL_STATIC_DESTRUCTOR (decl) = 1;
5690 priority = get_priority (args, /*is_destructor=*/true);
5691 SET_DECL_FINI_PRIORITY (decl, priority);
5692 TREE_USED (decl) = 1;
5696 warning (OPT_Wattributes, "%qE attribute ignored", name);
5697 *no_add_attrs = true;
5703 /* Handle a "mode" attribute; arguments as in
5704 struct attribute_spec.handler. */
5707 handle_mode_attribute (tree *node, tree name, tree args,
5708 int ARG_UNUSED (flags), bool *no_add_attrs)
5712 *no_add_attrs = true;
5714 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5715 warning (OPT_Wattributes, "%qE attribute ignored", name);
5719 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5720 int len = strlen (p);
5721 enum machine_mode mode = VOIDmode;
5725 if (len > 4 && p[0] == '_' && p[1] == '_'
5726 && p[len - 1] == '_' && p[len - 2] == '_')
5728 char *newp = (char *) alloca (len - 1);
5730 strcpy (newp, &p[2]);
5731 newp[len - 4] = '\0';
5735 /* Change this type to have a type with the specified mode.
5736 First check for the special modes. */
5737 if (!strcmp (p, "byte"))
5739 else if (!strcmp (p, "word"))
5741 else if (!strcmp (p, "pointer"))
5743 else if (!strcmp (p, "libgcc_cmp_return"))
5744 mode = targetm.libgcc_cmp_return_mode ();
5745 else if (!strcmp (p, "libgcc_shift_count"))
5746 mode = targetm.libgcc_shift_count_mode ();
5747 else if (!strcmp (p, "unwind_word"))
5748 mode = targetm.unwind_word_mode ();
5750 for (j = 0; j < NUM_MACHINE_MODES; j++)
5751 if (!strcmp (p, GET_MODE_NAME (j)))
5753 mode = (enum machine_mode) j;
5757 if (mode == VOIDmode)
5759 error ("unknown machine mode %qs", p);
5764 switch (GET_MODE_CLASS (mode))
5767 case MODE_PARTIAL_INT:
5769 case MODE_DECIMAL_FLOAT:
5774 valid_mode = targetm.scalar_mode_supported_p (mode);
5777 case MODE_COMPLEX_INT:
5778 case MODE_COMPLEX_FLOAT:
5779 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5782 case MODE_VECTOR_INT:
5783 case MODE_VECTOR_FLOAT:
5784 case MODE_VECTOR_FRACT:
5785 case MODE_VECTOR_UFRACT:
5786 case MODE_VECTOR_ACCUM:
5787 case MODE_VECTOR_UACCUM:
5788 warning (OPT_Wattributes, "specifying vector types with "
5789 "__attribute__ ((mode)) is deprecated");
5790 warning (OPT_Wattributes,
5791 "use __attribute__ ((vector_size)) instead");
5792 valid_mode = vector_mode_valid_p (mode);
5800 error ("unable to emulate %qs", p);
5804 if (POINTER_TYPE_P (type))
5806 tree (*fn)(tree, enum machine_mode, bool);
5808 if (!targetm.valid_pointer_mode (mode))
5810 error ("invalid pointer mode %qs", p);
5814 if (TREE_CODE (type) == POINTER_TYPE)
5815 fn = build_pointer_type_for_mode;
5817 fn = build_reference_type_for_mode;
5818 typefm = fn (TREE_TYPE (type), mode, false);
5822 /* For fixed-point modes, we need to test if the signness of type
5823 and the machine mode are consistent. */
5824 if (ALL_FIXED_POINT_MODE_P (mode)
5825 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
5827 error ("signness of type and machine mode %qs don't match", p);
5830 /* For fixed-point modes, we need to pass saturating info. */
5831 typefm = lang_hooks.types.type_for_mode (mode,
5832 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
5833 : TYPE_UNSIGNED (type));
5836 if (typefm == NULL_TREE)
5838 error ("no data type for mode %qs", p);
5841 else if (TREE_CODE (type) == ENUMERAL_TYPE)
5843 /* For enumeral types, copy the precision from the integer
5844 type returned above. If not an INTEGER_TYPE, we can't use
5845 this mode for this type. */
5846 if (TREE_CODE (typefm) != INTEGER_TYPE)
5848 error ("cannot use mode %qs for enumeral types", p);
5852 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5854 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5859 /* We cannot build a type variant, as there's code that assumes
5860 that TYPE_MAIN_VARIANT has the same mode. This includes the
5861 debug generators. Instead, create a subrange type. This
5862 results in all of the enumeral values being emitted only once
5863 in the original, and the subtype gets them by reference. */
5864 if (TYPE_UNSIGNED (type))
5865 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5867 typefm = make_signed_type (TYPE_PRECISION (typefm));
5868 TREE_TYPE (typefm) = type;
5871 else if (VECTOR_MODE_P (mode)
5872 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5873 : TREE_CODE (type) != TREE_CODE (typefm))
5875 error ("mode %qs applied to inappropriate type", p);
5885 /* Handle a "section" attribute; arguments as in
5886 struct attribute_spec.handler. */
5889 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5890 int ARG_UNUSED (flags), bool *no_add_attrs)
5894 if (targetm.have_named_sections)
5896 user_defined_section_attribute = true;
5898 if ((TREE_CODE (decl) == FUNCTION_DECL
5899 || TREE_CODE (decl) == VAR_DECL)
5900 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5902 if (TREE_CODE (decl) == VAR_DECL
5903 && current_function_decl != NULL_TREE
5904 && !TREE_STATIC (decl))
5906 error ("%Jsection attribute cannot be specified for "
5907 "local variables", decl);
5908 *no_add_attrs = true;
5911 /* The decl may have already been given a section attribute
5912 from a previous declaration. Ensure they match. */
5913 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5914 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5915 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5917 error ("section of %q+D conflicts with previous declaration",
5919 *no_add_attrs = true;
5921 else if (TREE_CODE (decl) == VAR_DECL
5922 && !targetm.have_tls && targetm.emutls.tmpl_section
5923 && DECL_THREAD_LOCAL_P (decl))
5925 error ("section of %q+D cannot be overridden", *node);
5926 *no_add_attrs = true;
5929 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5933 error ("section attribute not allowed for %q+D", *node);
5934 *no_add_attrs = true;
5939 error ("%Jsection attributes are not supported for this target", *node);
5940 *no_add_attrs = true;
5946 /* Handle a "aligned" attribute; arguments as in
5947 struct attribute_spec.handler. */
5950 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5951 int flags, bool *no_add_attrs)
5953 tree decl = NULL_TREE;
5956 tree align_expr = (args ? TREE_VALUE (args)
5957 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
5963 type = &TREE_TYPE (decl);
5964 is_type = TREE_CODE (*node) == TYPE_DECL;
5966 else if (TYPE_P (*node))
5967 type = node, is_type = 1;
5969 if (TREE_CODE (align_expr) != INTEGER_CST)
5971 error ("requested alignment is not a constant");
5972 *no_add_attrs = true;
5974 else if ((i = tree_log2 (align_expr)) == -1)
5976 error ("requested alignment is not a power of 2");
5977 *no_add_attrs = true;
5979 else if (i > HOST_BITS_PER_INT - 2)
5981 error ("requested alignment is too large");
5982 *no_add_attrs = true;
5986 /* If we have a TYPE_DECL, then copy the type, so that we
5987 don't accidentally modify a builtin type. See pushdecl. */
5988 if (decl && TREE_TYPE (decl) != error_mark_node
5989 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5991 tree tt = TREE_TYPE (decl);
5992 *type = build_variant_type_copy (*type);
5993 DECL_ORIGINAL_TYPE (decl) = tt;
5994 TYPE_NAME (*type) = decl;
5995 TREE_USED (*type) = TREE_USED (decl);
5996 TREE_TYPE (decl) = *type;
5998 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5999 *type = build_variant_type_copy (*type);
6001 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
6002 TYPE_USER_ALIGN (*type) = 1;
6004 else if (! VAR_OR_FUNCTION_DECL_P (decl)
6005 && TREE_CODE (decl) != FIELD_DECL)
6007 error ("alignment may not be specified for %q+D", decl);
6008 *no_add_attrs = true;
6010 else if (TREE_CODE (decl) == FUNCTION_DECL
6011 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
6013 if (DECL_USER_ALIGN (decl))
6014 error ("alignment for %q+D was previously specified as %d "
6015 "and may not be decreased", decl,
6016 DECL_ALIGN (decl) / BITS_PER_UNIT);
6018 error ("alignment for %q+D must be at least %d", decl,
6019 DECL_ALIGN (decl) / BITS_PER_UNIT);
6020 *no_add_attrs = true;
6024 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
6025 DECL_USER_ALIGN (decl) = 1;
6031 /* Handle a "weak" attribute; arguments as in
6032 struct attribute_spec.handler. */
6035 handle_weak_attribute (tree *node, tree name,
6036 tree ARG_UNUSED (args),
6037 int ARG_UNUSED (flags),
6038 bool * ARG_UNUSED (no_add_attrs))
6040 if (TREE_CODE (*node) == FUNCTION_DECL
6041 && DECL_DECLARED_INLINE_P (*node))
6043 error ("inline function %q+D cannot be declared weak", *node);
6044 *no_add_attrs = true;
6046 else if (TREE_CODE (*node) == FUNCTION_DECL
6047 || TREE_CODE (*node) == VAR_DECL)
6048 declare_weak (*node);
6050 warning (OPT_Wattributes, "%qE attribute ignored", name);
6055 /* Handle an "alias" attribute; arguments as in
6056 struct attribute_spec.handler. */
6059 handle_alias_attribute (tree *node, tree name, tree args,
6060 int ARG_UNUSED (flags), bool *no_add_attrs)
6064 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6066 warning (OPT_Wattributes, "%qE attribute ignored", name);
6067 *no_add_attrs = true;
6069 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6070 || (TREE_CODE (decl) != FUNCTION_DECL
6071 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6072 /* A static variable declaration is always a tentative definition,
6073 but the alias is a non-tentative definition which overrides. */
6074 || (TREE_CODE (decl) != FUNCTION_DECL
6075 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6077 error ("%q+D defined both normally and as an alias", decl);
6078 *no_add_attrs = true;
6081 /* Note that the very first time we process a nested declaration,
6082 decl_function_context will not be set. Indeed, *would* never
6083 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6084 we do below. After such frobbery, pushdecl would set the context.
6085 In any case, this is never what we want. */
6086 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6090 id = TREE_VALUE (args);
6091 if (TREE_CODE (id) != STRING_CST)
6093 error ("alias argument not a string");
6094 *no_add_attrs = true;
6097 id = get_identifier (TREE_STRING_POINTER (id));
6098 /* This counts as a use of the object pointed to. */
6101 if (TREE_CODE (decl) == FUNCTION_DECL)
6102 DECL_INITIAL (decl) = error_mark_node;
6105 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6106 DECL_EXTERNAL (decl) = 1;
6108 DECL_EXTERNAL (decl) = 0;
6109 TREE_STATIC (decl) = 1;
6114 warning (OPT_Wattributes, "%qE attribute ignored", name);
6115 *no_add_attrs = true;
6121 /* Handle a "weakref" attribute; arguments as in struct
6122 attribute_spec.handler. */
6125 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6126 int flags, bool *no_add_attrs)
6128 tree attr = NULL_TREE;
6130 /* We must ignore the attribute when it is associated with
6131 local-scoped decls, since attribute alias is ignored and many
6132 such symbols do not even have a DECL_WEAK field. */
6133 if (decl_function_context (*node)
6134 || current_function_decl
6135 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6137 warning (OPT_Wattributes, "%qE attribute ignored", name);
6138 *no_add_attrs = true;
6142 /* The idea here is that `weakref("name")' mutates into `weakref,
6143 alias("name")', and weakref without arguments, in turn,
6144 implicitly adds weak. */
6148 attr = tree_cons (get_identifier ("alias"), args, attr);
6149 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6151 *no_add_attrs = true;
6153 decl_attributes (node, attr, flags);
6157 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6158 error ("%Jweakref attribute must appear before alias attribute",
6161 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6162 and that isn't supported; and because it wants to add it to
6163 the list of weak decls, which isn't helpful. */
6164 DECL_WEAK (*node) = 1;
6170 /* Handle an "visibility" attribute; arguments as in
6171 struct attribute_spec.handler. */
6174 handle_visibility_attribute (tree *node, tree name, tree args,
6175 int ARG_UNUSED (flags),
6176 bool *ARG_UNUSED (no_add_attrs))
6179 tree id = TREE_VALUE (args);
6180 enum symbol_visibility vis;
6184 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6186 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6188 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6192 else if (TYPE_FIELDS (*node))
6194 error ("%qE attribute ignored because %qT is already defined",
6199 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6201 warning (OPT_Wattributes, "%qE attribute ignored", name);
6205 if (TREE_CODE (id) != STRING_CST)
6207 error ("visibility argument not a string");
6211 /* If this is a type, set the visibility on the type decl. */
6214 decl = TYPE_NAME (decl);
6217 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6219 warning (OPT_Wattributes, "%qE attribute ignored on types",
6225 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6226 vis = VISIBILITY_DEFAULT;
6227 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6228 vis = VISIBILITY_INTERNAL;
6229 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6230 vis = VISIBILITY_HIDDEN;
6231 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6232 vis = VISIBILITY_PROTECTED;
6235 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6236 vis = VISIBILITY_DEFAULT;
6239 if (DECL_VISIBILITY_SPECIFIED (decl)
6240 && vis != DECL_VISIBILITY (decl))
6242 tree attributes = (TYPE_P (*node)
6243 ? TYPE_ATTRIBUTES (*node)
6244 : DECL_ATTRIBUTES (decl));
6245 if (lookup_attribute ("visibility", attributes))
6246 error ("%qD redeclared with different visibility", decl);
6247 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6248 && lookup_attribute ("dllimport", attributes))
6249 error ("%qD was declared %qs which implies default visibility",
6251 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6252 && lookup_attribute ("dllexport", attributes))
6253 error ("%qD was declared %qs which implies default visibility",
6257 DECL_VISIBILITY (decl) = vis;
6258 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6260 /* Go ahead and attach the attribute to the node as well. This is needed
6261 so we can determine whether we have VISIBILITY_DEFAULT because the
6262 visibility was not specified, or because it was explicitly overridden
6263 from the containing scope. */
6268 /* Determine the ELF symbol visibility for DECL, which is either a
6269 variable or a function. It is an error to use this function if a
6270 definition of DECL is not available in this translation unit.
6271 Returns true if the final visibility has been determined by this
6272 function; false if the caller is free to make additional
6276 c_determine_visibility (tree decl)
6278 gcc_assert (TREE_CODE (decl) == VAR_DECL
6279 || TREE_CODE (decl) == FUNCTION_DECL);
6281 /* If the user explicitly specified the visibility with an
6282 attribute, honor that. DECL_VISIBILITY will have been set during
6283 the processing of the attribute. We check for an explicit
6284 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6285 to distinguish the use of an attribute from the use of a "#pragma
6286 GCC visibility push(...)"; in the latter case we still want other
6287 considerations to be able to overrule the #pragma. */
6288 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6289 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6290 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6291 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6294 /* Set default visibility to whatever the user supplied with
6295 visibility_specified depending on #pragma GCC visibility. */
6296 if (!DECL_VISIBILITY_SPECIFIED (decl))
6298 if (visibility_options.inpragma
6299 || DECL_VISIBILITY (decl) != default_visibility)
6301 DECL_VISIBILITY (decl) = default_visibility;
6302 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6303 /* If visibility changed and DECL already has DECL_RTL, ensure
6304 symbol flags are updated. */
6305 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6306 || TREE_CODE (decl) == FUNCTION_DECL)
6307 && DECL_RTL_SET_P (decl))
6308 make_decl_rtl (decl);
6314 /* Handle an "tls_model" attribute; arguments as in
6315 struct attribute_spec.handler. */
6318 handle_tls_model_attribute (tree *node, tree name, tree args,
6319 int ARG_UNUSED (flags), bool *no_add_attrs)
6323 enum tls_model kind;
6325 *no_add_attrs = true;
6327 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
6329 warning (OPT_Wattributes, "%qE attribute ignored", name);
6333 kind = DECL_TLS_MODEL (decl);
6334 id = TREE_VALUE (args);
6335 if (TREE_CODE (id) != STRING_CST)
6337 error ("tls_model argument not a string");
6341 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
6342 kind = TLS_MODEL_LOCAL_EXEC;
6343 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
6344 kind = TLS_MODEL_INITIAL_EXEC;
6345 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
6346 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
6347 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
6348 kind = TLS_MODEL_GLOBAL_DYNAMIC;
6350 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6352 DECL_TLS_MODEL (decl) = kind;
6356 /* Handle a "no_instrument_function" attribute; arguments as in
6357 struct attribute_spec.handler. */
6360 handle_no_instrument_function_attribute (tree *node, tree name,
6361 tree ARG_UNUSED (args),
6362 int ARG_UNUSED (flags),
6367 if (TREE_CODE (decl) != FUNCTION_DECL)
6369 error ("%J%qE attribute applies only to functions", decl, name);
6370 *no_add_attrs = true;
6372 else if (DECL_INITIAL (decl))
6374 error ("%Jcan%'t set %qE attribute after definition", decl, name);
6375 *no_add_attrs = true;
6378 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6383 /* Handle a "malloc" attribute; arguments as in
6384 struct attribute_spec.handler. */
6387 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6388 int ARG_UNUSED (flags), bool *no_add_attrs)
6390 if (TREE_CODE (*node) == FUNCTION_DECL
6391 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
6392 DECL_IS_MALLOC (*node) = 1;
6395 warning (OPT_Wattributes, "%qE attribute ignored", name);
6396 *no_add_attrs = true;
6402 /* Handle a "alloc_size" attribute; arguments as in
6403 struct attribute_spec.handler. */
6406 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6407 int ARG_UNUSED (flags), bool *no_add_attrs)
6409 unsigned arg_count = type_num_arguments (*node);
6410 for (; args; args = TREE_CHAIN (args))
6412 tree position = TREE_VALUE (args);
6414 if (TREE_CODE (position) != INTEGER_CST
6415 || TREE_INT_CST_HIGH (position)
6416 || TREE_INT_CST_LOW (position) < 1
6417 || TREE_INT_CST_LOW (position) > arg_count )
6419 warning (OPT_Wattributes,
6420 "alloc_size parameter outside range");
6421 *no_add_attrs = true;
6428 /* Handle a "returns_twice" attribute; arguments as in
6429 struct attribute_spec.handler. */
6432 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6433 int ARG_UNUSED (flags), bool *no_add_attrs)
6435 if (TREE_CODE (*node) == FUNCTION_DECL)
6436 DECL_IS_RETURNS_TWICE (*node) = 1;
6439 warning (OPT_Wattributes, "%qE attribute ignored", name);
6440 *no_add_attrs = true;
6446 /* Handle a "no_limit_stack" attribute; arguments as in
6447 struct attribute_spec.handler. */
6450 handle_no_limit_stack_attribute (tree *node, tree name,
6451 tree ARG_UNUSED (args),
6452 int ARG_UNUSED (flags),
6457 if (TREE_CODE (decl) != FUNCTION_DECL)
6459 error ("%J%qE attribute applies only to functions", decl, name);
6460 *no_add_attrs = true;
6462 else if (DECL_INITIAL (decl))
6464 error ("%Jcan%'t set %qE attribute after definition", decl, name);
6465 *no_add_attrs = true;
6468 DECL_NO_LIMIT_STACK (decl) = 1;
6473 /* Handle a "pure" attribute; arguments as in
6474 struct attribute_spec.handler. */
6477 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6478 int ARG_UNUSED (flags), bool *no_add_attrs)
6480 if (TREE_CODE (*node) == FUNCTION_DECL)
6481 DECL_PURE_P (*node) = 1;
6482 /* ??? TODO: Support types. */
6485 warning (OPT_Wattributes, "%qE attribute ignored", name);
6486 *no_add_attrs = true;
6492 /* Handle a "no vops" attribute; arguments as in
6493 struct attribute_spec.handler. */
6496 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
6497 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6498 bool *ARG_UNUSED (no_add_attrs))
6500 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
6501 DECL_IS_NOVOPS (*node) = 1;
6505 /* Handle a "deprecated" attribute; arguments as in
6506 struct attribute_spec.handler. */
6509 handle_deprecated_attribute (tree *node, tree name,
6510 tree ARG_UNUSED (args), int flags,
6513 tree type = NULL_TREE;
6515 tree what = NULL_TREE;
6520 type = TREE_TYPE (decl);
6522 if (TREE_CODE (decl) == TYPE_DECL
6523 || TREE_CODE (decl) == PARM_DECL
6524 || TREE_CODE (decl) == VAR_DECL
6525 || TREE_CODE (decl) == FUNCTION_DECL
6526 || TREE_CODE (decl) == FIELD_DECL)
6527 TREE_DEPRECATED (decl) = 1;
6531 else if (TYPE_P (*node))
6533 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6534 *node = build_variant_type_copy (*node);
6535 TREE_DEPRECATED (*node) = 1;
6543 *no_add_attrs = true;
6544 if (type && TYPE_NAME (type))
6546 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6547 what = TYPE_NAME (*node);
6548 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6549 && DECL_NAME (TYPE_NAME (type)))
6550 what = DECL_NAME (TYPE_NAME (type));
6553 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
6555 warning (OPT_Wattributes, "%qE attribute ignored", name);
6561 /* Handle a "vector_size" attribute; arguments as in
6562 struct attribute_spec.handler. */
6565 handle_vector_size_attribute (tree *node, tree name, tree args,
6566 int ARG_UNUSED (flags),
6569 unsigned HOST_WIDE_INT vecsize, nunits;
6570 enum machine_mode orig_mode;
6571 tree type = *node, new_type, size;
6573 *no_add_attrs = true;
6575 size = TREE_VALUE (args);
6577 if (!host_integerp (size, 1))
6579 warning (OPT_Wattributes, "%qE attribute ignored", name);
6583 /* Get the vector size (in bytes). */
6584 vecsize = tree_low_cst (size, 1);
6586 /* We need to provide for vector pointers, vector arrays, and
6587 functions returning vectors. For example:
6589 __attribute__((vector_size(16))) short *foo;
6591 In this case, the mode is SI, but the type being modified is
6592 HI, so we need to look further. */
6594 while (POINTER_TYPE_P (type)
6595 || TREE_CODE (type) == FUNCTION_TYPE
6596 || TREE_CODE (type) == METHOD_TYPE
6597 || TREE_CODE (type) == ARRAY_TYPE
6598 || TREE_CODE (type) == OFFSET_TYPE)
6599 type = TREE_TYPE (type);
6601 /* Get the mode of the type being modified. */
6602 orig_mode = TYPE_MODE (type);
6604 if ((!INTEGRAL_TYPE_P (type)
6605 && !SCALAR_FLOAT_TYPE_P (type)
6606 && !FIXED_POINT_TYPE_P (type))
6607 || (!SCALAR_FLOAT_MODE_P (orig_mode)
6608 && GET_MODE_CLASS (orig_mode) != MODE_INT
6609 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
6610 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
6611 || TREE_CODE (type) == BOOLEAN_TYPE)
6613 error ("invalid vector type for attribute %qE", name);
6617 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
6619 error ("vector size not an integral multiple of component size");
6625 error ("zero vector size");
6629 /* Calculate how many units fit in the vector. */
6630 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6631 if (nunits & (nunits - 1))
6633 error ("number of components of the vector not a power of two");
6637 new_type = build_vector_type (type, nunits);
6639 /* Build back pointers if needed. */
6640 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
6645 /* Handle the "nonnull" attribute. */
6647 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
6648 tree args, int ARG_UNUSED (flags),
6652 unsigned HOST_WIDE_INT attr_arg_num;
6654 /* If no arguments are specified, all pointer arguments should be
6655 non-null. Verify a full prototype is given so that the arguments
6656 will have the correct types when we actually check them later. */
6659 if (!TYPE_ARG_TYPES (type))
6661 error ("nonnull attribute without arguments on a non-prototype");
6662 *no_add_attrs = true;
6667 /* Argument list specified. Verify that each argument number references
6668 a pointer argument. */
6669 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6672 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
6674 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
6676 error ("nonnull argument has invalid operand number (argument %lu)",
6677 (unsigned long) attr_arg_num);
6678 *no_add_attrs = true;
6682 argument = TYPE_ARG_TYPES (type);
6685 for (ck_num = 1; ; ck_num++)
6687 if (!argument || ck_num == arg_num)
6689 argument = TREE_CHAIN (argument);
6693 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6695 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6696 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6697 *no_add_attrs = true;
6701 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6703 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6704 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6705 *no_add_attrs = true;
6714 /* Check the argument list of a function call for null in argument slots
6715 that are marked as requiring a non-null pointer argument. The NARGS
6716 arguments are passed in the array ARGARRAY.
6720 check_function_nonnull (tree attrs, int nargs, tree *argarray)
6725 for (a = attrs; a; a = TREE_CHAIN (a))
6727 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6729 args = TREE_VALUE (a);
6731 /* Walk the argument list. If we encounter an argument number we
6732 should check for non-null, do it. If the attribute has no args,
6733 then every pointer argument is checked (in which case the check
6734 for pointer type is done in check_nonnull_arg). */
6735 for (i = 0; i < nargs; i++)
6737 if (!args || nonnull_check_p (args, i + 1))
6738 check_function_arguments_recurse (check_nonnull_arg, NULL,
6746 /* Check that the Nth argument of a function call (counting backwards
6747 from the end) is a (pointer)0. The NARGS arguments are passed in the
6751 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
6753 tree attr = lookup_attribute ("sentinel", attrs);
6761 /* Skip over the named arguments. */
6762 while (typelist && len < nargs)
6764 typelist = TREE_CHAIN (typelist);
6768 if (TREE_VALUE (attr))
6770 tree p = TREE_VALUE (TREE_VALUE (attr));
6771 pos = TREE_INT_CST_LOW (p);
6774 /* The sentinel must be one of the varargs, i.e.
6775 in position >= the number of fixed arguments. */
6776 if ((nargs - 1 - pos) < len)
6778 warning (OPT_Wformat,
6779 "not enough variable arguments to fit a sentinel");
6783 /* Validate the sentinel. */
6784 sentinel = argarray[nargs - 1 - pos];
6785 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
6786 || !integer_zerop (sentinel))
6787 /* Although __null (in C++) is only an integer we allow it
6788 nevertheless, as we are guaranteed that it's exactly
6789 as wide as a pointer, and we don't want to force
6790 users to cast the NULL they have written there.
6791 We warn with -Wstrict-null-sentinel, though. */
6792 && (warn_strict_null_sentinel || null_node != sentinel))
6793 warning (OPT_Wformat, "missing sentinel in function call");
6797 /* Helper for check_function_nonnull; given a list of operands which
6798 must be non-null in ARGS, determine if operand PARAM_NUM should be
6802 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6804 unsigned HOST_WIDE_INT arg_num = 0;
6806 for (; args; args = TREE_CHAIN (args))
6808 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6812 if (arg_num == param_num)
6818 /* Check that the function argument PARAM (which is operand number
6819 PARAM_NUM) is non-null. This is called by check_function_nonnull
6820 via check_function_arguments_recurse. */
6823 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6824 unsigned HOST_WIDE_INT param_num)
6826 /* Just skip checking the argument if it's not a pointer. This can
6827 happen if the "nonnull" attribute was given without an operand
6828 list (which means to check every pointer argument). */
6830 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6833 if (integer_zerop (param))
6834 warning (OPT_Wnonnull, "null argument where non-null required "
6835 "(argument %lu)", (unsigned long) param_num);
6838 /* Helper for nonnull attribute handling; fetch the operand number
6839 from the attribute argument list. */
6842 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6844 /* Verify the arg number is a constant. */
6845 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6846 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6849 *valp = TREE_INT_CST_LOW (arg_num_expr);
6853 /* Handle a "nothrow" attribute; arguments as in
6854 struct attribute_spec.handler. */
6857 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6858 int ARG_UNUSED (flags), bool *no_add_attrs)
6860 if (TREE_CODE (*node) == FUNCTION_DECL)
6861 TREE_NOTHROW (*node) = 1;
6862 /* ??? TODO: Support types. */
6865 warning (OPT_Wattributes, "%qE attribute ignored", name);
6866 *no_add_attrs = true;
6872 /* Handle a "cleanup" attribute; arguments as in
6873 struct attribute_spec.handler. */
6876 handle_cleanup_attribute (tree *node, tree name, tree args,
6877 int ARG_UNUSED (flags), bool *no_add_attrs)
6880 tree cleanup_id, cleanup_decl;
6882 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6883 for global destructors in C++. This requires infrastructure that
6884 we don't have generically at the moment. It's also not a feature
6885 we'd be missing too much, since we do have attribute constructor. */
6886 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6888 warning (OPT_Wattributes, "%qE attribute ignored", name);
6889 *no_add_attrs = true;
6893 /* Verify that the argument is a function in scope. */
6894 /* ??? We could support pointers to functions here as well, if
6895 that was considered desirable. */
6896 cleanup_id = TREE_VALUE (args);
6897 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6899 error ("cleanup argument not an identifier");
6900 *no_add_attrs = true;
6903 cleanup_decl = lookup_name (cleanup_id);
6904 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6906 error ("cleanup argument not a function");
6907 *no_add_attrs = true;
6911 /* That the function has proper type is checked with the
6912 eventual call to build_function_call. */
6917 /* Handle a "warn_unused_result" attribute. No special handling. */
6920 handle_warn_unused_result_attribute (tree *node, tree name,
6921 tree ARG_UNUSED (args),
6922 int ARG_UNUSED (flags), bool *no_add_attrs)
6924 /* Ignore the attribute for functions not returning any value. */
6925 if (VOID_TYPE_P (TREE_TYPE (*node)))
6927 warning (OPT_Wattributes, "%qE attribute ignored", name);
6928 *no_add_attrs = true;
6934 /* Handle a "sentinel" attribute. */
6937 handle_sentinel_attribute (tree *node, tree name, tree args,
6938 int ARG_UNUSED (flags), bool *no_add_attrs)
6940 tree params = TYPE_ARG_TYPES (*node);
6944 warning (OPT_Wattributes,
6945 "%qE attribute requires prototypes with named arguments", name);
6946 *no_add_attrs = true;
6950 while (TREE_CHAIN (params))
6951 params = TREE_CHAIN (params);
6953 if (VOID_TYPE_P (TREE_VALUE (params)))
6955 warning (OPT_Wattributes,
6956 "%qE attribute only applies to variadic functions", name);
6957 *no_add_attrs = true;
6963 tree position = TREE_VALUE (args);
6965 if (TREE_CODE (position) != INTEGER_CST)
6967 warning (OPT_Wattributes,
6968 "requested position is not an integer constant");
6969 *no_add_attrs = true;
6973 if (tree_int_cst_lt (position, integer_zero_node))
6975 warning (OPT_Wattributes,
6976 "requested position is less than zero");
6977 *no_add_attrs = true;
6985 /* Handle a "type_generic" attribute. */
6988 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6989 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6990 bool * ARG_UNUSED (no_add_attrs))
6994 /* Ensure we have a function type. */
6995 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
6997 params = TYPE_ARG_TYPES (*node);
6998 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
6999 params = TREE_CHAIN (params);
7001 /* Ensure we have a variadic function. */
7002 gcc_assert (!params);
7007 /* Handle a "target" attribute. */
7010 handle_target_attribute (tree *node, tree name, tree args, int flags,
7013 /* Ensure we have a function type. */
7014 if (TREE_CODE (*node) != FUNCTION_DECL)
7016 warning (OPT_Wattributes, "%qE attribute ignored", name);
7017 *no_add_attrs = true;
7019 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7021 *no_add_attrs = true;
7026 /* Arguments being collected for optimization. */
7027 typedef const char *const_char_p; /* For DEF_VEC_P. */
7028 DEF_VEC_P(const_char_p);
7029 DEF_VEC_ALLOC_P(const_char_p, gc);
7030 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7033 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7034 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7035 false for #pragma GCC optimize. */
7038 parse_optimize_options (tree args, bool attr_p)
7043 int saved_flag_strict_aliasing;
7044 const char **opt_argv;
7047 /* Build up argv vector. Just in case the string is stored away, use garbage
7048 collected strings. */
7049 VEC_truncate (const_char_p, optimize_args, 0);
7050 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7052 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7054 tree value = TREE_VALUE (ap);
7056 if (TREE_CODE (value) == INTEGER_CST)
7059 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7060 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7063 else if (TREE_CODE (value) == STRING_CST)
7065 /* Split string into multiple substrings. */
7066 size_t len = TREE_STRING_LENGTH (value);
7067 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7068 char *end = p + len;
7072 while (next_p != NULL)
7078 comma = strchr (p, ',');
7091 r = q = (char *) ggc_alloc (len2 + 3);
7093 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7095 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7099 warning (OPT_Wattributes,
7100 "Bad option %s to optimize attribute.", p);
7102 warning (OPT_Wpragmas,
7103 "Bad option %s to pragma attribute", p);
7111 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7112 itself is -Os, and any other switch begins with a -f. */
7113 if ((*p >= '0' && *p <= '9')
7114 || (p[0] == 's' && p[1] == '\0'))
7120 memcpy (r, p, len2);
7122 VEC_safe_push (const_char_p, gc, optimize_args, q);
7128 opt_argc = VEC_length (const_char_p, optimize_args);
7129 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7131 for (i = 1; i < opt_argc; i++)
7132 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7134 saved_flag_strict_aliasing = flag_strict_aliasing;
7136 /* Now parse the options. */
7137 decode_options (opt_argc, opt_argv);
7139 /* Don't allow changing -fstrict-aliasing. */
7140 flag_strict_aliasing = saved_flag_strict_aliasing;
7142 VEC_truncate (const_char_p, optimize_args, 0);
7146 /* For handling "optimize" attribute. arguments as in
7147 struct attribute_spec.handler. */
7150 handle_optimize_attribute (tree *node, tree name, tree args,
7151 int ARG_UNUSED (flags), bool *no_add_attrs)
7153 /* Ensure we have a function type. */
7154 if (TREE_CODE (*node) != FUNCTION_DECL)
7156 warning (OPT_Wattributes, "%qE attribute ignored", name);
7157 *no_add_attrs = true;
7161 struct cl_optimization cur_opts;
7162 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7164 /* Save current options. */
7165 cl_optimization_save (&cur_opts);
7167 /* If we previously had some optimization options, use them as the
7170 cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7172 /* Parse options, and update the vector. */
7173 parse_optimize_options (args, true);
7174 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7175 = build_optimization_node ();
7177 /* Restore current options. */
7178 cl_optimization_restore (&cur_opts);
7184 /* Check for valid arguments being passed to a function.
7185 ATTRS is a list of attributes. There are NARGS arguments in the array
7186 ARGARRAY. TYPELIST is the list of argument types for the function.
7189 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7191 /* Check for null being passed in a pointer argument that must be
7192 non-null. We also need to do this if format checking is enabled. */
7195 check_function_nonnull (attrs, nargs, argarray);
7197 /* Check for errors in format strings. */
7199 if (warn_format || warn_missing_format_attribute)
7200 check_function_format (attrs, nargs, argarray);
7203 check_function_sentinel (attrs, nargs, argarray, typelist);
7206 /* Generic argument checking recursion routine. PARAM is the argument to
7207 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7208 once the argument is resolved. CTX is context for the callback. */
7210 check_function_arguments_recurse (void (*callback)
7211 (void *, tree, unsigned HOST_WIDE_INT),
7212 void *ctx, tree param,
7213 unsigned HOST_WIDE_INT param_num)
7215 if (CONVERT_EXPR_P (param)
7216 && (TYPE_PRECISION (TREE_TYPE (param))
7217 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7219 /* Strip coercion. */
7220 check_function_arguments_recurse (callback, ctx,
7221 TREE_OPERAND (param, 0), param_num);
7225 if (TREE_CODE (param) == CALL_EXPR)
7227 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7229 bool found_format_arg = false;
7231 /* See if this is a call to a known internationalization function
7232 that modifies a format arg. Such a function may have multiple
7233 format_arg attributes (for example, ngettext). */
7235 for (attrs = TYPE_ATTRIBUTES (type);
7237 attrs = TREE_CHAIN (attrs))
7238 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7241 tree format_num_expr;
7244 call_expr_arg_iterator iter;
7246 /* Extract the argument number, which was previously checked
7248 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7250 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7251 && !TREE_INT_CST_HIGH (format_num_expr));
7253 format_num = TREE_INT_CST_LOW (format_num_expr);
7255 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7257 inner_arg = next_call_expr_arg (&iter), i++)
7258 if (i == format_num)
7260 check_function_arguments_recurse (callback, ctx,
7261 inner_arg, param_num);
7262 found_format_arg = true;
7267 /* If we found a format_arg attribute and did a recursive check,
7268 we are done with checking this argument. Otherwise, we continue
7269 and this will be considered a non-literal. */
7270 if (found_format_arg)
7274 if (TREE_CODE (param) == COND_EXPR)
7276 /* Check both halves of the conditional expression. */
7277 check_function_arguments_recurse (callback, ctx,
7278 TREE_OPERAND (param, 1), param_num);
7279 check_function_arguments_recurse (callback, ctx,
7280 TREE_OPERAND (param, 2), param_num);
7284 (*callback) (ctx, param, param_num);
7287 /* Checks the number of arguments NARGS against the required number
7288 REQUIRED and issues an error if there is a mismatch. Returns true
7289 if the number of arguments is correct, otherwise false. */
7292 validate_nargs (tree fndecl, int nargs, int required)
7294 if (nargs < required)
7296 error ("not enough arguments to function %qE", fndecl);
7299 else if (nargs > required)
7301 error ("too many arguments to function %qE", fndecl);
7307 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7308 Returns false if there was an error, otherwise true. */
7311 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
7313 if (!DECL_BUILT_IN (fndecl)
7314 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
7317 switch (DECL_FUNCTION_CODE (fndecl))
7319 case BUILT_IN_CONSTANT_P:
7320 return validate_nargs (fndecl, nargs, 1);
7322 case BUILT_IN_ISFINITE:
7323 case BUILT_IN_ISINF:
7324 case BUILT_IN_ISINF_SIGN:
7325 case BUILT_IN_ISNAN:
7326 case BUILT_IN_ISNORMAL:
7327 if (validate_nargs (fndecl, nargs, 1))
7329 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
7331 error ("non-floating-point argument in call to "
7332 "function %qE", fndecl);
7339 case BUILT_IN_ISGREATER:
7340 case BUILT_IN_ISGREATEREQUAL:
7341 case BUILT_IN_ISLESS:
7342 case BUILT_IN_ISLESSEQUAL:
7343 case BUILT_IN_ISLESSGREATER:
7344 case BUILT_IN_ISUNORDERED:
7345 if (validate_nargs (fndecl, nargs, 2))
7347 enum tree_code code0, code1;
7348 code0 = TREE_CODE (TREE_TYPE (args[0]));
7349 code1 = TREE_CODE (TREE_TYPE (args[1]));
7350 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
7351 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7352 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
7354 error ("non-floating-point arguments in call to "
7355 "function %qE", fndecl);
7362 case BUILT_IN_FPCLASSIFY:
7363 if (validate_nargs (fndecl, nargs, 6))
7368 if (TREE_CODE (args[i]) != INTEGER_CST)
7370 error ("non-const integer argument %u in call to function %qE",
7375 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
7377 error ("non-floating-point argument in call to function %qE",
7390 /* Function to help qsort sort FIELD_DECLs by name order. */
7393 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)
7405 if (DECL_NAME (*x) < DECL_NAME (*y))
7411 gt_pointer_operator new_value;
7415 /* This routine compares two fields like field_decl_cmp but using the
7416 pointer operator in resort_data. */
7419 resort_field_decl_cmp (const void *x_p, const void *y_p)
7421 const tree *const x = (const tree *const) x_p;
7422 const tree *const y = (const tree *const) y_p;
7424 if (DECL_NAME (*x) == DECL_NAME (*y))
7425 /* A nontype is "greater" than a type. */
7426 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7427 if (DECL_NAME (*x) == NULL_TREE)
7429 if (DECL_NAME (*y) == NULL_TREE)
7432 tree d1 = DECL_NAME (*x);
7433 tree d2 = DECL_NAME (*y);
7434 resort_data.new_value (&d1, resort_data.cookie);
7435 resort_data.new_value (&d2, resort_data.cookie);
7442 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
7445 resort_sorted_fields (void *obj,
7446 void * ARG_UNUSED (orig_obj),
7447 gt_pointer_operator new_value,
7450 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
7451 resort_data.new_value = new_value;
7452 resort_data.cookie = cookie;
7453 qsort (&sf->elts[0], sf->len, sizeof (tree),
7454 resort_field_decl_cmp);
7457 /* Subroutine of c_parse_error.
7458 Return the result of concatenating LHS and RHS. RHS is really
7459 a string literal, its first character is indicated by RHS_START and
7460 RHS_SIZE is its length (including the terminating NUL character).
7462 The caller is responsible for deleting the returned pointer. */
7465 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
7467 const int lhs_size = strlen (lhs);
7468 char *result = XNEWVEC (char, lhs_size + rhs_size);
7469 strncpy (result, lhs, lhs_size);
7470 strncpy (result + lhs_size, rhs_start, rhs_size);
7474 /* Issue the error given by GMSGID, indicating that it occurred before
7475 TOKEN, which had the associated VALUE. */
7478 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
7480 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
7482 char *message = NULL;
7484 if (token == CPP_EOF)
7485 message = catenate_messages (gmsgid, " at end of input");
7486 else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
7487 || token == CPP_CHAR32)
7489 unsigned int val = TREE_INT_CST_LOW (value);
7508 if (val <= UCHAR_MAX && ISGRAPH (val))
7509 message = catenate_messages (gmsgid, " before %s'%c'");
7511 message = catenate_messages (gmsgid, " before %s'\\x%x'");
7513 error (message, prefix, val);
7517 else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
7518 || token == CPP_STRING32)
7519 message = catenate_messages (gmsgid, " before string constant");
7520 else if (token == CPP_NUMBER)
7521 message = catenate_messages (gmsgid, " before numeric constant");
7522 else if (token == CPP_NAME)
7524 message = catenate_messages (gmsgid, " before %qE");
7525 error (message, value);
7529 else if (token == CPP_PRAGMA)
7530 message = catenate_messages (gmsgid, " before %<#pragma%>");
7531 else if (token == CPP_PRAGMA_EOL)
7532 message = catenate_messages (gmsgid, " before end of line");
7533 else if (token < N_TTYPES)
7535 message = catenate_messages (gmsgid, " before %qs token");
7536 error (message, cpp_type2name (token));
7548 #undef catenate_messages
7551 /* Walk a gimplified function and warn for functions whose return value is
7552 ignored and attribute((warn_unused_result)) is set. This is done before
7553 inlining, so we don't have to worry about that. */
7556 c_warn_unused_result (gimple_seq seq)
7559 gimple_stmt_iterator i;
7561 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
7563 gimple g = gsi_stmt (i);
7565 switch (gimple_code (g))
7568 c_warn_unused_result (gimple_bind_body (g));
7571 c_warn_unused_result (gimple_try_eval (g));
7572 c_warn_unused_result (gimple_try_cleanup (g));
7575 c_warn_unused_result (gimple_catch_handler (g));
7577 case GIMPLE_EH_FILTER:
7578 c_warn_unused_result (gimple_eh_filter_failure (g));
7582 if (gimple_call_lhs (g))
7585 /* This is a naked call, as opposed to a GIMPLE_CALL with an
7586 LHS. All calls whose value is ignored should be
7587 represented like this. Look for the attribute. */
7588 fdecl = gimple_call_fndecl (g);
7589 ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
7591 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
7593 location_t loc = gimple_location (g);
7596 warning (0, "%Hignoring return value of %qD, "
7597 "declared with attribute warn_unused_result",
7600 warning (0, "%Hignoring return value of function "
7601 "declared with attribute warn_unused_result",
7607 /* Not a container, not a call, or a call whose value is used. */
7613 /* Convert a character from the host to the target execution character
7614 set. cpplib handles this, mostly. */
7617 c_common_to_target_charset (HOST_WIDE_INT c)
7619 /* Character constants in GCC proper are sign-extended under -fsigned-char,
7620 zero-extended under -fno-signed-char. cpplib insists that characters
7621 and character constants are always unsigned. Hence we must convert
7623 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
7625 uc = cpp_host_to_exec_charset (parse_in, uc);
7627 if (flag_signed_char)
7628 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
7629 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
7634 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
7635 component references, with STOP_REF, or alternatively an INDIRECT_REF of
7636 NULL, at the bottom; much like the traditional rendering of offsetof as a
7637 macro. Returns the folded and properly cast result. */
7640 fold_offsetof_1 (tree expr, tree stop_ref)
7642 enum tree_code code = PLUS_EXPR;
7645 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
7646 return size_zero_node;
7648 switch (TREE_CODE (expr))
7654 error ("cannot apply %<offsetof%> to static data member %qD", expr);
7655 return error_mark_node;
7659 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7660 return error_mark_node;
7663 gcc_assert (integer_zerop (expr));
7664 return size_zero_node;
7668 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7669 gcc_assert (base == error_mark_node || base == size_zero_node);
7673 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7674 if (base == error_mark_node)
7677 t = TREE_OPERAND (expr, 1);
7678 if (DECL_C_BIT_FIELD (t))
7680 error ("attempt to take address of bit-field structure "
7682 return error_mark_node;
7684 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
7685 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
7690 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7691 if (base == error_mark_node)
7694 t = TREE_OPERAND (expr, 1);
7695 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
7698 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
7700 t = convert (sizetype, t);
7701 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
7705 /* Handle static members of volatile structs. */
7706 t = TREE_OPERAND (expr, 1);
7707 gcc_assert (TREE_CODE (t) == VAR_DECL);
7708 return fold_offsetof_1 (t, stop_ref);
7714 return size_binop (code, base, off);
7718 fold_offsetof (tree expr, tree stop_ref)
7720 /* Convert back from the internal sizetype to size_t. */
7721 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
7724 /* Print an error message for an invalid lvalue. USE says
7725 how the lvalue is being used and so selects the error message. */
7728 lvalue_error (enum lvalue_use use)
7733 error ("lvalue required as left operand of assignment");
7736 error ("lvalue required as increment operand");
7739 error ("lvalue required as decrement operand");
7742 error ("lvalue required as unary %<&%> operand");
7745 error ("lvalue required in asm statement");
7752 /* *PTYPE is an incomplete array. Complete it with a domain based on
7753 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7754 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7755 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
7758 complete_array_type (tree *ptype, tree initial_value, bool do_default)
7760 tree maxindex, type, main_type, elt, unqual_elt;
7761 int failure = 0, quals;
7762 hashval_t hashcode = 0;
7764 maxindex = size_zero_node;
7767 if (TREE_CODE (initial_value) == STRING_CST)
7770 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7771 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
7773 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7775 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
7777 if (VEC_empty (constructor_elt, v))
7781 maxindex = integer_minus_one_node;
7786 unsigned HOST_WIDE_INT cnt;
7787 constructor_elt *ce;
7788 bool fold_p = false;
7790 if (VEC_index (constructor_elt, v, 0)->index)
7791 maxindex = fold_convert (sizetype,
7792 VEC_index (constructor_elt,
7794 curindex = maxindex;
7797 VEC_iterate (constructor_elt, v, cnt, ce);
7800 bool curfold_p = false;
7802 curindex = ce->index, curfold_p = true;
7806 curindex = fold_convert (sizetype, curindex);
7807 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
7809 if (tree_int_cst_lt (maxindex, curindex))
7810 maxindex = curindex, fold_p = curfold_p;
7813 maxindex = fold_convert (sizetype, maxindex);
7818 /* Make an error message unless that happened already. */
7819 if (initial_value != error_mark_node)
7831 elt = TREE_TYPE (type);
7832 quals = TYPE_QUALS (strip_array_types (elt));
7836 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
7838 /* Using build_distinct_type_copy and modifying things afterward instead
7839 of using build_array_type to create a new type preserves all of the
7840 TYPE_LANG_FLAG_? bits that the front end may have set. */
7841 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7842 TREE_TYPE (main_type) = unqual_elt;
7843 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
7844 layout_type (main_type);
7846 /* Make sure we have the canonical MAIN_TYPE. */
7847 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
7848 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
7850 main_type = type_hash_canon (hashcode, main_type);
7852 /* Fix the canonical type. */
7853 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
7854 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
7855 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
7856 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
7857 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
7858 != TYPE_DOMAIN (main_type)))
7859 TYPE_CANONICAL (main_type)
7860 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
7861 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
7863 TYPE_CANONICAL (main_type) = main_type;
7868 type = c_build_qualified_type (main_type, quals);
7870 if (COMPLETE_TYPE_P (type)
7871 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7872 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7874 error ("size of array is too large");
7875 /* If we proceed with the array type as it is, we'll eventually
7876 crash in tree_low_cst(). */
7877 type = error_mark_node;
7885 /* Used to help initialize the builtin-types.def table. When a type of
7886 the correct size doesn't exist, use error_mark_node instead of NULL.
7887 The later results in segfaults even when a decl using the type doesn't
7891 builtin_type_for_size (int size, bool unsignedp)
7893 tree type = lang_hooks.types.type_for_size (size, unsignedp);
7894 return type ? type : error_mark_node;
7897 /* A helper function for resolve_overloaded_builtin in resolving the
7898 overloaded __sync_ builtins. Returns a positive power of 2 if the
7899 first operand of PARAMS is a pointer to a supported data type.
7900 Returns 0 if an error is encountered. */
7903 sync_resolve_size (tree function, tree params)
7910 error ("too few arguments to function %qE", function);
7914 type = TREE_TYPE (TREE_VALUE (params));
7915 if (TREE_CODE (type) != POINTER_TYPE)
7918 type = TREE_TYPE (type);
7919 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
7922 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7923 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
7927 error ("incompatible type for argument %d of %qE", 1, function);
7931 /* A helper function for resolve_overloaded_builtin. Adds casts to
7932 PARAMS to make arguments match up with those of FUNCTION. Drops
7933 the variadic arguments at the end. Returns false if some error
7934 was encountered; true on success. */
7937 sync_resolve_params (tree orig_function, tree function, tree params)
7939 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
7943 /* We've declared the implementation functions to use "volatile void *"
7944 as the pointer parameter, so we shouldn't get any complaints from the
7945 call to check_function_arguments what ever type the user used. */
7946 arg_types = TREE_CHAIN (arg_types);
7947 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7950 /* For the rest of the values, we need to cast these to FTYPE, so that we
7951 don't get warnings for passing pointer types, etc. */
7952 while (arg_types != void_list_node)
7956 params = TREE_CHAIN (params);
7959 error ("too few arguments to function %qE", orig_function);
7963 /* ??? Ideally for the first conversion we'd use convert_for_assignment
7964 so that we get warnings for anything that doesn't match the pointer
7965 type. This isn't portable across the C and C++ front ends atm. */
7966 val = TREE_VALUE (params);
7967 val = convert (ptype, val);
7968 val = convert (TREE_VALUE (arg_types), val);
7969 TREE_VALUE (params) = val;
7971 arg_types = TREE_CHAIN (arg_types);
7975 /* The definition of these primitives is variadic, with the remaining
7976 being "an optional list of variables protected by the memory barrier".
7977 No clue what that's supposed to mean, precisely, but we consider all
7978 call-clobbered variables to be protected so we're safe. */
7979 TREE_CHAIN (params) = NULL;
7984 /* A helper function for resolve_overloaded_builtin. Adds a cast to
7985 RESULT to make it match the type of the first pointer argument in
7989 sync_resolve_return (tree params, tree result)
7991 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7992 ptype = TYPE_MAIN_VARIANT (ptype);
7993 return convert (ptype, result);
7996 /* Some builtin functions are placeholders for other expressions. This
7997 function should be called immediately after parsing the call expression
7998 before surrounding code has committed to the type of the expression.
8000 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8001 PARAMS is the argument list for the call. The return value is non-null
8002 when expansion is complete, and null if normal processing should
8006 resolve_overloaded_builtin (tree function, tree params)
8008 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8009 switch (DECL_BUILT_IN_CLASS (function))
8011 case BUILT_IN_NORMAL:
8014 if (targetm.resolve_overloaded_builtin)
8015 return targetm.resolve_overloaded_builtin (function, params);
8022 /* Handle BUILT_IN_NORMAL here. */
8025 case BUILT_IN_FETCH_AND_ADD_N:
8026 case BUILT_IN_FETCH_AND_SUB_N:
8027 case BUILT_IN_FETCH_AND_OR_N:
8028 case BUILT_IN_FETCH_AND_AND_N:
8029 case BUILT_IN_FETCH_AND_XOR_N:
8030 case BUILT_IN_FETCH_AND_NAND_N:
8031 case BUILT_IN_ADD_AND_FETCH_N:
8032 case BUILT_IN_SUB_AND_FETCH_N:
8033 case BUILT_IN_OR_AND_FETCH_N:
8034 case BUILT_IN_AND_AND_FETCH_N:
8035 case BUILT_IN_XOR_AND_FETCH_N:
8036 case BUILT_IN_NAND_AND_FETCH_N:
8037 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8038 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8039 case BUILT_IN_LOCK_TEST_AND_SET_N:
8040 case BUILT_IN_LOCK_RELEASE_N:
8042 int n = sync_resolve_size (function, params);
8043 tree new_function, result;
8046 return error_mark_node;
8048 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8049 if (!sync_resolve_params (function, new_function, params))
8050 return error_mark_node;
8052 result = build_function_call (new_function, params);
8053 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8054 && orig_code != BUILT_IN_LOCK_RELEASE_N)
8055 result = sync_resolve_return (params, result);
8065 /* Ignoring their sign, return true if two scalar types are the same. */
8067 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8069 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8071 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8072 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8073 || c2 == FIXED_POINT_TYPE));
8075 /* Equality works here because c_common_signed_type uses
8076 TYPE_MAIN_VARIANT. */
8077 return c_common_signed_type (t1)
8078 == c_common_signed_type (t2);
8081 /* Check for missing format attributes on function pointers. LTYPE is
8082 the new type or left-hand side type. RTYPE is the old type or
8083 right-hand side type. Returns TRUE if LTYPE is missing the desired
8087 check_missing_format_attribute (tree ltype, tree rtype)
8089 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8092 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8093 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8098 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8099 if (is_attribute_p ("format", TREE_PURPOSE (la)))
8107 /* Subscripting with type char is likely to lose on a machine where
8108 chars are signed. So warn on any machine, but optionally. Don't
8109 warn for unsigned char since that type is safe. Don't warn for
8110 signed char because anyone who uses that must have done so
8111 deliberately. Furthermore, we reduce the false positive load by
8112 warning only for non-constant value of type char. */
8115 warn_array_subscript_with_type_char (tree index)
8117 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8118 && TREE_CODE (index) != INTEGER_CST)
8119 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8122 /* Implement -Wparentheses for the unexpected C precedence rules, to
8123 cover cases like x + y << z which readers are likely to
8124 misinterpret. We have seen an expression in which CODE is a binary
8125 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8126 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8127 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8128 expression was not formed using a binary or unary operator, or it
8129 was enclosed in parentheses. */
8132 warn_about_parentheses (enum tree_code code,
8133 enum tree_code code_left, tree arg_left,
8134 enum tree_code code_right, tree arg_right)
8136 if (!warn_parentheses)
8139 /* This macro tests that the expression ARG with original tree code
8140 CODE appears to be a boolean expression. or the result of folding a
8141 boolean expression. */
8142 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8143 (truth_value_p (TREE_CODE (ARG)) \
8144 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8145 /* Folding may create 0 or 1 integers from other expressions. */ \
8146 || ((CODE) != INTEGER_CST \
8147 && (integer_onep (ARG) || integer_zerop (ARG))))
8152 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8153 warning (OPT_Wparentheses,
8154 "suggest parentheses around %<+%> inside %<<<%>");
8155 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8156 warning (OPT_Wparentheses,
8157 "suggest parentheses around %<-%> inside %<<<%>");
8161 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8162 warning (OPT_Wparentheses,
8163 "suggest parentheses around %<+%> inside %<>>%>");
8164 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8165 warning (OPT_Wparentheses,
8166 "suggest parentheses around %<-%> inside %<>>%>");
8169 case TRUTH_ORIF_EXPR:
8170 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8171 warning (OPT_Wparentheses,
8172 "suggest parentheses around %<&&%> within %<||%>");
8176 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8177 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8178 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8179 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8180 warning (OPT_Wparentheses,
8181 "suggest parentheses around arithmetic in operand of %<|%>");
8182 /* Check cases like x|y==z */
8183 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8184 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8185 warning (OPT_Wparentheses,
8186 "suggest parentheses around comparison in operand of %<|%>");
8187 /* Check cases like !x | y */
8188 else if (code_left == TRUTH_NOT_EXPR
8189 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8190 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8191 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8195 if (code_left == BIT_AND_EXPR
8196 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8197 || code_right == BIT_AND_EXPR
8198 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8199 warning (OPT_Wparentheses,
8200 "suggest parentheses around arithmetic in operand of %<^%>");
8201 /* Check cases like x^y==z */
8202 else 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 %<^%>");
8209 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8210 warning (OPT_Wparentheses,
8211 "suggest parentheses around %<+%> in operand of %<&%>");
8212 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8213 warning (OPT_Wparentheses,
8214 "suggest parentheses around %<-%> in operand of %<&%>");
8215 /* Check cases like x&y==z */
8216 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8217 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8218 warning (OPT_Wparentheses,
8219 "suggest parentheses around comparison in operand of %<&%>");
8220 /* Check cases like !x & y */
8221 else if (code_left == TRUTH_NOT_EXPR
8222 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8223 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8224 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8228 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8229 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8230 warning (OPT_Wparentheses,
8231 "suggest parentheses around comparison in operand of %<==%>");
8234 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8235 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8236 warning (OPT_Wparentheses,
8237 "suggest parentheses around comparison in operand of %<!=%>");
8241 if (TREE_CODE_CLASS (code) == tcc_comparison
8242 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
8243 && code_left != NE_EXPR && code_left != EQ_EXPR
8244 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
8245 || (TREE_CODE_CLASS (code_right) == tcc_comparison
8246 && code_right != NE_EXPR && code_right != EQ_EXPR
8247 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
8248 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
8249 "have their mathematical meaning");
8252 #undef NOT_A_BOOLEAN_EXPR_P
8255 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8258 warn_for_unused_label (tree label)
8260 if (!TREE_USED (label))
8262 if (DECL_INITIAL (label))
8263 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
8265 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
8269 #ifndef TARGET_HAS_TARGETCM
8270 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
8273 /* Warn for division by zero according to the value of DIVISOR. LOC
8274 is the location of the division operator. */
8277 warn_for_div_by_zero (location_t loc, tree divisor)
8279 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8280 about division by zero. Do not issue a warning if DIVISOR has a
8281 floating-point type, since we consider 0.0/0.0 a valid way of
8282 generating a NaN. */
8283 if (skip_evaluation == 0
8284 && (integer_zerop (divisor) || fixed_zerop (divisor)))
8285 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
8288 /* Subroutine of build_binary_op. Give warnings for comparisons
8289 between signed and unsigned quantities that may fail. Do the
8290 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8291 so that casts will be considered, but default promotions won't
8294 LOCATION is the location of the comparison operator.
8296 The arguments of this function map directly to local variables
8297 of build_binary_op. */
8300 warn_for_sign_compare (location_t location,
8301 tree orig_op0, tree orig_op1,
8303 tree result_type, enum tree_code resultcode)
8305 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
8306 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
8307 int unsignedp0, unsignedp1;
8309 /* In C++, check for comparison of different enum types. */
8311 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
8312 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
8313 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
8314 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
8316 warning_at (location,
8317 OPT_Wsign_compare, "comparison between types %qT and %qT",
8318 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
8321 /* Do not warn if the comparison is being done in a signed type,
8322 since the signed type will only be chosen if it can represent
8323 all the values of the unsigned type. */
8324 if (!TYPE_UNSIGNED (result_type))
8326 /* Do not warn if both operands are unsigned. */
8327 else if (op0_signed == op1_signed)
8331 tree sop, uop, base_type;
8335 sop = orig_op0, uop = orig_op1;
8337 sop = orig_op1, uop = orig_op0;
8339 STRIP_TYPE_NOPS (sop);
8340 STRIP_TYPE_NOPS (uop);
8341 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
8342 ? TREE_TYPE (result_type) : result_type);
8344 /* Do not warn if the signed quantity is an unsuffixed integer
8345 literal (or some static constant expression involving such
8346 literals or a conditional expression involving such literals)
8347 and it is non-negative. */
8348 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
8350 /* Do not warn if the comparison is an equality operation, the
8351 unsigned quantity is an integral constant, and it would fit
8352 in the result if the result were signed. */
8353 else if (TREE_CODE (uop) == INTEGER_CST
8354 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
8355 && int_fits_type_p (uop, c_common_signed_type (base_type)))
8357 /* In C, do not warn if the unsigned quantity is an enumeration
8358 constant and its maximum value would fit in the result if the
8359 result were signed. */
8360 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
8361 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
8362 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
8363 c_common_signed_type (base_type)))
8366 warning_at (location,
8368 "comparison between signed and unsigned integer expressions");
8371 /* Warn if two unsigned values are being compared in a size larger
8372 than their original size, and one (and only one) is the result of
8373 a `~' operator. This comparison will always fail.
8375 Also warn if one operand is a constant, and the constant does not
8376 have all bits set that are set in the ~ operand when it is
8379 op0 = get_narrower (op0, &unsignedp0);
8380 op1 = get_narrower (op1, &unsignedp1);
8382 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
8383 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
8385 if (TREE_CODE (op0) == BIT_NOT_EXPR)
8386 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
8387 if (TREE_CODE (op1) == BIT_NOT_EXPR)
8388 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
8390 if (host_integerp (op0, 0) || host_integerp (op1, 0))
8393 HOST_WIDE_INT constant, mask;
8397 if (host_integerp (op0, 0))
8400 unsignedp = unsignedp1;
8401 constant = tree_low_cst (op0, 0);
8406 unsignedp = unsignedp0;
8407 constant = tree_low_cst (op1, 0);
8410 bits = TYPE_PRECISION (TREE_TYPE (primop));
8411 if (bits < TYPE_PRECISION (result_type)
8412 && bits < HOST_BITS_PER_LONG && unsignedp)
8414 mask = (~ (HOST_WIDE_INT) 0) << bits;
8415 if ((mask & constant) != mask)
8418 warning (OPT_Wsign_compare,
8419 "promoted ~unsigned is always non-zero");
8421 warning_at (location, OPT_Wsign_compare,
8422 "comparison of promoted ~unsigned with constant");
8426 else if (unsignedp0 && unsignedp1
8427 && (TYPE_PRECISION (TREE_TYPE (op0))
8428 < TYPE_PRECISION (result_type))
8429 && (TYPE_PRECISION (TREE_TYPE (op1))
8430 < TYPE_PRECISION (result_type)))
8431 warning_at (location, OPT_Wsign_compare,
8432 "comparison of promoted ~unsigned with unsigned");
8436 #include "gt-c-common.h"