1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
51 #include "target-def.h"
53 #include "fixed-value.h"
56 cpp_reader *parse_in; /* Declared in c-pragma.h. */
58 /* We let tm.h override the types used here, to handle trivial differences
59 such as the choice of unsigned int or long unsigned int for size_t.
60 When machines start needing nontrivial differences in the size type,
61 it would be best to do something here to figure out automatically
62 from other information what type to use. */
65 #define SIZE_TYPE "long unsigned int"
69 #define PID_TYPE "int"
73 #define CHAR16_TYPE "short unsigned int"
77 #define CHAR32_TYPE "unsigned int"
81 #define WCHAR_TYPE "int"
84 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
85 #define MODIFIED_WCHAR_TYPE \
86 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
89 #define PTRDIFF_TYPE "long int"
93 #define WINT_TYPE "unsigned int"
97 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
99 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
105 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
107 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
108 ? "long unsigned int" \
109 : "long long unsigned int"))
112 /* The following symbols are subsumed in the c_global_trees array, and
113 listed here individually for documentation purposes.
115 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
117 tree short_integer_type_node;
118 tree long_integer_type_node;
119 tree long_long_integer_type_node;
121 tree short_unsigned_type_node;
122 tree long_unsigned_type_node;
123 tree long_long_unsigned_type_node;
125 tree truthvalue_type_node;
126 tree truthvalue_false_node;
127 tree truthvalue_true_node;
129 tree ptrdiff_type_node;
131 tree unsigned_char_type_node;
132 tree signed_char_type_node;
133 tree wchar_type_node;
134 tree signed_wchar_type_node;
135 tree unsigned_wchar_type_node;
137 tree char16_type_node;
138 tree char32_type_node;
140 tree float_type_node;
141 tree double_type_node;
142 tree long_double_type_node;
144 tree complex_integer_type_node;
145 tree complex_float_type_node;
146 tree complex_double_type_node;
147 tree complex_long_double_type_node;
149 tree dfloat32_type_node;
150 tree dfloat64_type_node;
151 tree_dfloat128_type_node;
153 tree intQI_type_node;
154 tree intHI_type_node;
155 tree intSI_type_node;
156 tree intDI_type_node;
157 tree intTI_type_node;
159 tree unsigned_intQI_type_node;
160 tree unsigned_intHI_type_node;
161 tree unsigned_intSI_type_node;
162 tree unsigned_intDI_type_node;
163 tree unsigned_intTI_type_node;
165 tree widest_integer_literal_type_node;
166 tree widest_unsigned_literal_type_node;
168 Nodes for types `void *' and `const void *'.
170 tree ptr_type_node, const_ptr_type_node;
172 Nodes for types `char *' and `const char *'.
174 tree string_type_node, const_string_type_node;
176 Type `char[SOMENUMBER]'.
177 Used when an array of char is needed and the size is irrelevant.
179 tree char_array_type_node;
181 Type `int[SOMENUMBER]' or something like it.
182 Used when an array of int needed and the size is irrelevant.
184 tree int_array_type_node;
186 Type `wchar_t[SOMENUMBER]' or something like it.
187 Used when a wide string literal is created.
189 tree wchar_array_type_node;
191 Type `char16_t[SOMENUMBER]' or something like it.
192 Used when a UTF-16 string literal is created.
194 tree char16_array_type_node;
196 Type `char32_t[SOMENUMBER]' or something like it.
197 Used when a UTF-32 string literal is created.
199 tree char32_array_type_node;
201 Type `int ()' -- used for implicit declaration of functions.
203 tree default_function_type;
205 A VOID_TYPE node, packaged in a TREE_LIST.
209 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
210 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
211 VAR_DECLS, but C++ does.)
213 tree function_name_decl_node;
214 tree pretty_function_name_decl_node;
215 tree c99_function_name_decl_node;
217 Stack of nested function name VAR_DECLs.
219 tree saved_function_name_decls;
223 tree c_global_trees[CTI_MAX];
225 /* Switches common to the C front ends. */
227 /* Nonzero if preprocessing only. */
229 int flag_preprocess_only;
231 /* Nonzero means don't output line number information. */
233 char flag_no_line_commands;
235 /* Nonzero causes -E output not to be done, but directives such as
236 #define that have side effects are still obeyed. */
240 /* Nonzero means dump macros in some fashion. */
242 char flag_dump_macros;
244 /* Nonzero means pass #include lines through to the output. */
246 char flag_dump_includes;
248 /* Nonzero means process PCH files while preprocessing. */
250 bool flag_pch_preprocess;
252 /* The file name to which we should write a precompiled header, or
253 NULL if no header will be written in this compile. */
255 const char *pch_file;
257 /* Nonzero if an ISO standard was selected. It rejects macros in the
261 /* Nonzero if -undef was given. It suppresses target built-in macros
265 /* Nonzero means don't recognize the non-ANSI builtin functions. */
269 /* Nonzero means don't recognize the non-ANSI builtin functions.
272 int flag_no_nonansi_builtin;
274 /* Nonzero means give `double' the same size as `float'. */
276 int flag_short_double;
278 /* Nonzero means give `wchar_t' the same size as `short'. */
280 int flag_short_wchar;
282 /* Nonzero means allow implicit conversions between vectors with
283 differing numbers of subparts and/or differing element types. */
284 int flag_lax_vector_conversions;
286 /* Nonzero means allow Microsoft extensions without warnings or errors. */
287 int flag_ms_extensions;
289 /* Nonzero means don't recognize the keyword `asm'. */
293 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
295 int flag_signed_bitfields = 1;
297 /* Warn about #pragma directives that are not recognized. */
299 int warn_unknown_pragmas; /* Tri state variable. */
301 /* Warn about format/argument anomalies in calls to formatted I/O functions
302 (*printf, *scanf, strftime, strfmon, etc.). */
306 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
307 with GCC this doesn't matter as __null is guaranteed to have the right
310 int warn_strict_null_sentinel;
312 /* Zero means that faster, ...NonNil variants of objc_msgSend...
313 calls will be used in ObjC; passing nil receivers to such calls
314 will most likely result in crashes. */
315 int flag_nil_receivers = 1;
317 /* Nonzero means that code generation will be altered to support
318 "zero-link" execution. This currently affects ObjC only, but may
319 affect other languages in the future. */
320 int flag_zero_link = 0;
322 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
323 unit. It will inform the ObjC runtime that class definition(s) herein
324 contained are to replace one(s) previously loaded. */
325 int flag_replace_objc_classes = 0;
327 /* C/ObjC language option variables. */
330 /* Nonzero means allow type mismatches in conditional expressions;
331 just make their values `void'. */
333 int flag_cond_mismatch;
335 /* Nonzero means enable C89 Amendment 1 features. */
339 /* Nonzero means use the ISO C99 dialect of C. */
343 /* Nonzero means that we have builtin functions, and main is an int. */
348 /* ObjC language option variables. */
351 /* Open and close the file for outputting class declarations, if
354 int flag_gen_declaration;
356 /* Tells the compiler that this is a special run. Do not perform any
357 compiling, instead we are to test some platform dependent features
358 and output a C header file with appropriate definitions. */
360 int print_struct_values;
362 /* Tells the compiler what is the constant string class for ObjC. */
364 const char *constant_string_class_name;
367 /* C++ language option variables. */
370 /* Nonzero means don't recognize any extension keywords. */
372 int flag_no_gnu_keywords;
374 /* Nonzero means do emit exported implementations of functions even if
375 they can be inlined. */
377 int flag_implement_inlines = 1;
379 /* Nonzero means that implicit instantiations will be emitted if needed. */
381 int flag_implicit_templates = 1;
383 /* Nonzero means that implicit instantiations of inline templates will be
384 emitted if needed, even if instantiations of non-inline templates
387 int flag_implicit_inline_templates = 1;
389 /* Nonzero means generate separate instantiation control files and
390 juggle them at link time. */
392 int flag_use_repository;
394 /* Nonzero if we want to issue diagnostics that the standard says are not
397 int flag_optional_diags = 1;
399 /* Nonzero means we should attempt to elide constructors when possible. */
401 int flag_elide_constructors = 1;
403 /* Nonzero means that member functions defined in class scope are
404 inline by default. */
406 int flag_default_inline = 1;
408 /* Controls whether compiler generates 'type descriptor' that give
409 run-time type information. */
413 /* Nonzero if we want to conserve space in the .o files. We do this
414 by putting uninitialized data and runtime initialized data into
415 .common instead of .data at the expense of not flagging multiple
418 int flag_conserve_space;
420 /* Nonzero if we want to obey access control semantics. */
422 int flag_access_control = 1;
424 /* Nonzero if we want to check the return value of new and avoid calling
425 constructors if it is a null pointer. */
429 /* The C++ dialect being used. C++98 is the default. */
431 enum cxx_dialect cxx_dialect = cxx98;
433 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
434 initialization variables.
435 0: Old rules, set by -fno-for-scope.
436 2: New ISO rules, set by -ffor-scope.
437 1: Try to implement new ISO rules, but with backup compatibility
438 (and warnings). This is the default, for now. */
440 int flag_new_for_scope = 1;
442 /* Nonzero if we want to emit defined symbols with common-like linkage as
443 weak symbols where possible, in order to conform to C++ semantics.
444 Otherwise, emit them as local symbols. */
448 /* 0 means we want the preprocessor to not emit line directives for
449 the current working directory. 1 means we want it to do it. -1
450 means we should decide depending on whether debugging information
451 is being emitted or not. */
453 int flag_working_directory = -1;
455 /* Nonzero to use __cxa_atexit, rather than atexit, to register
456 destructors for local statics and global objects. '2' means it has been
457 set nonzero as a default, not by a command-line flag. */
459 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
461 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
462 code. '2' means it has not been set explicitly on the command line. */
464 int flag_use_cxa_get_exception_ptr = 2;
466 /* Nonzero means to implement standard semantics for exception
467 specifications, calling unexpected if an exception is thrown that
468 doesn't match the specification. Zero means to treat them as
469 assertions and optimize accordingly, but not check them. */
471 int flag_enforce_eh_specs = 1;
473 /* Nonzero means to generate thread-safe code for initializing local
476 int flag_threadsafe_statics = 1;
478 /* Nonzero means warn about implicit declarations. */
480 int warn_implicit = 1;
482 /* Maximum template instantiation depth. This limit is rather
483 arbitrary, but it exists to limit the time it takes to notice
484 infinite template instantiations. */
486 int max_tinst_depth = 500;
490 /* The elements of `ridpointers' are identifier nodes for the reserved
491 type names and storage classes. It is indexed by a RID_... value. */
494 tree (*make_fname_decl) (tree, int);
496 /* Nonzero means the expression being parsed will never be evaluated.
497 This is a count, since unevaluated expressions can nest. */
500 /* Information about how a function name is generated. */
503 tree *const decl; /* pointer to the VAR_DECL. */
504 const unsigned rid; /* RID number for the identifier. */
505 const int pretty; /* How pretty is it? */
508 /* The three ways of getting then name of the current function. */
510 const struct fname_var_t fname_vars[] =
512 /* C99 compliant __func__, must be first. */
513 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
514 /* GCC __FUNCTION__ compliant. */
515 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
516 /* GCC __PRETTY_FUNCTION__ compliant. */
517 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
521 static tree check_case_value (tree);
522 static bool check_case_bounds (tree, tree, tree *, tree *);
524 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
525 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
528 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_always_inline_attribute (tree *, tree, tree, int,
533 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
534 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
535 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
536 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
537 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
538 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
539 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
541 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_transparent_union_attribute (tree *, tree, tree,
544 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
545 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
546 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
547 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
548 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
549 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
550 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
551 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
552 static tree handle_visibility_attribute (tree *, tree, tree, int,
554 static tree handle_tls_model_attribute (tree *, tree, tree, int,
556 static tree handle_no_instrument_function_attribute (tree *, tree,
558 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
559 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
560 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
562 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
563 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
564 static tree handle_deprecated_attribute (tree *, tree, tree, int,
566 static tree handle_vector_size_attribute (tree *, tree, tree, int,
568 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
569 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
570 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
571 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
573 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
574 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
575 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
576 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
577 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
579 static void check_function_nonnull (tree, int, tree *);
580 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
581 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
582 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
583 static int resort_field_decl_cmp (const void *, const void *);
585 /* Reserved words. The third field is a mask: keywords are disabled
586 if they match the mask.
589 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
590 C --std=c99: D_CXXONLY | D_OBJC
591 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
592 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
593 C++ --std=c0x: D_CONLY | D_OBJC
594 ObjC++ is like C++ except that D_OBJC is not set
596 If -fno-asm is used, D_ASM is added to the mask. If
597 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
598 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
599 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
601 const struct c_common_resword c_common_reswords[] =
603 { "_Bool", RID_BOOL, D_CONLY },
604 { "_Complex", RID_COMPLEX, 0 },
605 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
606 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
607 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
608 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
609 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
610 { "_Sat", RID_SAT, D_CONLY | D_EXT },
611 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
612 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
613 { "__alignof", RID_ALIGNOF, 0 },
614 { "__alignof__", RID_ALIGNOF, 0 },
615 { "__asm", RID_ASM, 0 },
616 { "__asm__", RID_ASM, 0 },
617 { "__attribute", RID_ATTRIBUTE, 0 },
618 { "__attribute__", RID_ATTRIBUTE, 0 },
619 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
620 { "__builtin_offsetof", RID_OFFSETOF, 0 },
621 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
622 { "__builtin_va_arg", RID_VA_ARG, 0 },
623 { "__complex", RID_COMPLEX, 0 },
624 { "__complex__", RID_COMPLEX, 0 },
625 { "__const", RID_CONST, 0 },
626 { "__const__", RID_CONST, 0 },
627 { "__decltype", RID_DECLTYPE, D_CXXONLY },
628 { "__extension__", RID_EXTENSION, 0 },
629 { "__func__", RID_C99_FUNCTION_NAME, 0 },
630 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
631 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
632 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
633 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
634 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
635 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
636 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
637 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
638 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
639 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
640 { "__is_class", RID_IS_CLASS, D_CXXONLY },
641 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
642 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
643 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
644 { "__is_pod", RID_IS_POD, D_CXXONLY },
645 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
646 { "__is_union", RID_IS_UNION, D_CXXONLY },
647 { "__imag", RID_IMAGPART, 0 },
648 { "__imag__", RID_IMAGPART, 0 },
649 { "__inline", RID_INLINE, 0 },
650 { "__inline__", RID_INLINE, 0 },
651 { "__label__", RID_LABEL, 0 },
652 { "__null", RID_NULL, 0 },
653 { "__real", RID_REALPART, 0 },
654 { "__real__", RID_REALPART, 0 },
655 { "__restrict", RID_RESTRICT, 0 },
656 { "__restrict__", RID_RESTRICT, 0 },
657 { "__signed", RID_SIGNED, 0 },
658 { "__signed__", RID_SIGNED, 0 },
659 { "__thread", RID_THREAD, 0 },
660 { "__typeof", RID_TYPEOF, 0 },
661 { "__typeof__", RID_TYPEOF, 0 },
662 { "__volatile", RID_VOLATILE, 0 },
663 { "__volatile__", RID_VOLATILE, 0 },
664 { "asm", RID_ASM, D_ASM },
665 { "auto", RID_AUTO, 0 },
666 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
667 { "break", RID_BREAK, 0 },
668 { "case", RID_CASE, 0 },
669 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
670 { "char", RID_CHAR, 0 },
671 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
672 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
673 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
674 { "const", RID_CONST, 0 },
675 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
676 { "continue", RID_CONTINUE, 0 },
677 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
678 { "default", RID_DEFAULT, 0 },
679 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
681 { "double", RID_DOUBLE, 0 },
682 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
683 { "else", RID_ELSE, 0 },
684 { "enum", RID_ENUM, 0 },
685 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
686 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
687 { "extern", RID_EXTERN, 0 },
688 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
689 { "float", RID_FLOAT, 0 },
690 { "for", RID_FOR, 0 },
691 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
692 { "goto", RID_GOTO, 0 },
694 { "inline", RID_INLINE, D_EXT89 },
695 { "int", RID_INT, 0 },
696 { "long", RID_LONG, 0 },
697 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
698 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
699 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
700 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
701 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
702 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
703 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
704 { "register", RID_REGISTER, 0 },
705 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
706 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
707 { "return", RID_RETURN, 0 },
708 { "short", RID_SHORT, 0 },
709 { "signed", RID_SIGNED, 0 },
710 { "sizeof", RID_SIZEOF, 0 },
711 { "static", RID_STATIC, 0 },
712 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
713 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
714 { "struct", RID_STRUCT, 0 },
715 { "switch", RID_SWITCH, 0 },
716 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
717 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
718 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
719 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
720 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
721 { "typedef", RID_TYPEDEF, 0 },
722 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
723 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
724 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
725 { "union", RID_UNION, 0 },
726 { "unsigned", RID_UNSIGNED, 0 },
727 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
728 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
729 { "void", RID_VOID, 0 },
730 { "volatile", RID_VOLATILE, 0 },
731 { "wchar_t", RID_WCHAR, D_CXXONLY },
732 { "while", RID_WHILE, 0 },
733 /* These Objective-C keywords are recognized only immediately after
735 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
736 { "defs", RID_AT_DEFS, D_OBJC },
737 { "encode", RID_AT_ENCODE, D_OBJC },
738 { "end", RID_AT_END, D_OBJC },
739 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
740 { "interface", RID_AT_INTERFACE, D_OBJC },
741 { "protocol", RID_AT_PROTOCOL, D_OBJC },
742 { "selector", RID_AT_SELECTOR, D_OBJC },
743 { "finally", RID_AT_FINALLY, D_OBJC },
744 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
745 /* These are recognized only in protocol-qualifier context
747 { "bycopy", RID_BYCOPY, D_OBJC },
748 { "byref", RID_BYREF, D_OBJC },
749 { "in", RID_IN, D_OBJC },
750 { "inout", RID_INOUT, D_OBJC },
751 { "oneway", RID_ONEWAY, D_OBJC },
752 { "out", RID_OUT, D_OBJC },
755 const unsigned int num_c_common_reswords =
756 sizeof c_common_reswords / sizeof (struct c_common_resword);
758 /* Table of machine-independent attributes common to all C-like languages. */
759 const struct attribute_spec c_common_attribute_table[] =
761 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
762 { "packed", 0, 0, false, false, false,
763 handle_packed_attribute },
764 { "nocommon", 0, 0, true, false, false,
765 handle_nocommon_attribute },
766 { "common", 0, 0, true, false, false,
767 handle_common_attribute },
768 /* FIXME: logically, noreturn attributes should be listed as
769 "false, true, true" and apply to function types. But implementing this
770 would require all the places in the compiler that use TREE_THIS_VOLATILE
771 on a decl to identify non-returning functions to be located and fixed
772 to check the function type instead. */
773 { "noreturn", 0, 0, true, false, false,
774 handle_noreturn_attribute },
775 { "volatile", 0, 0, true, false, false,
776 handle_noreturn_attribute },
777 { "noinline", 0, 0, true, false, false,
778 handle_noinline_attribute },
779 { "always_inline", 0, 0, true, false, false,
780 handle_always_inline_attribute },
781 { "gnu_inline", 0, 0, true, false, false,
782 handle_gnu_inline_attribute },
783 { "artificial", 0, 0, true, false, false,
784 handle_artificial_attribute },
785 { "flatten", 0, 0, true, false, false,
786 handle_flatten_attribute },
787 { "used", 0, 0, true, false, false,
788 handle_used_attribute },
789 { "unused", 0, 0, false, false, false,
790 handle_unused_attribute },
791 { "externally_visible", 0, 0, true, false, false,
792 handle_externally_visible_attribute },
793 /* The same comments as for noreturn attributes apply to const ones. */
794 { "const", 0, 0, true, false, false,
795 handle_const_attribute },
796 { "transparent_union", 0, 0, false, false, false,
797 handle_transparent_union_attribute },
798 { "constructor", 0, 1, true, false, false,
799 handle_constructor_attribute },
800 { "destructor", 0, 1, true, false, false,
801 handle_destructor_attribute },
802 { "mode", 1, 1, false, true, false,
803 handle_mode_attribute },
804 { "section", 1, 1, true, false, false,
805 handle_section_attribute },
806 { "aligned", 0, 1, false, false, false,
807 handle_aligned_attribute },
808 { "weak", 0, 0, true, false, false,
809 handle_weak_attribute },
810 { "alias", 1, 1, true, false, false,
811 handle_alias_attribute },
812 { "weakref", 0, 1, true, false, false,
813 handle_weakref_attribute },
814 { "no_instrument_function", 0, 0, true, false, false,
815 handle_no_instrument_function_attribute },
816 { "malloc", 0, 0, true, false, false,
817 handle_malloc_attribute },
818 { "returns_twice", 0, 0, true, false, false,
819 handle_returns_twice_attribute },
820 { "no_stack_limit", 0, 0, true, false, false,
821 handle_no_limit_stack_attribute },
822 { "pure", 0, 0, true, false, false,
823 handle_pure_attribute },
824 /* For internal use (marking of builtins) only. The name contains space
825 to prevent its usage in source code. */
826 { "no vops", 0, 0, true, false, false,
827 handle_novops_attribute },
828 { "deprecated", 0, 0, false, false, false,
829 handle_deprecated_attribute },
830 { "vector_size", 1, 1, false, true, false,
831 handle_vector_size_attribute },
832 { "visibility", 1, 1, false, false, false,
833 handle_visibility_attribute },
834 { "tls_model", 1, 1, true, false, false,
835 handle_tls_model_attribute },
836 { "nonnull", 0, -1, false, true, true,
837 handle_nonnull_attribute },
838 { "nothrow", 0, 0, true, false, false,
839 handle_nothrow_attribute },
840 { "may_alias", 0, 0, false, true, false, NULL },
841 { "cleanup", 1, 1, true, false, false,
842 handle_cleanup_attribute },
843 { "warn_unused_result", 0, 0, false, true, true,
844 handle_warn_unused_result_attribute },
845 { "sentinel", 0, 1, false, true, true,
846 handle_sentinel_attribute },
847 /* For internal use (marking of builtins) only. The name contains space
848 to prevent its usage in source code. */
849 { "type generic", 0, 0, false, true, true,
850 handle_type_generic_attribute },
851 { "alloc_size", 1, 2, false, true, true,
852 handle_alloc_size_attribute },
853 { "cold", 0, 0, true, false, false,
854 handle_cold_attribute },
855 { "hot", 0, 0, true, false, false,
856 handle_hot_attribute },
857 { "warning", 1, 1, true, false, false,
858 handle_error_attribute },
859 { "error", 1, 1, true, false, false,
860 handle_error_attribute },
861 { "target", 1, -1, true, false, false,
862 handle_target_attribute },
863 { "optimize", 1, -1, true, false, false,
864 handle_optimize_attribute },
865 { NULL, 0, 0, false, false, false, NULL }
868 /* Give the specifications for the format attributes, used by C and all
871 const struct attribute_spec c_common_format_attribute_table[] =
873 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
874 { "format", 3, 3, false, true, true,
875 handle_format_attribute },
876 { "format_arg", 1, 1, false, true, true,
877 handle_format_arg_attribute },
878 { NULL, 0, 0, false, false, false, NULL }
881 /* Push current bindings for the function name VAR_DECLS. */
884 start_fname_decls (void)
887 tree saved = NULL_TREE;
889 for (ix = 0; fname_vars[ix].decl; ix++)
891 tree decl = *fname_vars[ix].decl;
895 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
896 *fname_vars[ix].decl = NULL_TREE;
899 if (saved || saved_function_name_decls)
900 /* Normally they'll have been NULL, so only push if we've got a
901 stack, or they are non-NULL. */
902 saved_function_name_decls = tree_cons (saved, NULL_TREE,
903 saved_function_name_decls);
906 /* Finish up the current bindings, adding them into the current function's
907 statement tree. This must be done _before_ finish_stmt_tree is called.
908 If there is no current function, we must be at file scope and no statements
909 are involved. Pop the previous bindings. */
912 finish_fname_decls (void)
915 tree stmts = NULL_TREE;
916 tree stack = saved_function_name_decls;
918 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
919 append_to_statement_list (TREE_VALUE (stack), &stmts);
923 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
925 if (TREE_CODE (*bodyp) == BIND_EXPR)
926 bodyp = &BIND_EXPR_BODY (*bodyp);
928 append_to_statement_list_force (*bodyp, &stmts);
932 for (ix = 0; fname_vars[ix].decl; ix++)
933 *fname_vars[ix].decl = NULL_TREE;
937 /* We had saved values, restore them. */
940 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
942 tree decl = TREE_PURPOSE (saved);
943 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
945 *fname_vars[ix].decl = decl;
947 stack = TREE_CHAIN (stack);
949 saved_function_name_decls = stack;
952 /* Return the text name of the current function, suitably prettified
953 by PRETTY_P. Return string must be freed by caller. */
956 fname_as_string (int pretty_p)
958 const char *name = "top level";
961 cpp_string cstr = { 0, 0 }, strname;
969 if (current_function_decl)
970 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
972 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
974 namep = XNEWVEC (char, len);
975 snprintf (namep, len, "\"%s\"", name);
976 strname.text = (unsigned char *) namep;
977 strname.len = len - 1;
979 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
982 return (const char *) cstr.text;
988 /* Return the VAR_DECL for a const char array naming the current
989 function. If the VAR_DECL has not yet been created, create it
990 now. RID indicates how it should be formatted and IDENTIFIER_NODE
991 ID is its name (unfortunately C and C++ hold the RID values of
992 keywords in different places, so we can't derive RID from ID in
993 this language independent code. LOC is the location of the
997 fname_decl (location_t loc, unsigned int rid, tree id)
1000 tree decl = NULL_TREE;
1002 for (ix = 0; fname_vars[ix].decl; ix++)
1003 if (fname_vars[ix].rid == rid)
1006 decl = *fname_vars[ix].decl;
1009 /* If a tree is built here, it would normally have the lineno of
1010 the current statement. Later this tree will be moved to the
1011 beginning of the function and this line number will be wrong.
1012 To avoid this problem set the lineno to 0 here; that prevents
1013 it from appearing in the RTL. */
1015 location_t saved_location = input_location;
1016 input_location = UNKNOWN_LOCATION;
1018 stmts = push_stmt_list ();
1019 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1020 stmts = pop_stmt_list (stmts);
1021 if (!IS_EMPTY_STMT (stmts))
1022 saved_function_name_decls
1023 = tree_cons (decl, stmts, saved_function_name_decls);
1024 *fname_vars[ix].decl = decl;
1025 input_location = saved_location;
1027 if (!ix && !current_function_decl)
1028 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1033 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1036 fix_string_type (tree value)
1038 int length = TREE_STRING_LENGTH (value);
1040 tree e_type, i_type, a_type;
1042 /* Compute the number of elements, for the array type. */
1043 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1046 e_type = char_type_node;
1048 else if (TREE_TYPE (value) == char16_array_type_node)
1050 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1051 e_type = char16_type_node;
1053 else if (TREE_TYPE (value) == char32_array_type_node)
1055 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1056 e_type = char32_type_node;
1060 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1061 e_type = wchar_type_node;
1064 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1065 limit in C++98 Annex B is very large (65536) and is not normative,
1066 so we do not diagnose it (warn_overlength_strings is forced off
1067 in c_common_post_options). */
1068 if (warn_overlength_strings)
1070 const int nchars_max = flag_isoc99 ? 4095 : 509;
1071 const int relevant_std = flag_isoc99 ? 99 : 90;
1072 if (nchars - 1 > nchars_max)
1073 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1074 separate the %d from the 'C'. 'ISO' should not be
1075 translated, but it may be moved after 'C%d' in languages
1076 where modifiers follow nouns. */
1077 pedwarn (input_location, OPT_Woverlength_strings,
1078 "string length %qd is greater than the length %qd "
1079 "ISO C%d compilers are required to support",
1080 nchars - 1, nchars_max, relevant_std);
1083 /* Create the array type for the string constant. The ISO C++
1084 standard says that a string literal has type `const char[N]' or
1085 `const wchar_t[N]'. We use the same logic when invoked as a C
1086 front-end with -Wwrite-strings.
1087 ??? We should change the type of an expression depending on the
1088 state of a warning flag. We should just be warning -- see how
1089 this is handled in the C++ front-end for the deprecated implicit
1090 conversion from string literals to `char*' or `wchar_t*'.
1092 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1093 array type being the unqualified version of that type.
1094 Therefore, if we are constructing an array of const char, we must
1095 construct the matching unqualified array type first. The C front
1096 end does not require this, but it does no harm, so we do it
1098 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1099 a_type = build_array_type (e_type, i_type);
1100 if (c_dialect_cxx() || warn_write_strings)
1101 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1103 TREE_TYPE (value) = a_type;
1104 TREE_CONSTANT (value) = 1;
1105 TREE_READONLY (value) = 1;
1106 TREE_STATIC (value) = 1;
1110 /* Print a warning if a constant expression had overflow in folding.
1111 Invoke this function on every expression that the language
1112 requires to be a constant expression.
1113 Note the ANSI C standard says it is erroneous for a
1114 constant expression to overflow. */
1117 constant_expression_warning (tree value)
1119 if (warn_overflow && pedantic
1120 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1121 || TREE_CODE (value) == FIXED_CST
1122 || TREE_CODE (value) == VECTOR_CST
1123 || TREE_CODE (value) == COMPLEX_CST)
1124 && TREE_OVERFLOW (value))
1125 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1128 /* The same as above but print an unconditional error. */
1130 constant_expression_error (tree value)
1132 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1133 || TREE_CODE (value) == FIXED_CST
1134 || TREE_CODE (value) == VECTOR_CST
1135 || TREE_CODE (value) == COMPLEX_CST)
1136 && TREE_OVERFLOW (value))
1137 error ("overflow in constant expression");
1140 /* Print a warning if an expression had overflow in folding and its
1143 Invoke this function on every expression that
1144 (1) appears in the source code, and
1145 (2) is a constant expression that overflowed, and
1146 (3) is not already checked by convert_and_check;
1147 however, do not invoke this function on operands of explicit casts
1148 or when the expression is the result of an operator and any operand
1149 already overflowed. */
1152 overflow_warning (tree value)
1154 if (skip_evaluation) return;
1156 switch (TREE_CODE (value))
1159 warning (OPT_Woverflow, "integer overflow in expression");
1163 warning (OPT_Woverflow, "floating point overflow in expression");
1167 warning (OPT_Woverflow, "fixed-point overflow in expression");
1171 warning (OPT_Woverflow, "vector overflow in expression");
1175 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1176 warning (OPT_Woverflow, "complex integer overflow in expression");
1177 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1178 warning (OPT_Woverflow, "complex floating point overflow in expression");
1187 /* Warn about use of a logical || / && operator being used in a
1188 context where it is likely that the bitwise equivalent was intended
1189 by the programmer. CODE is the TREE_CODE of the operator, ARG1
1190 and ARG2 the arguments. */
1193 warn_logical_operator (enum tree_code code, tree arg1, tree
1198 case TRUTH_ANDIF_EXPR:
1199 case TRUTH_ORIF_EXPR:
1201 case TRUTH_AND_EXPR:
1202 if (!TREE_NO_WARNING (arg1)
1203 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
1204 && !CONSTANT_CLASS_P (arg1)
1205 && TREE_CODE (arg2) == INTEGER_CST
1206 && !integer_zerop (arg2))
1208 warning (OPT_Wlogical_op,
1209 "logical %<%s%> with non-zero constant "
1210 "will always evaluate as true",
1211 ((code == TRUTH_ANDIF_EXPR)
1212 || (code == TRUTH_AND_EXPR)) ? "&&" : "||");
1213 TREE_NO_WARNING (arg1) = true;
1222 /* Print a warning about casts that might indicate violation
1223 of strict aliasing rules if -Wstrict-aliasing is used and
1224 strict aliasing mode is in effect. OTYPE is the original
1225 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1228 strict_aliasing_warning (tree otype, tree type, tree expr)
1230 if (!(flag_strict_aliasing
1231 && POINTER_TYPE_P (type)
1232 && POINTER_TYPE_P (otype)
1233 && !VOID_TYPE_P (TREE_TYPE (type)))
1234 /* If the type we are casting to is a ref-all pointer
1235 dereferencing it is always valid. */
1236 || TYPE_REF_CAN_ALIAS_ALL (type))
1239 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1240 && (DECL_P (TREE_OPERAND (expr, 0))
1241 || handled_component_p (TREE_OPERAND (expr, 0))))
1243 /* Casting the address of an object to non void pointer. Warn
1244 if the cast breaks type based aliasing. */
1245 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1247 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1248 "might break strict-aliasing rules");
1253 /* warn_strict_aliasing >= 3. This includes the default (3).
1254 Only warn if the cast is dereferenced immediately. */
1255 alias_set_type set1 =
1256 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1257 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1259 if (set1 != set2 && set2 != 0
1260 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1262 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1263 "pointer will break strict-aliasing rules");
1266 else if (warn_strict_aliasing == 2
1267 && !alias_sets_must_conflict_p (set1, set2))
1269 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1270 "pointer might break strict-aliasing rules");
1276 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1278 /* At this level, warn for any conversions, even if an address is
1279 not taken in the same statement. This will likely produce many
1280 false positives, but could be useful to pinpoint problems that
1281 are not revealed at higher levels. */
1282 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1283 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1284 if (!COMPLETE_TYPE_P (type)
1285 || !alias_sets_must_conflict_p (set1, set2))
1287 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1288 "pointer might break strict-aliasing rules");
1296 /* Warn for unlikely, improbable, or stupid DECL declarations
1300 check_main_parameter_types (tree decl)
1305 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1306 args = TREE_CHAIN (args))
1308 tree type = args ? TREE_VALUE (args) : 0;
1310 if (type == void_type_node || type == error_mark_node )
1317 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1318 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1323 if (TREE_CODE (type) != POINTER_TYPE
1324 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1325 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1327 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1332 if (TREE_CODE (type) != POINTER_TYPE
1333 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1334 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1336 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1337 "%<char **%>", decl);
1342 /* It is intentional that this message does not mention the third
1343 argument because it's only mentioned in an appendix of the
1345 if (argct > 0 && (argct < 2 || argct > 3))
1346 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1349 /* True if pointers to distinct types T1 and T2 can be converted to
1350 each other without an explicit cast. Only returns true for opaque
1353 vector_targets_convertible_p (const_tree t1, const_tree t2)
1355 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1356 && (targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1357 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1363 /* True if vector types T1 and T2 can be converted to each other
1364 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1365 can only be converted with -flax-vector-conversions yet that is not
1366 in effect, emit a note telling the user about that option if such
1367 a note has not previously been emitted. */
1369 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1371 static bool emitted_lax_note = false;
1372 bool convertible_lax;
1374 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1375 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1379 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1380 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1381 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1382 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1383 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1385 if (!convertible_lax || flag_lax_vector_conversions)
1386 return convertible_lax;
1388 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1389 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1392 if (emit_lax_note && !emitted_lax_note)
1394 emitted_lax_note = true;
1395 inform (input_location, "use -flax-vector-conversions to permit "
1396 "conversions between vectors with differing "
1397 "element types or numbers of subparts");
1403 /* This is a helper function of build_binary_op.
1405 For certain operations if both args were extended from the same
1406 smaller type, do the arithmetic in that type and then extend.
1408 BITWISE indicates a bitwise operation.
1409 For them, this optimization is safe only if
1410 both args are zero-extended or both are sign-extended.
1411 Otherwise, we might change the result.
1412 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1413 but calculated in (unsigned short) it would be (unsigned short)-1.
1415 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1417 int unsigned0, unsigned1;
1422 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1423 excessive narrowing when we call get_narrower below. For
1424 example, suppose that OP0 is of unsigned int extended
1425 from signed char and that RESULT_TYPE is long long int.
1426 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1429 (long long int) (unsigned int) signed_char
1431 which get_narrower would narrow down to
1433 (unsigned int) signed char
1435 If we do not cast OP0 first, get_narrower would return
1436 signed_char, which is inconsistent with the case of the
1438 op0 = convert (result_type, op0);
1439 op1 = convert (result_type, op1);
1441 arg0 = get_narrower (op0, &unsigned0);
1442 arg1 = get_narrower (op1, &unsigned1);
1444 /* UNS is 1 if the operation to be done is an unsigned one. */
1445 uns = TYPE_UNSIGNED (result_type);
1447 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1448 but it *requires* conversion to FINAL_TYPE. */
1450 if ((TYPE_PRECISION (TREE_TYPE (op0))
1451 == TYPE_PRECISION (TREE_TYPE (arg0)))
1452 && TREE_TYPE (op0) != result_type)
1453 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1454 if ((TYPE_PRECISION (TREE_TYPE (op1))
1455 == TYPE_PRECISION (TREE_TYPE (arg1)))
1456 && TREE_TYPE (op1) != result_type)
1457 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1459 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1461 /* For bitwise operations, signedness of nominal type
1462 does not matter. Consider only how operands were extended. */
1466 /* Note that in all three cases below we refrain from optimizing
1467 an unsigned operation on sign-extended args.
1468 That would not be valid. */
1470 /* Both args variable: if both extended in same way
1471 from same width, do it in that width.
1472 Do it unsigned if args were zero-extended. */
1473 if ((TYPE_PRECISION (TREE_TYPE (arg0))
1474 < TYPE_PRECISION (result_type))
1475 && (TYPE_PRECISION (TREE_TYPE (arg1))
1476 == TYPE_PRECISION (TREE_TYPE (arg0)))
1477 && unsigned0 == unsigned1
1478 && (unsigned0 || !uns))
1479 return c_common_signed_or_unsigned_type
1480 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1482 else if (TREE_CODE (arg0) == INTEGER_CST
1483 && (unsigned1 || !uns)
1484 && (TYPE_PRECISION (TREE_TYPE (arg1))
1485 < TYPE_PRECISION (result_type))
1487 = c_common_signed_or_unsigned_type (unsigned1,
1489 && !POINTER_TYPE_P (type)
1490 && int_fits_type_p (arg0, type))
1493 else if (TREE_CODE (arg1) == INTEGER_CST
1494 && (unsigned0 || !uns)
1495 && (TYPE_PRECISION (TREE_TYPE (arg0))
1496 < TYPE_PRECISION (result_type))
1498 = c_common_signed_or_unsigned_type (unsigned0,
1500 && !POINTER_TYPE_P (type)
1501 && int_fits_type_p (arg1, type))
1507 /* Warns if the conversion of EXPR to TYPE may alter a value.
1508 This is a helper function for warnings_for_convert_and_check. */
1511 conversion_warning (tree type, tree expr)
1513 bool give_warning = false;
1516 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
1517 tree expr_type = TREE_TYPE (expr);
1519 if (!warn_conversion && !warn_sign_conversion)
1522 /* If any operand is artificial, then this expression was generated
1523 by the compiler and we do not warn. */
1524 for (i = 0; i < expr_num_operands; i++)
1526 tree op = TREE_OPERAND (expr, i);
1527 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
1531 switch (TREE_CODE (expr))
1539 case TRUTH_ANDIF_EXPR:
1540 case TRUTH_ORIF_EXPR:
1541 case TRUTH_AND_EXPR:
1543 case TRUTH_XOR_EXPR:
1544 case TRUTH_NOT_EXPR:
1545 /* Conversion from boolean to a signed:1 bit-field (which only
1546 can hold the values 0 and -1) doesn't lose information - but
1547 it does change the value. */
1548 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
1549 warning (OPT_Wconversion,
1550 "conversion to %qT from boolean expression", type);
1556 /* Warn for real constant that is not an exact integer converted
1558 if (TREE_CODE (expr_type) == REAL_TYPE
1559 && TREE_CODE (type) == INTEGER_TYPE)
1561 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
1562 give_warning = true;
1564 /* Warn for an integer constant that does not fit into integer type. */
1565 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1566 && TREE_CODE (type) == INTEGER_TYPE
1567 && !int_fits_type_p (expr, type))
1569 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
1570 && tree_int_cst_sgn (expr) < 0)
1571 warning (OPT_Wsign_conversion,
1572 "negative integer implicitly converted to unsigned type");
1573 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
1574 warning (OPT_Wsign_conversion, "conversion of unsigned constant "
1575 "value to negative integer");
1577 give_warning = true;
1579 else if (TREE_CODE (type) == REAL_TYPE)
1581 /* Warn for an integer constant that does not fit into real type. */
1582 if (TREE_CODE (expr_type) == INTEGER_TYPE)
1584 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1585 if (!exact_real_truncate (TYPE_MODE (type), &a))
1586 give_warning = true;
1588 /* Warn for a real constant that does not fit into a smaller
1590 else if (TREE_CODE (expr_type) == REAL_TYPE
1591 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1593 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1594 if (!exact_real_truncate (TYPE_MODE (type), &a))
1595 give_warning = true;
1600 warning (OPT_Wconversion,
1601 "conversion to %qT alters %qT constant value",
1608 /* In case of COND_EXPR, if both operands are constants or
1609 COND_EXPR, then we do not care about the type of COND_EXPR,
1610 only about the conversion of each operand. */
1611 tree op1 = TREE_OPERAND (expr, 1);
1612 tree op2 = TREE_OPERAND (expr, 2);
1614 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
1615 || TREE_CODE (op1) == COND_EXPR)
1616 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
1617 || TREE_CODE (op2) == COND_EXPR))
1619 conversion_warning (type, op1);
1620 conversion_warning (type, op2);
1626 default: /* 'expr' is not a constant. */
1628 /* Warn for real types converted to integer types. */
1629 if (TREE_CODE (expr_type) == REAL_TYPE
1630 && TREE_CODE (type) == INTEGER_TYPE)
1631 give_warning = true;
1633 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1634 && TREE_CODE (type) == INTEGER_TYPE)
1636 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1637 expr = get_unwidened (expr, 0);
1638 expr_type = TREE_TYPE (expr);
1640 /* Don't warn for short y; short x = ((int)y & 0xff); */
1641 if (TREE_CODE (expr) == BIT_AND_EXPR
1642 || TREE_CODE (expr) == BIT_IOR_EXPR
1643 || TREE_CODE (expr) == BIT_XOR_EXPR)
1645 /* If both args were extended from a shortest type,
1646 use that type if that is safe. */
1647 expr_type = shorten_binary_op (expr_type,
1648 TREE_OPERAND (expr, 0),
1649 TREE_OPERAND (expr, 1),
1652 if (TREE_CODE (expr) == BIT_AND_EXPR)
1654 tree op0 = TREE_OPERAND (expr, 0);
1655 tree op1 = TREE_OPERAND (expr, 1);
1656 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1657 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1659 /* If one of the operands is a non-negative constant
1660 that fits in the target type, then the type of the
1661 other operand does not matter. */
1662 if ((TREE_CODE (op0) == INTEGER_CST
1663 && int_fits_type_p (op0, c_common_signed_type (type))
1664 && int_fits_type_p (op0, c_common_unsigned_type (type)))
1665 || (TREE_CODE (op1) == INTEGER_CST
1666 && int_fits_type_p (op1, c_common_signed_type (type))
1667 && int_fits_type_p (op1,
1668 c_common_unsigned_type (type))))
1670 /* If constant is unsigned and fits in the target
1671 type, then the result will also fit. */
1672 else if ((TREE_CODE (op0) == INTEGER_CST
1674 && int_fits_type_p (op0, type))
1675 || (TREE_CODE (op1) == INTEGER_CST
1677 && int_fits_type_p (op1, type)))
1681 /* Warn for integer types converted to smaller integer types. */
1682 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1683 give_warning = true;
1685 /* When they are the same width but different signedness,
1686 then the value may change. */
1687 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
1688 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
1689 /* Even when converted to a bigger type, if the type is
1690 unsigned but expr is signed, then negative values
1692 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
1693 warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
1694 "may change the sign of the result",
1698 /* Warn for integer types converted to real types if and only if
1699 all the range of values of the integer type cannot be
1700 represented by the real type. */
1701 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1702 && TREE_CODE (type) == REAL_TYPE)
1704 tree type_low_bound = TYPE_MIN_VALUE (expr_type);
1705 tree type_high_bound = TYPE_MAX_VALUE (expr_type);
1706 REAL_VALUE_TYPE real_low_bound
1707 = real_value_from_int_cst (0, type_low_bound);
1708 REAL_VALUE_TYPE real_high_bound
1709 = real_value_from_int_cst (0, type_high_bound);
1711 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1712 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1713 give_warning = true;
1716 /* Warn for real types converted to smaller real types. */
1717 else if (TREE_CODE (expr_type) == REAL_TYPE
1718 && TREE_CODE (type) == REAL_TYPE
1719 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1720 give_warning = true;
1724 warning (OPT_Wconversion,
1725 "conversion to %qT from %qT may alter its value",
1730 /* Produce warnings after a conversion. RESULT is the result of
1731 converting EXPR to TYPE. This is a helper function for
1732 convert_and_check and cp_convert_and_check. */
1735 warnings_for_convert_and_check (tree type, tree expr, tree result)
1737 if (TREE_CODE (expr) == INTEGER_CST
1738 && (TREE_CODE (type) == INTEGER_TYPE
1739 || TREE_CODE (type) == ENUMERAL_TYPE)
1740 && !int_fits_type_p (expr, type))
1742 /* Do not diagnose overflow in a constant expression merely
1743 because a conversion overflowed. */
1744 if (TREE_OVERFLOW (result))
1745 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1747 if (TYPE_UNSIGNED (type))
1749 /* This detects cases like converting -129 or 256 to
1751 if (!int_fits_type_p (expr, c_common_signed_type (type)))
1752 warning (OPT_Woverflow,
1753 "large integer implicitly truncated to unsigned type");
1755 conversion_warning (type, expr);
1757 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
1758 warning (OPT_Woverflow,
1759 "overflow in implicit constant conversion");
1760 /* No warning for converting 0x80000000 to int. */
1762 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1763 || TYPE_PRECISION (TREE_TYPE (expr))
1764 != TYPE_PRECISION (type)))
1765 warning (OPT_Woverflow,
1766 "overflow in implicit constant conversion");
1769 conversion_warning (type, expr);
1771 else if ((TREE_CODE (result) == INTEGER_CST
1772 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
1773 warning (OPT_Woverflow,
1774 "overflow in implicit constant conversion");
1776 conversion_warning (type, expr);
1780 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1781 Invoke this function on every expression that is converted implicitly,
1782 i.e. because of language rules and not because of an explicit cast. */
1785 convert_and_check (tree type, tree expr)
1789 if (TREE_TYPE (expr) == type)
1792 result = convert (type, expr);
1794 if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
1795 warnings_for_convert_and_check (type, expr, result);
1800 /* A node in a list that describes references to variables (EXPR), which are
1801 either read accesses if WRITER is zero, or write accesses, in which case
1802 WRITER is the parent of EXPR. */
1809 /* Used to implement a cache the results of a call to verify_tree. We only
1810 use this for SAVE_EXPRs. */
1813 struct tlist_cache *next;
1814 struct tlist *cache_before_sp;
1815 struct tlist *cache_after_sp;
1819 /* Obstack to use when allocating tlist structures, and corresponding
1821 static struct obstack tlist_obstack;
1822 static char *tlist_firstobj = 0;
1824 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1826 static struct tlist *warned_ids;
1827 /* SAVE_EXPRs need special treatment. We process them only once and then
1828 cache the results. */
1829 static struct tlist_cache *save_expr_cache;
1831 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1832 static void merge_tlist (struct tlist **, struct tlist *, int);
1833 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1834 static int warning_candidate_p (tree);
1835 static void warn_for_collisions (struct tlist *);
1836 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1837 static struct tlist *new_tlist (struct tlist *, tree, tree);
1839 /* Create a new struct tlist and fill in its fields. */
1840 static struct tlist *
1841 new_tlist (struct tlist *next, tree t, tree writer)
1844 l = XOBNEW (&tlist_obstack, struct tlist);
1851 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1852 is nonnull, we ignore any node we find which has a writer equal to it. */
1855 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1859 struct tlist *next = add->next;
1862 if (!exclude_writer || add->writer != exclude_writer)
1863 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1868 /* Merge the nodes of ADD into TO. This merging process is done so that for
1869 each variable that already exists in TO, no new node is added; however if
1870 there is a write access recorded in ADD, and an occurrence on TO is only
1871 a read access, then the occurrence in TO will be modified to record the
1875 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1877 struct tlist **end = to;
1880 end = &(*end)->next;
1886 struct tlist *next = add->next;
1888 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1889 if (tmp2->expr == add->expr)
1893 tmp2->writer = add->writer;
1897 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1898 end = &(*end)->next;
1905 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1906 references in list LIST conflict with it, excluding reads if ONLY writers
1910 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1915 /* Avoid duplicate warnings. */
1916 for (tmp = warned_ids; tmp; tmp = tmp->next)
1917 if (tmp->expr == written)
1922 if (list->expr == written
1923 && list->writer != writer
1924 && (!only_writes || list->writer)
1925 && DECL_NAME (list->expr))
1927 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1928 warning_at (EXPR_HAS_LOCATION (writer)
1929 ? EXPR_LOCATION (writer) : input_location,
1930 OPT_Wsequence_point, "operation on %qE may be undefined",
1937 /* Given a list LIST of references to variables, find whether any of these
1938 can cause conflicts due to missing sequence points. */
1941 warn_for_collisions (struct tlist *list)
1945 for (tmp = list; tmp; tmp = tmp->next)
1948 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1952 /* Return nonzero if X is a tree that can be verified by the sequence point
1955 warning_candidate_p (tree x)
1957 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1960 /* Walk the tree X, and record accesses to variables. If X is written by the
1961 parent tree, WRITER is the parent.
1962 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1963 expression or its only operand forces a sequence point, then everything up
1964 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1966 Once we return, we will have emitted warnings if any subexpression before
1967 such a sequence point could be undefined. On a higher level, however, the
1968 sequence point may not be relevant, and we'll merge the two lists.
1970 Example: (b++, a) + b;
1971 The call that processes the COMPOUND_EXPR will store the increment of B
1972 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1973 processes the PLUS_EXPR will need to merge the two lists so that
1974 eventually, all accesses end up on the same list (and we'll warn about the
1975 unordered subexpressions b++ and b.
1977 A note on merging. If we modify the former example so that our expression
1980 care must be taken not simply to add all three expressions into the final
1981 PNO_SP list. The function merge_tlist takes care of that by merging the
1982 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1983 way, so that no more than one access to B is recorded. */
1986 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1989 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1990 enum tree_code code;
1991 enum tree_code_class cl;
1993 /* X may be NULL if it is the operand of an empty statement expression
1999 code = TREE_CODE (x);
2000 cl = TREE_CODE_CLASS (code);
2002 if (warning_candidate_p (x))
2004 *pno_sp = new_tlist (*pno_sp, x, writer);
2014 case TRUTH_ANDIF_EXPR:
2015 case TRUTH_ORIF_EXPR:
2016 tmp_before = tmp_nosp = tmp_list3 = 0;
2017 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2018 warn_for_collisions (tmp_nosp);
2019 merge_tlist (pbefore_sp, tmp_before, 0);
2020 merge_tlist (pbefore_sp, tmp_nosp, 0);
2021 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2022 merge_tlist (pbefore_sp, tmp_list3, 0);
2026 tmp_before = tmp_list2 = 0;
2027 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2028 warn_for_collisions (tmp_list2);
2029 merge_tlist (pbefore_sp, tmp_before, 0);
2030 merge_tlist (pbefore_sp, tmp_list2, 1);
2032 tmp_list3 = tmp_nosp = 0;
2033 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2034 warn_for_collisions (tmp_nosp);
2035 merge_tlist (pbefore_sp, tmp_list3, 0);
2037 tmp_list3 = tmp_list2 = 0;
2038 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2039 warn_for_collisions (tmp_list2);
2040 merge_tlist (pbefore_sp, tmp_list3, 0);
2041 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2042 two first, to avoid warning for (a ? b++ : b++). */
2043 merge_tlist (&tmp_nosp, tmp_list2, 0);
2044 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2047 case PREDECREMENT_EXPR:
2048 case PREINCREMENT_EXPR:
2049 case POSTDECREMENT_EXPR:
2050 case POSTINCREMENT_EXPR:
2051 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2055 tmp_before = tmp_nosp = tmp_list3 = 0;
2056 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2057 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2058 /* Expressions inside the LHS are not ordered wrt. the sequence points
2059 in the RHS. Example:
2061 Despite the fact that the modification of "a" is in the before_sp
2062 list (tmp_before), it conflicts with the use of "a" in the LHS.
2063 We can handle this by adding the contents of tmp_list3
2064 to those of tmp_before, and redoing the collision warnings for that
2066 add_tlist (&tmp_before, tmp_list3, x, 1);
2067 warn_for_collisions (tmp_before);
2068 /* Exclude the LHS itself here; we first have to merge it into the
2069 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2070 didn't exclude the LHS, we'd get it twice, once as a read and once
2072 add_tlist (pno_sp, tmp_list3, x, 0);
2073 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2075 merge_tlist (pbefore_sp, tmp_before, 0);
2076 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2077 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2078 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2082 /* We need to warn about conflicts among arguments and conflicts between
2083 args and the function address. Side effects of the function address,
2084 however, are not ordered by the sequence point of the call. */
2086 call_expr_arg_iterator iter;
2088 tmp_before = tmp_nosp = 0;
2089 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2090 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2092 tmp_list2 = tmp_list3 = 0;
2093 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2094 merge_tlist (&tmp_list3, tmp_list2, 0);
2095 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2097 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2098 warn_for_collisions (tmp_before);
2099 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2104 /* Scan all the list, e.g. indices of multi dimensional array. */
2107 tmp_before = tmp_nosp = 0;
2108 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2109 merge_tlist (&tmp_nosp, tmp_before, 0);
2110 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2117 struct tlist_cache *t;
2118 for (t = save_expr_cache; t; t = t->next)
2124 t = XOBNEW (&tlist_obstack, struct tlist_cache);
2125 t->next = save_expr_cache;
2127 save_expr_cache = t;
2129 tmp_before = tmp_nosp = 0;
2130 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2131 warn_for_collisions (tmp_nosp);
2136 struct tlist *t = tmp_nosp;
2138 merge_tlist (&tmp_list3, t, 0);
2140 t->cache_before_sp = tmp_before;
2141 t->cache_after_sp = tmp_list3;
2143 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2144 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2149 x = TREE_OPERAND (x, 0);
2156 /* For other expressions, simply recurse on their operands.
2157 Manual tail recursion for unary expressions.
2158 Other non-expressions need not be processed. */
2159 if (cl == tcc_unary)
2161 x = TREE_OPERAND (x, 0);
2165 else if (IS_EXPR_CODE_CLASS (cl))
2168 int max = TREE_OPERAND_LENGTH (x);
2169 for (lp = 0; lp < max; lp++)
2171 tmp_before = tmp_nosp = 0;
2172 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2173 merge_tlist (&tmp_nosp, tmp_before, 0);
2174 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2181 /* Try to warn for undefined behavior in EXPR due to missing sequence
2185 verify_sequence_points (tree expr)
2187 struct tlist *before_sp = 0, *after_sp = 0;
2190 save_expr_cache = 0;
2191 if (tlist_firstobj == 0)
2193 gcc_obstack_init (&tlist_obstack);
2194 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2197 verify_tree (expr, &before_sp, &after_sp, 0);
2198 warn_for_collisions (after_sp);
2199 obstack_free (&tlist_obstack, tlist_firstobj);
2202 /* Validate the expression after `case' and apply default promotions. */
2205 check_case_value (tree value)
2207 if (value == NULL_TREE)
2210 /* ??? Can we ever get nops here for a valid case value? We
2212 STRIP_TYPE_NOPS (value);
2213 /* In C++, the following is allowed:
2216 switch (...) { case i: ... }
2218 So, we try to reduce the VALUE to a constant that way. */
2219 if (c_dialect_cxx ())
2221 value = decl_constant_value (value);
2222 STRIP_TYPE_NOPS (value);
2223 value = fold (value);
2226 if (TREE_CODE (value) == INTEGER_CST)
2227 /* Promote char or short to int. */
2228 value = perform_integral_promotions (value);
2229 else if (value != error_mark_node)
2231 error ("case label does not reduce to an integer constant");
2232 value = error_mark_node;
2235 constant_expression_warning (value);
2240 /* See if the case values LOW and HIGH are in the range of the original
2241 type (i.e. before the default conversion to int) of the switch testing
2243 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2244 the type before promoting it. CASE_LOW_P is a pointer to the lower
2245 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2246 if the case is not a case range.
2247 The caller has to make sure that we are not called with NULL for
2248 CASE_LOW_P (i.e. the default case).
2249 Returns true if the case label is in range of ORIG_TYPE (saturated or
2250 untouched) or false if the label is out of range. */
2253 check_case_bounds (tree type, tree orig_type,
2254 tree *case_low_p, tree *case_high_p)
2256 tree min_value, max_value;
2257 tree case_low = *case_low_p;
2258 tree case_high = case_high_p ? *case_high_p : case_low;
2260 /* If there was a problem with the original type, do nothing. */
2261 if (orig_type == error_mark_node)
2264 min_value = TYPE_MIN_VALUE (orig_type);
2265 max_value = TYPE_MAX_VALUE (orig_type);
2267 /* Case label is less than minimum for type. */
2268 if (tree_int_cst_compare (case_low, min_value) < 0
2269 && tree_int_cst_compare (case_high, min_value) < 0)
2271 warning (0, "case label value is less than minimum value for type");
2275 /* Case value is greater than maximum for type. */
2276 if (tree_int_cst_compare (case_low, max_value) > 0
2277 && tree_int_cst_compare (case_high, max_value) > 0)
2279 warning (0, "case label value exceeds maximum value for type");
2283 /* Saturate lower case label value to minimum. */
2284 if (tree_int_cst_compare (case_high, min_value) >= 0
2285 && tree_int_cst_compare (case_low, min_value) < 0)
2287 warning (0, "lower value in case label range"
2288 " less than minimum value for type");
2289 case_low = min_value;
2292 /* Saturate upper case label value to maximum. */
2293 if (tree_int_cst_compare (case_low, max_value) <= 0
2294 && tree_int_cst_compare (case_high, max_value) > 0)
2296 warning (0, "upper value in case label range"
2297 " exceeds maximum value for type");
2298 case_high = max_value;
2301 if (*case_low_p != case_low)
2302 *case_low_p = convert (type, case_low);
2303 if (case_high_p && *case_high_p != case_high)
2304 *case_high_p = convert (type, case_high);
2309 /* Return an integer type with BITS bits of precision,
2310 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2313 c_common_type_for_size (unsigned int bits, int unsignedp)
2315 if (bits == TYPE_PRECISION (integer_type_node))
2316 return unsignedp ? unsigned_type_node : integer_type_node;
2318 if (bits == TYPE_PRECISION (signed_char_type_node))
2319 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2321 if (bits == TYPE_PRECISION (short_integer_type_node))
2322 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2324 if (bits == TYPE_PRECISION (long_integer_type_node))
2325 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2327 if (bits == TYPE_PRECISION (long_long_integer_type_node))
2328 return (unsignedp ? long_long_unsigned_type_node
2329 : long_long_integer_type_node);
2331 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2332 return (unsignedp ? widest_unsigned_literal_type_node
2333 : widest_integer_literal_type_node);
2335 if (bits <= TYPE_PRECISION (intQI_type_node))
2336 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2338 if (bits <= TYPE_PRECISION (intHI_type_node))
2339 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2341 if (bits <= TYPE_PRECISION (intSI_type_node))
2342 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2344 if (bits <= TYPE_PRECISION (intDI_type_node))
2345 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2350 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2351 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2352 and saturating if SATP is nonzero, otherwise not saturating. */
2355 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2356 int unsignedp, int satp)
2358 enum machine_mode mode;
2360 mode = unsignedp ? UQQmode : QQmode;
2362 mode = unsignedp ? UHAmode : HAmode;
2364 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2365 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2368 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2370 sorry ("GCC cannot support operators with integer types and "
2371 "fixed-point types that have too many integral and "
2372 "fractional bits together");
2376 return c_common_type_for_mode (mode, satp);
2379 /* Used for communication between c_common_type_for_mode and
2380 c_register_builtin_type. */
2381 static GTY(()) tree registered_builtin_types;
2383 /* Return a data type that has machine mode MODE.
2384 If the mode is an integer,
2385 then UNSIGNEDP selects between signed and unsigned types.
2386 If the mode is a fixed-point mode,
2387 then UNSIGNEDP selects between saturating and nonsaturating types. */
2390 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2394 if (mode == TYPE_MODE (integer_type_node))
2395 return unsignedp ? unsigned_type_node : integer_type_node;
2397 if (mode == TYPE_MODE (signed_char_type_node))
2398 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2400 if (mode == TYPE_MODE (short_integer_type_node))
2401 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2403 if (mode == TYPE_MODE (long_integer_type_node))
2404 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2406 if (mode == TYPE_MODE (long_long_integer_type_node))
2407 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2409 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2410 return unsignedp ? widest_unsigned_literal_type_node
2411 : widest_integer_literal_type_node;
2414 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2417 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2420 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2423 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2425 #if HOST_BITS_PER_WIDE_INT >= 64
2426 if (mode == TYPE_MODE (intTI_type_node))
2427 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2430 if (mode == TYPE_MODE (float_type_node))
2431 return float_type_node;
2433 if (mode == TYPE_MODE (double_type_node))
2434 return double_type_node;
2436 if (mode == TYPE_MODE (long_double_type_node))
2437 return long_double_type_node;
2439 if (mode == TYPE_MODE (void_type_node))
2440 return void_type_node;
2442 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2444 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2445 : make_signed_type (GET_MODE_PRECISION (mode)));
2447 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2449 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2450 : make_signed_type (GET_MODE_PRECISION (mode)));
2452 if (COMPLEX_MODE_P (mode))
2454 enum machine_mode inner_mode;
2457 if (mode == TYPE_MODE (complex_float_type_node))
2458 return complex_float_type_node;
2459 if (mode == TYPE_MODE (complex_double_type_node))
2460 return complex_double_type_node;
2461 if (mode == TYPE_MODE (complex_long_double_type_node))
2462 return complex_long_double_type_node;
2464 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2465 return complex_integer_type_node;
2467 inner_mode = GET_MODE_INNER (mode);
2468 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2469 if (inner_type != NULL_TREE)
2470 return build_complex_type (inner_type);
2472 else if (VECTOR_MODE_P (mode))
2474 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2475 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2476 if (inner_type != NULL_TREE)
2477 return build_vector_type_for_mode (inner_type, mode);
2480 if (mode == TYPE_MODE (dfloat32_type_node))
2481 return dfloat32_type_node;
2482 if (mode == TYPE_MODE (dfloat64_type_node))
2483 return dfloat64_type_node;
2484 if (mode == TYPE_MODE (dfloat128_type_node))
2485 return dfloat128_type_node;
2487 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2489 if (mode == TYPE_MODE (short_fract_type_node))
2490 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2491 if (mode == TYPE_MODE (fract_type_node))
2492 return unsignedp ? sat_fract_type_node : fract_type_node;
2493 if (mode == TYPE_MODE (long_fract_type_node))
2494 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2495 if (mode == TYPE_MODE (long_long_fract_type_node))
2496 return unsignedp ? sat_long_long_fract_type_node
2497 : long_long_fract_type_node;
2499 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2500 return unsignedp ? sat_unsigned_short_fract_type_node
2501 : unsigned_short_fract_type_node;
2502 if (mode == TYPE_MODE (unsigned_fract_type_node))
2503 return unsignedp ? sat_unsigned_fract_type_node
2504 : unsigned_fract_type_node;
2505 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2506 return unsignedp ? sat_unsigned_long_fract_type_node
2507 : unsigned_long_fract_type_node;
2508 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2509 return unsignedp ? sat_unsigned_long_long_fract_type_node
2510 : unsigned_long_long_fract_type_node;
2512 if (mode == TYPE_MODE (short_accum_type_node))
2513 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2514 if (mode == TYPE_MODE (accum_type_node))
2515 return unsignedp ? sat_accum_type_node : accum_type_node;
2516 if (mode == TYPE_MODE (long_accum_type_node))
2517 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2518 if (mode == TYPE_MODE (long_long_accum_type_node))
2519 return unsignedp ? sat_long_long_accum_type_node
2520 : long_long_accum_type_node;
2522 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2523 return unsignedp ? sat_unsigned_short_accum_type_node
2524 : unsigned_short_accum_type_node;
2525 if (mode == TYPE_MODE (unsigned_accum_type_node))
2526 return unsignedp ? sat_unsigned_accum_type_node
2527 : unsigned_accum_type_node;
2528 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2529 return unsignedp ? sat_unsigned_long_accum_type_node
2530 : unsigned_long_accum_type_node;
2531 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2532 return unsignedp ? sat_unsigned_long_long_accum_type_node
2533 : unsigned_long_long_accum_type_node;
2536 return unsignedp ? sat_qq_type_node : qq_type_node;
2538 return unsignedp ? sat_hq_type_node : hq_type_node;
2540 return unsignedp ? sat_sq_type_node : sq_type_node;
2542 return unsignedp ? sat_dq_type_node : dq_type_node;
2544 return unsignedp ? sat_tq_type_node : tq_type_node;
2546 if (mode == UQQmode)
2547 return unsignedp ? sat_uqq_type_node : uqq_type_node;
2548 if (mode == UHQmode)
2549 return unsignedp ? sat_uhq_type_node : uhq_type_node;
2550 if (mode == USQmode)
2551 return unsignedp ? sat_usq_type_node : usq_type_node;
2552 if (mode == UDQmode)
2553 return unsignedp ? sat_udq_type_node : udq_type_node;
2554 if (mode == UTQmode)
2555 return unsignedp ? sat_utq_type_node : utq_type_node;
2558 return unsignedp ? sat_ha_type_node : ha_type_node;
2560 return unsignedp ? sat_sa_type_node : sa_type_node;
2562 return unsignedp ? sat_da_type_node : da_type_node;
2564 return unsignedp ? sat_ta_type_node : ta_type_node;
2566 if (mode == UHAmode)
2567 return unsignedp ? sat_uha_type_node : uha_type_node;
2568 if (mode == USAmode)
2569 return unsignedp ? sat_usa_type_node : usa_type_node;
2570 if (mode == UDAmode)
2571 return unsignedp ? sat_uda_type_node : uda_type_node;
2572 if (mode == UTAmode)
2573 return unsignedp ? sat_uta_type_node : uta_type_node;
2576 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2577 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2578 return TREE_VALUE (t);
2584 c_common_unsigned_type (tree type)
2586 return c_common_signed_or_unsigned_type (1, type);
2589 /* Return a signed type the same as TYPE in other respects. */
2592 c_common_signed_type (tree type)
2594 return c_common_signed_or_unsigned_type (0, type);
2597 /* Return a type the same as TYPE except unsigned or
2598 signed according to UNSIGNEDP. */
2601 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2605 /* This block of code emulates the behavior of the old
2606 c_common_unsigned_type. In particular, it returns
2607 long_unsigned_type_node if passed a long, even when a int would
2608 have the same size. This is necessary for warnings to work
2609 correctly in archs where sizeof(int) == sizeof(long) */
2611 type1 = TYPE_MAIN_VARIANT (type);
2612 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2613 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2614 if (type1 == integer_type_node || type1 == unsigned_type_node)
2615 return unsignedp ? unsigned_type_node : integer_type_node;
2616 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2617 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2618 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2619 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2620 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
2621 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2622 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
2623 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
2624 #if HOST_BITS_PER_WIDE_INT >= 64
2625 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2626 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2628 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2629 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2630 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2631 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2632 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2633 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2634 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2635 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2637 #define C_COMMON_FIXED_TYPES(NAME) \
2638 if (type1 == short_ ## NAME ## _type_node \
2639 || type1 == unsigned_short_ ## NAME ## _type_node) \
2640 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2641 : short_ ## NAME ## _type_node; \
2642 if (type1 == NAME ## _type_node \
2643 || type1 == unsigned_ ## NAME ## _type_node) \
2644 return unsignedp ? unsigned_ ## NAME ## _type_node \
2645 : NAME ## _type_node; \
2646 if (type1 == long_ ## NAME ## _type_node \
2647 || type1 == unsigned_long_ ## NAME ## _type_node) \
2648 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2649 : long_ ## NAME ## _type_node; \
2650 if (type1 == long_long_ ## NAME ## _type_node \
2651 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2652 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2653 : long_long_ ## NAME ## _type_node;
2655 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
2656 if (type1 == NAME ## _type_node \
2657 || type1 == u ## NAME ## _type_node) \
2658 return unsignedp ? u ## NAME ## _type_node \
2659 : NAME ## _type_node;
2661 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
2662 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2663 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2664 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2665 : sat_ ## short_ ## NAME ## _type_node; \
2666 if (type1 == sat_ ## NAME ## _type_node \
2667 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2668 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2669 : sat_ ## NAME ## _type_node; \
2670 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2671 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2672 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2673 : sat_ ## long_ ## NAME ## _type_node; \
2674 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2675 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2676 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2677 : sat_ ## long_long_ ## NAME ## _type_node;
2679 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
2680 if (type1 == sat_ ## NAME ## _type_node \
2681 || type1 == sat_ ## u ## NAME ## _type_node) \
2682 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2683 : sat_ ## NAME ## _type_node;
2685 C_COMMON_FIXED_TYPES (fract);
2686 C_COMMON_FIXED_TYPES_SAT (fract);
2687 C_COMMON_FIXED_TYPES (accum);
2688 C_COMMON_FIXED_TYPES_SAT (accum);
2690 C_COMMON_FIXED_MODE_TYPES (qq);
2691 C_COMMON_FIXED_MODE_TYPES (hq);
2692 C_COMMON_FIXED_MODE_TYPES (sq);
2693 C_COMMON_FIXED_MODE_TYPES (dq);
2694 C_COMMON_FIXED_MODE_TYPES (tq);
2695 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
2696 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
2697 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
2698 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
2699 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
2700 C_COMMON_FIXED_MODE_TYPES (ha);
2701 C_COMMON_FIXED_MODE_TYPES (sa);
2702 C_COMMON_FIXED_MODE_TYPES (da);
2703 C_COMMON_FIXED_MODE_TYPES (ta);
2704 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
2705 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
2706 C_COMMON_FIXED_MODE_TYPES_SAT (da);
2707 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
2709 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2710 the precision; they have precision set to match their range, but
2711 may use a wider mode to match an ABI. If we change modes, we may
2712 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2713 the precision as well, so as to yield correct results for
2714 bit-field types. C++ does not have these separate bit-field
2715 types, and producing a signed or unsigned variant of an
2716 ENUMERAL_TYPE may cause other problems as well. */
2718 if (!INTEGRAL_TYPE_P (type)
2719 || TYPE_UNSIGNED (type) == unsignedp)
2722 #define TYPE_OK(node) \
2723 (TYPE_MODE (type) == TYPE_MODE (node) \
2724 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2725 if (TYPE_OK (signed_char_type_node))
2726 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2727 if (TYPE_OK (integer_type_node))
2728 return unsignedp ? unsigned_type_node : integer_type_node;
2729 if (TYPE_OK (short_integer_type_node))
2730 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2731 if (TYPE_OK (long_integer_type_node))
2732 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2733 if (TYPE_OK (long_long_integer_type_node))
2734 return (unsignedp ? long_long_unsigned_type_node
2735 : long_long_integer_type_node);
2736 if (TYPE_OK (widest_integer_literal_type_node))
2737 return (unsignedp ? widest_unsigned_literal_type_node
2738 : widest_integer_literal_type_node);
2740 #if HOST_BITS_PER_WIDE_INT >= 64
2741 if (TYPE_OK (intTI_type_node))
2742 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2744 if (TYPE_OK (intDI_type_node))
2745 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2746 if (TYPE_OK (intSI_type_node))
2747 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2748 if (TYPE_OK (intHI_type_node))
2749 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2750 if (TYPE_OK (intQI_type_node))
2751 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2754 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2757 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2760 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2762 /* Extended integer types of the same width as a standard type have
2763 lesser rank, so those of the same width as int promote to int or
2764 unsigned int and are valid for printf formats expecting int or
2765 unsigned int. To avoid such special cases, avoid creating
2766 extended integer types for bit-fields if a standard integer type
2768 if (width == TYPE_PRECISION (integer_type_node))
2769 return unsignedp ? unsigned_type_node : integer_type_node;
2770 if (width == TYPE_PRECISION (signed_char_type_node))
2771 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2772 if (width == TYPE_PRECISION (short_integer_type_node))
2773 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2774 if (width == TYPE_PRECISION (long_integer_type_node))
2775 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2776 if (width == TYPE_PRECISION (long_long_integer_type_node))
2777 return (unsignedp ? long_long_unsigned_type_node
2778 : long_long_integer_type_node);
2779 return build_nonstandard_integer_type (width, unsignedp);
2782 /* The C version of the register_builtin_type langhook. */
2785 c_register_builtin_type (tree type, const char* name)
2789 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2790 DECL_ARTIFICIAL (decl) = 1;
2791 if (!TYPE_NAME (type))
2792 TYPE_NAME (type) = decl;
2795 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2798 /* Print an error message for invalid operands to arith operation
2799 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
2800 LOCATION is the location of the message. */
2803 binary_op_error (location_t location, enum tree_code code,
2804 tree type0, tree type1)
2811 opname = "+"; break;
2813 opname = "-"; break;
2815 opname = "*"; break;
2817 opname = "max"; break;
2819 opname = "min"; break;
2821 opname = "=="; break;
2823 opname = "!="; break;
2825 opname = "<="; break;
2827 opname = ">="; break;
2829 opname = "<"; break;
2831 opname = ">"; break;
2833 opname = "<<"; break;
2835 opname = ">>"; break;
2836 case TRUNC_MOD_EXPR:
2837 case FLOOR_MOD_EXPR:
2838 opname = "%"; break;
2839 case TRUNC_DIV_EXPR:
2840 case FLOOR_DIV_EXPR:
2841 opname = "/"; break;
2843 opname = "&"; break;
2845 opname = "|"; break;
2846 case TRUTH_ANDIF_EXPR:
2847 opname = "&&"; break;
2848 case TRUTH_ORIF_EXPR:
2849 opname = "||"; break;
2851 opname = "^"; break;
2856 "invalid operands to binary %s (have %qT and %qT)", opname,
2860 /* Subroutine of build_binary_op, used for comparison operations.
2861 See if the operands have both been converted from subword integer types
2862 and, if so, perhaps change them both back to their original type.
2863 This function is also responsible for converting the two operands
2864 to the proper common type for comparison.
2866 The arguments of this function are all pointers to local variables
2867 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2868 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2870 If this function returns nonzero, it means that the comparison has
2871 a constant value. What this function returns is an expression for
2875 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2876 enum tree_code *rescode_ptr)
2879 tree op0 = *op0_ptr;
2880 tree op1 = *op1_ptr;
2881 int unsignedp0, unsignedp1;
2883 tree primop0, primop1;
2884 enum tree_code code = *rescode_ptr;
2886 /* Throw away any conversions to wider types
2887 already present in the operands. */
2889 primop0 = get_narrower (op0, &unsignedp0);
2890 primop1 = get_narrower (op1, &unsignedp1);
2892 /* Handle the case that OP0 does not *contain* a conversion
2893 but it *requires* conversion to FINAL_TYPE. */
2895 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2896 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2897 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2898 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2900 /* If one of the operands must be floated, we cannot optimize. */
2901 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2902 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2904 /* If first arg is constant, swap the args (changing operation
2905 so value is preserved), for canonicalization. Don't do this if
2906 the second arg is 0. */
2908 if (TREE_CONSTANT (primop0)
2909 && !integer_zerop (primop1) && !real_zerop (primop1)
2910 && !fixed_zerop (primop1))
2913 int temi = unsignedp0;
2921 unsignedp0 = unsignedp1;
2944 *rescode_ptr = code;
2947 /* If comparing an integer against a constant more bits wide,
2948 maybe we can deduce a value of 1 or 0 independent of the data.
2949 Or else truncate the constant now
2950 rather than extend the variable at run time.
2952 This is only interesting if the constant is the wider arg.
2953 Also, it is not safe if the constant is unsigned and the
2954 variable arg is signed, since in this case the variable
2955 would be sign-extended and then regarded as unsigned.
2956 Our technique fails in this case because the lowest/highest
2957 possible unsigned results don't follow naturally from the
2958 lowest/highest possible values of the variable operand.
2959 For just EQ_EXPR and NE_EXPR there is another technique that
2960 could be used: see if the constant can be faithfully represented
2961 in the other operand's type, by truncating it and reextending it
2962 and see if that preserves the constant's value. */
2964 if (!real1 && !real2
2965 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
2966 && TREE_CODE (primop1) == INTEGER_CST
2967 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2969 int min_gt, max_gt, min_lt, max_lt;
2970 tree maxval, minval;
2971 /* 1 if comparison is nominally unsigned. */
2972 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2975 type = c_common_signed_or_unsigned_type (unsignedp0,
2976 TREE_TYPE (primop0));
2978 maxval = TYPE_MAX_VALUE (type);
2979 minval = TYPE_MIN_VALUE (type);
2981 if (unsignedp && !unsignedp0)
2982 *restype_ptr = c_common_signed_type (*restype_ptr);
2984 if (TREE_TYPE (primop1) != *restype_ptr)
2986 /* Convert primop1 to target type, but do not introduce
2987 additional overflow. We know primop1 is an int_cst. */
2988 primop1 = force_fit_type_double (*restype_ptr,
2989 TREE_INT_CST_LOW (primop1),
2990 TREE_INT_CST_HIGH (primop1), 0,
2991 TREE_OVERFLOW (primop1));
2993 if (type != *restype_ptr)
2995 minval = convert (*restype_ptr, minval);
2996 maxval = convert (*restype_ptr, maxval);
2999 if (unsignedp && unsignedp0)
3001 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3002 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3003 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3004 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3008 min_gt = INT_CST_LT (primop1, minval);
3009 max_gt = INT_CST_LT (primop1, maxval);
3010 min_lt = INT_CST_LT (minval, primop1);
3011 max_lt = INT_CST_LT (maxval, primop1);
3015 /* This used to be a switch, but Genix compiler can't handle that. */
3016 if (code == NE_EXPR)
3018 if (max_lt || min_gt)
3019 val = truthvalue_true_node;
3021 else if (code == EQ_EXPR)
3023 if (max_lt || min_gt)
3024 val = truthvalue_false_node;
3026 else if (code == LT_EXPR)
3029 val = truthvalue_true_node;
3031 val = truthvalue_false_node;
3033 else if (code == GT_EXPR)
3036 val = truthvalue_true_node;
3038 val = truthvalue_false_node;
3040 else if (code == LE_EXPR)
3043 val = truthvalue_true_node;
3045 val = truthvalue_false_node;
3047 else if (code == GE_EXPR)
3050 val = truthvalue_true_node;
3052 val = truthvalue_false_node;
3055 /* If primop0 was sign-extended and unsigned comparison specd,
3056 we did a signed comparison above using the signed type bounds.
3057 But the comparison we output must be unsigned.
3059 Also, for inequalities, VAL is no good; but if the signed
3060 comparison had *any* fixed result, it follows that the
3061 unsigned comparison just tests the sign in reverse
3062 (positive values are LE, negative ones GE).
3063 So we can generate an unsigned comparison
3064 against an extreme value of the signed type. */
3066 if (unsignedp && !unsignedp0)
3073 primop1 = TYPE_MIN_VALUE (type);
3079 primop1 = TYPE_MAX_VALUE (type);
3086 type = c_common_unsigned_type (type);
3089 if (TREE_CODE (primop0) != INTEGER_CST)
3091 if (val == truthvalue_false_node)
3092 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3093 if (val == truthvalue_true_node)
3094 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3099 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3100 if (TREE_SIDE_EFFECTS (primop0))
3101 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3105 /* Value is not predetermined, but do the comparison
3106 in the type of the operand that is not constant.
3107 TYPE is already properly set. */
3110 /* If either arg is decimal float and the other is float, find the
3111 proper common type to use for comparison. */
3112 else if (real1 && real2
3113 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3114 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3115 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3117 else if (real1 && real2
3118 && (TYPE_PRECISION (TREE_TYPE (primop0))
3119 == TYPE_PRECISION (TREE_TYPE (primop1))))
3120 type = TREE_TYPE (primop0);
3122 /* If args' natural types are both narrower than nominal type
3123 and both extend in the same manner, compare them
3124 in the type of the wider arg.
3125 Otherwise must actually extend both to the nominal
3126 common type lest different ways of extending
3128 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3130 else if (unsignedp0 == unsignedp1 && real1 == real2
3131 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3132 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3134 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3135 type = c_common_signed_or_unsigned_type (unsignedp0
3136 || TYPE_UNSIGNED (*restype_ptr),
3138 /* Make sure shorter operand is extended the right way
3139 to match the longer operand. */
3141 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3142 TREE_TYPE (primop0)),
3145 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3146 TREE_TYPE (primop1)),
3151 /* Here we must do the comparison on the nominal type
3152 using the args exactly as we received them. */
3153 type = *restype_ptr;
3157 if (!real1 && !real2 && integer_zerop (primop1)
3158 && TYPE_UNSIGNED (*restype_ptr))
3164 /* All unsigned values are >= 0, so we warn. However,
3165 if OP0 is a constant that is >= 0, the signedness of
3166 the comparison isn't an issue, so suppress the
3168 if (warn_type_limits && !in_system_header
3169 && !(TREE_CODE (primop0) == INTEGER_CST
3170 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3172 warning (OPT_Wtype_limits,
3173 "comparison of unsigned expression >= 0 is always true");
3174 value = truthvalue_true_node;
3178 if (warn_type_limits && !in_system_header
3179 && !(TREE_CODE (primop0) == INTEGER_CST
3180 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3182 warning (OPT_Wtype_limits,
3183 "comparison of unsigned expression < 0 is always false");
3184 value = truthvalue_false_node;
3193 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3194 if (TREE_SIDE_EFFECTS (primop0))
3195 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3202 *op0_ptr = convert (type, primop0);
3203 *op1_ptr = convert (type, primop1);
3205 *restype_ptr = truthvalue_type_node;
3210 /* Return a tree for the sum or difference (RESULTCODE says which)
3211 of pointer PTROP and integer INTOP. */
3214 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3218 /* The result is a pointer of the same type that is being added. */
3219 tree result_type = TREE_TYPE (ptrop);
3221 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3223 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3224 "pointer of type %<void *%> used in arithmetic");
3225 size_exp = integer_one_node;
3227 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3229 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3230 "pointer to a function used in arithmetic");
3231 size_exp = integer_one_node;
3233 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3235 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3236 "pointer to member function used in arithmetic");
3237 size_exp = integer_one_node;
3240 size_exp = size_in_bytes (TREE_TYPE (result_type));
3242 /* We are manipulating pointer values, so we don't need to warn
3243 about relying on undefined signed overflow. We disable the
3244 warning here because we use integer types so fold won't know that
3245 they are really pointers. */
3246 fold_defer_overflow_warnings ();
3248 /* If what we are about to multiply by the size of the elements
3249 contains a constant term, apply distributive law
3250 and multiply that constant term separately.
3251 This helps produce common subexpressions. */
3252 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3253 && !TREE_CONSTANT (intop)
3254 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3255 && TREE_CONSTANT (size_exp)
3256 /* If the constant comes from pointer subtraction,
3257 skip this optimization--it would cause an error. */
3258 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3259 /* If the constant is unsigned, and smaller than the pointer size,
3260 then we must skip this optimization. This is because it could cause
3261 an overflow error if the constant is negative but INTOP is not. */
3262 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3263 || (TYPE_PRECISION (TREE_TYPE (intop))
3264 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3266 enum tree_code subcode = resultcode;
3267 tree int_type = TREE_TYPE (intop);
3268 if (TREE_CODE (intop) == MINUS_EXPR)
3269 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3270 /* Convert both subexpression types to the type of intop,
3271 because weird cases involving pointer arithmetic
3272 can result in a sum or difference with different type args. */
3273 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3275 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3276 intop = convert (int_type, TREE_OPERAND (intop, 0));
3279 /* Convert the integer argument to a type the same size as sizetype
3280 so the multiply won't overflow spuriously. */
3281 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3282 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3283 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3284 TYPE_UNSIGNED (sizetype)), intop);
3286 /* Replace the integer argument with a suitable product by the object size.
3287 Do this multiplication as signed, then convert to the appropriate
3288 type for the pointer operation. */
3289 intop = convert (sizetype,
3290 build_binary_op (EXPR_LOCATION (intop),
3292 convert (TREE_TYPE (intop), size_exp), 1));
3294 /* Create the sum or difference. */
3295 if (resultcode == MINUS_EXPR)
3296 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3298 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3300 fold_undefer_and_ignore_overflow_warnings ();
3305 /* Return whether EXPR is a declaration whose address can never be
3309 decl_with_nonnull_addr_p (const_tree expr)
3311 return (DECL_P (expr)
3312 && (TREE_CODE (expr) == PARM_DECL
3313 || TREE_CODE (expr) == LABEL_DECL
3314 || !DECL_WEAK (expr)));
3317 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3318 or for an `if' or `while' statement or ?..: exp. It should already
3319 have been validated to be of suitable type; otherwise, a bad
3320 diagnostic may result.
3322 The EXPR is located at LOCATION.
3324 This preparation consists of taking the ordinary
3325 representation of an expression expr and producing a valid tree
3326 boolean expression describing whether expr is nonzero. We could
3327 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3328 but we optimize comparisons, &&, ||, and !.
3330 The resulting type should always be `truthvalue_type_node'. */
3333 c_common_truthvalue_conversion (location_t location, tree expr)
3335 switch (TREE_CODE (expr))
3337 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
3338 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3339 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3340 case ORDERED_EXPR: case UNORDERED_EXPR:
3341 if (TREE_TYPE (expr) == truthvalue_type_node)
3343 return build2 (TREE_CODE (expr), truthvalue_type_node,
3344 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3346 case TRUTH_ANDIF_EXPR:
3347 case TRUTH_ORIF_EXPR:
3348 case TRUTH_AND_EXPR:
3350 case TRUTH_XOR_EXPR:
3351 if (TREE_TYPE (expr) == truthvalue_type_node)
3353 return build2 (TREE_CODE (expr), truthvalue_type_node,
3354 c_common_truthvalue_conversion (location,
3355 TREE_OPERAND (expr, 0)),
3356 c_common_truthvalue_conversion (location,
3357 TREE_OPERAND (expr, 1)));
3359 case TRUTH_NOT_EXPR:
3360 if (TREE_TYPE (expr) == truthvalue_type_node)
3362 return build1 (TREE_CODE (expr), truthvalue_type_node,
3363 c_common_truthvalue_conversion (location,
3364 TREE_OPERAND (expr, 0)));
3370 return integer_zerop (expr) ? truthvalue_false_node
3371 : truthvalue_true_node;
3374 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3375 ? truthvalue_true_node
3376 : truthvalue_false_node;
3379 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3380 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3381 ? truthvalue_true_node
3382 : truthvalue_false_node;
3385 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3390 tree inner = TREE_OPERAND (expr, 0);
3391 if (decl_with_nonnull_addr_p (inner))
3393 /* Common Ada/Pascal programmer's mistake. */
3394 warning_at (location,
3396 "the address of %qD will always evaluate as %<true%>",
3398 return truthvalue_true_node;
3404 return build_binary_op (EXPR_LOCATION (expr),
3405 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3406 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3407 c_common_truthvalue_conversion (location,
3408 TREE_OPERAND (expr, 0)),
3409 c_common_truthvalue_conversion (location,
3410 TREE_OPERAND (expr, 1)),
3416 /* These don't change whether an object is nonzero or zero. */
3417 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
3421 /* These don't change whether an object is zero or nonzero, but
3422 we can't ignore them if their second arg has side-effects. */
3423 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3424 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3425 TREE_OPERAND (expr, 1),
3426 c_common_truthvalue_conversion
3427 (location, TREE_OPERAND (expr, 0)));
3429 return c_common_truthvalue_conversion (location,
3430 TREE_OPERAND (expr, 0));
3434 tree op1 = TREE_OPERAND (expr, 1);
3435 tree op2 = TREE_OPERAND (expr, 2);
3436 /* In C++ one of the arms might have void type if it is throw. */
3437 if (!VOID_TYPE_P (TREE_TYPE (op1)))
3438 op1 = c_common_truthvalue_conversion (location, op1);
3439 if (!VOID_TYPE_P (TREE_TYPE (op2)))
3440 op2 = c_common_truthvalue_conversion (location, op2);
3441 /* Distribute the conversion into the arms of a COND_EXPR. */
3442 return fold_build3 (COND_EXPR, truthvalue_type_node,
3443 TREE_OPERAND (expr, 0), op1, op2);
3447 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3448 since that affects how `default_conversion' will behave. */
3449 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3450 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3452 /* If this is widening the argument, we can ignore it. */
3453 if (TYPE_PRECISION (TREE_TYPE (expr))
3454 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3455 return c_common_truthvalue_conversion (location,
3456 TREE_OPERAND (expr, 0));
3460 if (!TREE_NO_WARNING (expr)
3461 && warn_parentheses)
3463 warning (OPT_Wparentheses,
3464 "suggest parentheses around assignment used as truth value");
3465 TREE_NO_WARNING (expr) = 1;
3473 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3475 tree t = save_expr (expr);
3476 return (build_binary_op
3477 (EXPR_LOCATION (expr),
3478 (TREE_SIDE_EFFECTS (expr)
3479 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3480 c_common_truthvalue_conversion
3482 build_unary_op (location, REALPART_EXPR, t, 0)),
3483 c_common_truthvalue_conversion
3485 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3489 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3491 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3493 (TREE_TYPE (expr))));
3494 return build_binary_op (EXPR_LOCATION (expr),
3495 NE_EXPR, expr, fixed_zero_node, 1);
3498 return build_binary_op (EXPR_LOCATION (expr),
3499 NE_EXPR, expr, integer_zero_node, 1);
3502 static void def_builtin_1 (enum built_in_function fncode,
3504 enum built_in_class fnclass,
3505 tree fntype, tree libtype,
3506 bool both_p, bool fallback_p, bool nonansi_p,
3507 tree fnattrs, bool implicit_p);
3510 /* Apply the TYPE_QUALS to the new DECL. */
3513 c_apply_type_quals_to_decl (int type_quals, tree decl)
3515 tree type = TREE_TYPE (decl);
3517 if (type == error_mark_node)
3520 if (((type_quals & TYPE_QUAL_CONST)
3521 || (type && TREE_CODE (type) == REFERENCE_TYPE))
3522 /* An object declared 'const' is only readonly after it is
3523 initialized. We don't have any way of expressing this currently,
3524 so we need to be conservative and unset TREE_READONLY for types
3525 with constructors. Otherwise aliasing code will ignore stores in
3526 an inline constructor. */
3527 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3528 TREE_READONLY (decl) = 1;
3529 if (type_quals & TYPE_QUAL_VOLATILE)
3531 TREE_SIDE_EFFECTS (decl) = 1;
3532 TREE_THIS_VOLATILE (decl) = 1;
3534 if (type_quals & TYPE_QUAL_RESTRICT)
3536 while (type && TREE_CODE (type) == ARRAY_TYPE)
3537 /* Allow 'restrict' on arrays of pointers.
3538 FIXME currently we just ignore it. */
3539 type = TREE_TYPE (type);
3541 || !POINTER_TYPE_P (type)
3542 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3543 error ("invalid use of %<restrict%>");
3544 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3545 /* Indicate we need to make a unique alias set for this pointer.
3546 We can't do it here because it might be pointing to an
3548 DECL_POINTER_ALIAS_SET (decl) = -2;
3552 /* Hash function for the problem of multiple type definitions in
3553 different files. This must hash all types that will compare
3554 equal via comptypes to the same value. In practice it hashes
3555 on some of the simple stuff and leaves the details to comptypes. */
3558 c_type_hash (const void *p)
3562 const_tree const t = (const_tree) p;
3564 switch (TREE_CODE (t))
3566 /* For pointers, hash on pointee type plus some swizzling. */
3568 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3569 /* Hash on number of elements and total size. */
3572 t2 = TYPE_VALUES (t);
3576 t2 = TYPE_FIELDS (t);
3578 case QUAL_UNION_TYPE:
3580 t2 = TYPE_FIELDS (t);
3584 t2 = TYPE_FIELDS (t);
3589 for (; t2; t2 = TREE_CHAIN (t2))
3591 /* We might have a VLA here. */
3592 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
3595 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3596 return ((size << 24) | (i << shift));
3599 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3601 /* Return the typed-based alias set for T, which may be an expression
3602 or a type. Return -1 if we don't do anything special. */
3605 c_common_get_alias_set (tree t)
3610 /* Permit type-punning when accessing a union, provided the access
3611 is directly through the union. For example, this code does not
3612 permit taking the address of a union member and then storing
3613 through it. Even the type-punning allowed here is a GCC
3614 extension, albeit a common and useful one; the C standard says
3615 that such accesses have implementation-defined behavior. */
3617 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3618 u = TREE_OPERAND (u, 0))
3619 if (TREE_CODE (u) == COMPONENT_REF
3620 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3623 /* That's all the expressions we handle specially. */
3627 /* The C standard guarantees that any object may be accessed via an
3628 lvalue that has character type. */
3629 if (t == char_type_node
3630 || t == signed_char_type_node
3631 || t == unsigned_char_type_node)
3634 /* The C standard specifically allows aliasing between signed and
3635 unsigned variants of the same type. We treat the signed
3636 variant as canonical. */
3637 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3639 tree t1 = c_common_signed_type (t);
3641 /* t1 == t can happen for boolean nodes which are always unsigned. */
3643 return get_alias_set (t1);
3645 else if (POINTER_TYPE_P (t))
3649 /* Unfortunately, there is no canonical form of a pointer type.
3650 In particular, if we have `typedef int I', then `int *', and
3651 `I *' are different types. So, we have to pick a canonical
3652 representative. We do this below.
3654 Technically, this approach is actually more conservative that
3655 it needs to be. In particular, `const int *' and `int *'
3656 should be in different alias sets, according to the C and C++
3657 standard, since their types are not the same, and so,
3658 technically, an `int **' and `const int **' cannot point at
3661 But, the standard is wrong. In particular, this code is
3666 const int* const* cipp = ipp;
3668 And, it doesn't make sense for that to be legal unless you
3669 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3670 the pointed-to types. This issue has been reported to the
3672 t1 = build_type_no_quals (t);
3674 return get_alias_set (t1);
3677 /* Handle the case of multiple type nodes referring to "the same" type,
3678 which occurs with IMA. These share an alias set. FIXME: Currently only
3679 C90 is handled. (In C99 type compatibility is not transitive, which
3680 complicates things mightily. The alias set splay trees can theoretically
3681 represent this, but insertion is tricky when you consider all the
3682 different orders things might arrive in.) */
3684 if (c_language != clk_c || flag_isoc99)
3687 /* Save time if there's only one input file. */
3688 if (num_in_fnames == 1)
3691 /* Pointers need special handling if they point to any type that
3692 needs special handling (below). */
3693 if (TREE_CODE (t) == POINTER_TYPE)
3696 /* Find bottom type under any nested POINTERs. */
3697 for (t2 = TREE_TYPE (t);
3698 TREE_CODE (t2) == POINTER_TYPE;
3699 t2 = TREE_TYPE (t2))
3701 if (TREE_CODE (t2) != RECORD_TYPE
3702 && TREE_CODE (t2) != ENUMERAL_TYPE
3703 && TREE_CODE (t2) != QUAL_UNION_TYPE
3704 && TREE_CODE (t2) != UNION_TYPE)
3706 if (TYPE_SIZE (t2) == 0)
3709 /* These are the only cases that need special handling. */
3710 if (TREE_CODE (t) != RECORD_TYPE
3711 && TREE_CODE (t) != ENUMERAL_TYPE
3712 && TREE_CODE (t) != QUAL_UNION_TYPE
3713 && TREE_CODE (t) != UNION_TYPE
3714 && TREE_CODE (t) != POINTER_TYPE)
3717 if (TYPE_SIZE (t) == 0)
3720 /* Look up t in hash table. Only one of the compatible types within each
3721 alias set is recorded in the table. */
3722 if (!type_hash_table)
3723 type_hash_table = htab_create_ggc (1021, c_type_hash,
3724 (htab_eq) lang_hooks.types_compatible_p,
3726 slot = htab_find_slot (type_hash_table, t, INSERT);
3729 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3730 return TYPE_ALIAS_SET ((tree)*slot);
3733 /* Our caller will assign and record (in t) a new alias set; all we need
3734 to do is remember t in the hash table. */
3740 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3741 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3742 flag controls whether we should diagnose possibly ill-formed
3743 constructs or not. */
3746 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3748 const char *op_name;
3750 enum tree_code type_code = TREE_CODE (type);
3752 op_name = is_sizeof ? "sizeof" : "__alignof__";
3754 if (type_code == FUNCTION_TYPE)
3758 if (complain && (pedantic || warn_pointer_arith))
3759 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3760 "invalid application of %<sizeof%> to a function type");
3762 return error_mark_node;
3763 value = size_one_node;
3766 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3768 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3770 if (type_code == VOID_TYPE
3771 && complain && (pedantic || warn_pointer_arith))
3772 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3773 "invalid application of %qs to a void type", op_name);
3775 return error_mark_node;
3776 value = size_one_node;
3778 else if (!COMPLETE_TYPE_P (type))
3781 error ("invalid application of %qs to incomplete type %qT ",
3783 value = size_zero_node;
3788 /* Convert in case a char is more than one unit. */
3789 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3790 size_int (TYPE_PRECISION (char_type_node)
3793 value = size_int (TYPE_ALIGN_UNIT (type));
3796 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3797 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3798 never happen. However, this node should really have type
3799 `size_t', which is just a typedef for an ordinary integer type. */
3800 value = fold_convert (size_type_node, value);
3801 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3806 /* Implement the __alignof keyword: Return the minimum required
3807 alignment of EXPR, measured in bytes. For VAR_DECLs,
3808 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3809 from an "aligned" __attribute__ specification). */
3812 c_alignof_expr (tree expr)
3816 if (VAR_OR_FUNCTION_DECL_P (expr))
3817 t = size_int (DECL_ALIGN_UNIT (expr));
3819 else if (TREE_CODE (expr) == COMPONENT_REF
3820 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3822 error ("%<__alignof%> applied to a bit-field");
3825 else if (TREE_CODE (expr) == COMPONENT_REF
3826 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3827 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3829 else if (TREE_CODE (expr) == INDIRECT_REF)
3831 tree t = TREE_OPERAND (expr, 0);
3833 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3835 while (CONVERT_EXPR_P (t)
3836 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3840 t = TREE_OPERAND (t, 0);
3841 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3842 if (thisalign > bestalign)
3843 best = t, bestalign = thisalign;
3845 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3848 return c_alignof (TREE_TYPE (expr));
3850 return fold_convert (size_type_node, t);
3853 /* Handle C and C++ default attributes. */
3855 enum built_in_attribute
3857 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3858 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3859 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3860 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3861 #include "builtin-attrs.def"
3862 #undef DEF_ATTR_NULL_TREE
3864 #undef DEF_ATTR_IDENT
3865 #undef DEF_ATTR_TREE_LIST
3869 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3871 static void c_init_attributes (void);
3875 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3876 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3877 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3878 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3879 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3880 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3881 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3882 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3883 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3884 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3885 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3886 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3887 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3888 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3889 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3891 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3892 #include "builtin-types.def"
3893 #undef DEF_PRIMITIVE_TYPE
3894 #undef DEF_FUNCTION_TYPE_0
3895 #undef DEF_FUNCTION_TYPE_1
3896 #undef DEF_FUNCTION_TYPE_2
3897 #undef DEF_FUNCTION_TYPE_3
3898 #undef DEF_FUNCTION_TYPE_4
3899 #undef DEF_FUNCTION_TYPE_5
3900 #undef DEF_FUNCTION_TYPE_6
3901 #undef DEF_FUNCTION_TYPE_7
3902 #undef DEF_FUNCTION_TYPE_VAR_0
3903 #undef DEF_FUNCTION_TYPE_VAR_1
3904 #undef DEF_FUNCTION_TYPE_VAR_2
3905 #undef DEF_FUNCTION_TYPE_VAR_3
3906 #undef DEF_FUNCTION_TYPE_VAR_4
3907 #undef DEF_FUNCTION_TYPE_VAR_5
3908 #undef DEF_POINTER_TYPE
3912 typedef enum c_builtin_type builtin_type;
3914 /* A temporary array for c_common_nodes_and_builtins. Used in
3915 communication with def_fn_type. */
3916 static tree builtin_types[(int) BT_LAST + 1];
3918 /* A helper function for c_common_nodes_and_builtins. Build function type
3919 for DEF with return type RET and N arguments. If VAR is true, then the
3920 function should be variadic after those N arguments.
3922 Takes special care not to ICE if any of the types involved are
3923 error_mark_node, which indicates that said type is not in fact available
3924 (see builtin_type_for_size). In which case the function type as a whole
3925 should be error_mark_node. */
3928 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3930 tree args = NULL, t;
3935 for (i = 0; i < n; ++i)
3937 builtin_type a = (builtin_type) va_arg (list, int);
3938 t = builtin_types[a];
3939 if (t == error_mark_node)
3941 args = tree_cons (NULL_TREE, t, args);
3945 args = nreverse (args);
3947 args = chainon (args, void_list_node);
3949 t = builtin_types[ret];
3950 if (t == error_mark_node)
3952 t = build_function_type (t, args);
3955 builtin_types[def] = t;
3958 /* Build builtin functions common to both C and C++ language
3962 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3964 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3965 builtin_types[ENUM] = VALUE;
3966 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3967 def_fn_type (ENUM, RETURN, 0, 0);
3968 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3969 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3970 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3971 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3972 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3973 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3974 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3975 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3976 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3977 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3978 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3980 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3981 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3983 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3984 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3985 def_fn_type (ENUM, RETURN, 1, 0);
3986 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3987 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3988 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3989 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3990 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3991 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3992 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3993 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3994 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3995 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3996 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3997 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3999 #include "builtin-types.def"
4001 #undef DEF_PRIMITIVE_TYPE
4002 #undef DEF_FUNCTION_TYPE_1
4003 #undef DEF_FUNCTION_TYPE_2
4004 #undef DEF_FUNCTION_TYPE_3
4005 #undef DEF_FUNCTION_TYPE_4
4006 #undef DEF_FUNCTION_TYPE_5
4007 #undef DEF_FUNCTION_TYPE_6
4008 #undef DEF_FUNCTION_TYPE_VAR_0
4009 #undef DEF_FUNCTION_TYPE_VAR_1
4010 #undef DEF_FUNCTION_TYPE_VAR_2
4011 #undef DEF_FUNCTION_TYPE_VAR_3
4012 #undef DEF_FUNCTION_TYPE_VAR_4
4013 #undef DEF_FUNCTION_TYPE_VAR_5
4014 #undef DEF_POINTER_TYPE
4015 builtin_types[(int) BT_LAST] = NULL_TREE;
4017 c_init_attributes ();
4019 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4020 NONANSI_P, ATTRS, IMPLICIT, COND) \
4022 def_builtin_1 (ENUM, NAME, CLASS, \
4023 builtin_types[(int) TYPE], \
4024 builtin_types[(int) LIBTYPE], \
4025 BOTH_P, FALLBACK_P, NONANSI_P, \
4026 built_in_attributes[(int) ATTRS], IMPLICIT);
4027 #include "builtins.def"
4030 targetm.init_builtins ();
4032 build_common_builtin_nodes ();
4038 /* Build tree nodes and builtin functions common to both C and C++ language
4042 c_common_nodes_and_builtins (void)
4044 int char16_type_size;
4045 int char32_type_size;
4046 int wchar_type_size;
4047 tree array_domain_type;
4048 tree va_list_ref_type_node;
4049 tree va_list_arg_type_node;
4051 /* Define `int' and `char' first so that dbx will output them first. */
4052 record_builtin_type (RID_INT, NULL, integer_type_node);
4053 record_builtin_type (RID_CHAR, "char", char_type_node);
4055 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4056 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4057 but not C. Are the conditionals here needed? */
4058 if (c_dialect_cxx ())
4059 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4060 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4061 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4062 record_builtin_type (RID_MAX, "long unsigned int",
4063 long_unsigned_type_node);
4064 if (c_dialect_cxx ())
4065 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4066 record_builtin_type (RID_MAX, "long long int",
4067 long_long_integer_type_node);
4068 record_builtin_type (RID_MAX, "long long unsigned int",
4069 long_long_unsigned_type_node);
4070 if (c_dialect_cxx ())
4071 record_builtin_type (RID_MAX, "long long unsigned",
4072 long_long_unsigned_type_node);
4073 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4074 record_builtin_type (RID_MAX, "short unsigned int",
4075 short_unsigned_type_node);
4076 if (c_dialect_cxx ())
4077 record_builtin_type (RID_MAX, "unsigned short",
4078 short_unsigned_type_node);
4080 /* Define both `signed char' and `unsigned char'. */
4081 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4082 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4084 /* These are types that c_common_type_for_size and
4085 c_common_type_for_mode use. */
4086 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4088 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4090 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4092 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4094 #if HOST_BITS_PER_WIDE_INT >= 64
4095 if (targetm.scalar_mode_supported_p (TImode))
4096 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4097 get_identifier ("__int128_t"),
4100 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4101 unsigned_intQI_type_node));
4102 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4103 unsigned_intHI_type_node));
4104 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4105 unsigned_intSI_type_node));
4106 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4107 unsigned_intDI_type_node));
4108 #if HOST_BITS_PER_WIDE_INT >= 64
4109 if (targetm.scalar_mode_supported_p (TImode))
4110 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4111 get_identifier ("__uint128_t"),
4112 unsigned_intTI_type_node));
4115 /* Create the widest literal types. */
4116 widest_integer_literal_type_node
4117 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4118 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4119 widest_integer_literal_type_node));
4121 widest_unsigned_literal_type_node
4122 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4123 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4124 widest_unsigned_literal_type_node));
4126 /* `unsigned long' is the standard type for sizeof.
4127 Note that stddef.h uses `unsigned long',
4128 and this must agree, even if long and int are the same size. */
4130 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4131 signed_size_type_node = c_common_signed_type (size_type_node);
4132 set_sizetype (size_type_node);
4135 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4137 build_common_tree_nodes_2 (flag_short_double);
4139 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4140 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4141 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4143 /* Only supported decimal floating point extension if the target
4144 actually supports underlying modes. */
4145 if (targetm.scalar_mode_supported_p (SDmode)
4146 && targetm.scalar_mode_supported_p (DDmode)
4147 && targetm.scalar_mode_supported_p (TDmode))
4149 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4150 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4151 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4154 if (targetm.fixed_point_supported_p ())
4156 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4157 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4158 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4159 record_builtin_type (RID_MAX, "long long _Fract",
4160 long_long_fract_type_node);
4161 record_builtin_type (RID_MAX, "unsigned short _Fract",
4162 unsigned_short_fract_type_node);
4163 record_builtin_type (RID_MAX, "unsigned _Fract",
4164 unsigned_fract_type_node);
4165 record_builtin_type (RID_MAX, "unsigned long _Fract",
4166 unsigned_long_fract_type_node);
4167 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4168 unsigned_long_long_fract_type_node);
4169 record_builtin_type (RID_MAX, "_Sat short _Fract",
4170 sat_short_fract_type_node);
4171 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4172 record_builtin_type (RID_MAX, "_Sat long _Fract",
4173 sat_long_fract_type_node);
4174 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4175 sat_long_long_fract_type_node);
4176 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4177 sat_unsigned_short_fract_type_node);
4178 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4179 sat_unsigned_fract_type_node);
4180 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4181 sat_unsigned_long_fract_type_node);
4182 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4183 sat_unsigned_long_long_fract_type_node);
4184 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4185 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4186 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4187 record_builtin_type (RID_MAX, "long long _Accum",
4188 long_long_accum_type_node);
4189 record_builtin_type (RID_MAX, "unsigned short _Accum",
4190 unsigned_short_accum_type_node);
4191 record_builtin_type (RID_MAX, "unsigned _Accum",
4192 unsigned_accum_type_node);
4193 record_builtin_type (RID_MAX, "unsigned long _Accum",
4194 unsigned_long_accum_type_node);
4195 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4196 unsigned_long_long_accum_type_node);
4197 record_builtin_type (RID_MAX, "_Sat short _Accum",
4198 sat_short_accum_type_node);
4199 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4200 record_builtin_type (RID_MAX, "_Sat long _Accum",
4201 sat_long_accum_type_node);
4202 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4203 sat_long_long_accum_type_node);
4204 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4205 sat_unsigned_short_accum_type_node);
4206 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4207 sat_unsigned_accum_type_node);
4208 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4209 sat_unsigned_long_accum_type_node);
4210 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4211 sat_unsigned_long_long_accum_type_node);
4215 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4216 get_identifier ("complex int"),
4217 complex_integer_type_node));
4218 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4219 get_identifier ("complex float"),
4220 complex_float_type_node));
4221 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4222 get_identifier ("complex double"),
4223 complex_double_type_node));
4224 lang_hooks.decls.pushdecl
4225 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4226 complex_long_double_type_node));
4228 if (c_dialect_cxx ())
4229 /* For C++, make fileptr_type_node a distinct void * type until
4230 FILE type is defined. */
4231 fileptr_type_node = build_variant_type_copy (ptr_type_node);
4233 record_builtin_type (RID_VOID, NULL, void_type_node);
4235 /* Set the TYPE_NAME for any variants that were built before
4236 record_builtin_type gave names to the built-in types. */
4238 tree void_name = TYPE_NAME (void_type_node);
4239 TYPE_NAME (void_type_node) = NULL_TREE;
4240 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4242 TYPE_NAME (void_type_node) = void_name;
4245 /* This node must not be shared. */
4246 void_zero_node = make_node (INTEGER_CST);
4247 TREE_TYPE (void_zero_node) = void_type_node;
4249 void_list_node = build_void_list_node ();
4251 /* Make a type to be the domain of a few array types
4252 whose domains don't really matter.
4253 200 is small enough that it always fits in size_t
4254 and large enough that it can hold most function names for the
4255 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4256 array_domain_type = build_index_type (size_int (200));
4258 /* Make a type for arrays of characters.
4259 With luck nothing will ever really depend on the length of this
4261 char_array_type_node
4262 = build_array_type (char_type_node, array_domain_type);
4264 /* Likewise for arrays of ints. */
4266 = build_array_type (integer_type_node, array_domain_type);
4268 string_type_node = build_pointer_type (char_type_node);
4269 const_string_type_node
4270 = build_pointer_type (build_qualified_type
4271 (char_type_node, TYPE_QUAL_CONST));
4273 /* This is special for C++ so functions can be overloaded. */
4274 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4275 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4276 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4277 if (c_dialect_cxx ())
4279 if (TYPE_UNSIGNED (wchar_type_node))
4280 wchar_type_node = make_unsigned_type (wchar_type_size);
4282 wchar_type_node = make_signed_type (wchar_type_size);
4283 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4287 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
4288 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
4291 /* This is for wide string constants. */
4292 wchar_array_type_node
4293 = build_array_type (wchar_type_node, array_domain_type);
4295 /* Define 'char16_t'. */
4296 char16_type_node = get_identifier (CHAR16_TYPE);
4297 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4298 char16_type_size = TYPE_PRECISION (char16_type_node);
4299 if (c_dialect_cxx ())
4301 char16_type_node = make_unsigned_type (char16_type_size);
4303 if (cxx_dialect == cxx0x)
4304 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4307 /* This is for UTF-16 string constants. */
4308 char16_array_type_node
4309 = build_array_type (char16_type_node, array_domain_type);
4311 /* Define 'char32_t'. */
4312 char32_type_node = get_identifier (CHAR32_TYPE);
4313 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4314 char32_type_size = TYPE_PRECISION (char32_type_node);
4315 if (c_dialect_cxx ())
4317 char32_type_node = make_unsigned_type (char32_type_size);
4319 if (cxx_dialect == cxx0x)
4320 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4323 /* This is for UTF-32 string constants. */
4324 char32_array_type_node
4325 = build_array_type (char32_type_node, array_domain_type);
4328 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4331 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4333 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4335 default_function_type = build_function_type (integer_type_node, NULL_TREE);
4337 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
4338 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
4340 lang_hooks.decls.pushdecl
4341 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
4342 va_list_type_node));
4343 #ifdef TARGET_ENUM_VA_LIST
4348 for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
4350 lang_hooks.decls.pushdecl
4351 (build_decl (TYPE_DECL, get_identifier (pname),
4358 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4360 va_list_arg_type_node = va_list_ref_type_node =
4361 build_pointer_type (TREE_TYPE (va_list_type_node));
4365 va_list_arg_type_node = va_list_type_node;
4366 va_list_ref_type_node = build_reference_type (va_list_type_node);
4369 if (!flag_preprocess_only)
4370 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4372 main_identifier_node = get_identifier ("main");
4374 /* Create the built-in __null node. It is important that this is
4376 null_node = make_node (INTEGER_CST);
4377 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
4379 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4380 memset (builtin_types, 0, sizeof (builtin_types));
4383 /* Look up the function in built_in_decls that corresponds to DECL
4384 and set ASMSPEC as its user assembler name. DECL must be a
4385 function decl that declares a builtin. */
4388 set_builtin_user_assembler_name (tree decl, const char *asmspec)
4391 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
4392 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
4395 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
4396 set_user_assembler_name (builtin, asmspec);
4397 switch (DECL_FUNCTION_CODE (decl))
4399 case BUILT_IN_MEMCPY:
4400 init_block_move_fn (asmspec);
4401 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
4403 case BUILT_IN_MEMSET:
4404 init_block_clear_fn (asmspec);
4405 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
4407 case BUILT_IN_MEMMOVE:
4408 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
4410 case BUILT_IN_MEMCMP:
4411 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
4413 case BUILT_IN_ABORT:
4414 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
4421 /* The number of named compound-literals generated thus far. */
4422 static GTY(()) int compound_literal_number;
4424 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4427 set_compound_literal_name (tree decl)
4430 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4431 compound_literal_number);
4432 compound_literal_number++;
4433 DECL_NAME (decl) = get_identifier (name);
4437 build_va_arg (tree expr, tree type)
4439 return build1 (VA_ARG_EXPR, type, expr);
4443 /* Linked list of disabled built-in functions. */
4445 typedef struct disabled_builtin
4448 struct disabled_builtin *next;
4450 static disabled_builtin *disabled_builtins = NULL;
4452 static bool builtin_function_disabled_p (const char *);
4454 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4455 begins with "__builtin_", give an error. */
4458 disable_builtin_function (const char *name)
4460 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4461 error ("cannot disable built-in function %qs", name);
4464 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4465 new_disabled_builtin->name = name;
4466 new_disabled_builtin->next = disabled_builtins;
4467 disabled_builtins = new_disabled_builtin;
4472 /* Return true if the built-in function NAME has been disabled, false
4476 builtin_function_disabled_p (const char *name)
4478 disabled_builtin *p;
4479 for (p = disabled_builtins; p != NULL; p = p->next)
4481 if (strcmp (name, p->name) == 0)
4488 /* Worker for DEF_BUILTIN.
4489 Possibly define a builtin function with one or two names.
4490 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4491 nonansi_p and flag_no_nonansi_builtin. */
4494 def_builtin_1 (enum built_in_function fncode,
4496 enum built_in_class fnclass,
4497 tree fntype, tree libtype,
4498 bool both_p, bool fallback_p, bool nonansi_p,
4499 tree fnattrs, bool implicit_p)
4502 const char *libname;
4504 if (fntype == error_mark_node)
4507 gcc_assert ((!both_p && !fallback_p)
4508 || !strncmp (name, "__builtin_",
4509 strlen ("__builtin_")));
4511 libname = name + strlen ("__builtin_");
4512 decl = add_builtin_function (name, fntype, fncode, fnclass,
4513 (fallback_p ? libname : NULL),
4516 && !flag_no_builtin && !builtin_function_disabled_p (libname)
4517 && !(nonansi_p && flag_no_nonansi_builtin))
4518 add_builtin_function (libname, libtype, fncode, fnclass,
4521 built_in_decls[(int) fncode] = decl;
4523 implicit_built_in_decls[(int) fncode] = decl;
4526 /* Nonzero if the type T promotes to int. This is (nearly) the
4527 integral promotions defined in ISO C99 6.3.1.1/2. */
4530 c_promoting_integer_type_p (const_tree t)
4532 switch (TREE_CODE (t))
4535 return (TYPE_MAIN_VARIANT (t) == char_type_node
4536 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
4537 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
4538 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
4539 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
4540 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
4543 /* ??? Technically all enumerations not larger than an int
4544 promote to an int. But this is used along code paths
4545 that only want to notice a size change. */
4546 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
4556 /* Return 1 if PARMS specifies a fixed number of parameters
4557 and none of their types is affected by default promotions. */
4560 self_promoting_args_p (const_tree parms)
4563 for (t = parms; t; t = TREE_CHAIN (t))
4565 tree type = TREE_VALUE (t);
4567 if (type == error_mark_node)
4570 if (TREE_CHAIN (t) == 0 && type != void_type_node)
4576 if (TYPE_MAIN_VARIANT (type) == float_type_node)
4579 if (c_promoting_integer_type_p (type))
4585 /* Recursively remove any '*' or '&' operator from TYPE. */
4587 strip_pointer_operator (tree t)
4589 while (POINTER_TYPE_P (t))
4594 /* Recursively remove pointer or array type from TYPE. */
4596 strip_pointer_or_array_types (tree t)
4598 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
4603 /* Used to compare case labels. K1 and K2 are actually tree nodes
4604 representing case labels, or NULL_TREE for a `default' label.
4605 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4606 K2, and 0 if K1 and K2 are equal. */
4609 case_compare (splay_tree_key k1, splay_tree_key k2)
4611 /* Consider a NULL key (such as arises with a `default' label) to be
4612 smaller than anything else. */
4618 return tree_int_cst_compare ((tree) k1, (tree) k2);
4621 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4622 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4623 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4624 case label was declared using the usual C/C++ syntax, rather than
4625 the GNU case range extension. CASES is a tree containing all the
4626 case ranges processed so far; COND is the condition for the
4627 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
4628 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
4631 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
4632 tree low_value, tree high_value)
4637 splay_tree_node node;
4639 /* Create the LABEL_DECL itself. */
4640 label = create_artificial_label ();
4642 /* If there was an error processing the switch condition, bail now
4643 before we get more confused. */
4644 if (!cond || cond == error_mark_node)
4647 if ((low_value && TREE_TYPE (low_value)
4648 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4649 || (high_value && TREE_TYPE (high_value)
4650 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4652 error ("pointers are not permitted as case values");
4656 /* Case ranges are a GNU extension. */
4658 pedwarn (input_location, OPT_pedantic,
4659 "range expressions in switch statements are non-standard");
4661 type = TREE_TYPE (cond);
4664 low_value = check_case_value (low_value);
4665 low_value = convert_and_check (type, low_value);
4666 if (low_value == error_mark_node)
4671 high_value = check_case_value (high_value);
4672 high_value = convert_and_check (type, high_value);
4673 if (high_value == error_mark_node)
4677 if (low_value && high_value)
4679 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4680 really a case range, even though it was written that way.
4681 Remove the HIGH_VALUE to simplify later processing. */
4682 if (tree_int_cst_equal (low_value, high_value))
4683 high_value = NULL_TREE;
4684 else if (!tree_int_cst_lt (low_value, high_value))
4685 warning (0, "empty range specified");
4688 /* See if the case is in range of the type of the original testing
4689 expression. If both low_value and high_value are out of range,
4690 don't insert the case label and return NULL_TREE. */
4692 && !check_case_bounds (type, orig_type,
4693 &low_value, high_value ? &high_value : NULL))
4696 /* Look up the LOW_VALUE in the table of case labels we already
4698 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4699 /* If there was not an exact match, check for overlapping ranges.
4700 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4701 that's a `default' label and the only overlap is an exact match. */
4702 if (!node && (low_value || high_value))
4704 splay_tree_node low_bound;
4705 splay_tree_node high_bound;
4707 /* Even though there wasn't an exact match, there might be an
4708 overlap between this case range and another case range.
4709 Since we've (inductively) not allowed any overlapping case
4710 ranges, we simply need to find the greatest low case label
4711 that is smaller that LOW_VALUE, and the smallest low case
4712 label that is greater than LOW_VALUE. If there is an overlap
4713 it will occur in one of these two ranges. */
4714 low_bound = splay_tree_predecessor (cases,
4715 (splay_tree_key) low_value);
4716 high_bound = splay_tree_successor (cases,
4717 (splay_tree_key) low_value);
4719 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4720 the LOW_VALUE, so there is no need to check unless the
4721 LOW_BOUND is in fact itself a case range. */
4723 && CASE_HIGH ((tree) low_bound->value)
4724 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4727 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4728 range is bigger than the low end of the current range, so we
4729 are only interested if the current range is a real range, and
4730 not an ordinary case label. */
4733 && (tree_int_cst_compare ((tree) high_bound->key,
4738 /* If there was an overlap, issue an error. */
4741 tree duplicate = CASE_LABEL ((tree) node->value);
4745 error ("duplicate (or overlapping) case value");
4746 error ("%Jthis is the first entry overlapping that value", duplicate);
4750 error ("duplicate case value") ;
4751 error ("%Jpreviously used here", duplicate);
4755 error ("multiple default labels in one switch");
4756 error ("%Jthis is the first default label", duplicate);
4761 /* Add a CASE_LABEL to the statement-tree. */
4762 case_label = add_stmt (build_case_label (low_value, high_value, label));
4763 /* Register this case label in the splay tree. */
4764 splay_tree_insert (cases,
4765 (splay_tree_key) low_value,
4766 (splay_tree_value) case_label);
4771 /* Add a label so that the back-end doesn't think that the beginning of
4772 the switch is unreachable. Note that we do not add a case label, as
4773 that just leads to duplicates and thence to failure later on. */
4776 tree t = create_artificial_label ();
4777 add_stmt (build_stmt (LABEL_EXPR, t));
4779 return error_mark_node;
4782 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4783 Used to verify that case values match up with enumerator values. */
4786 match_case_to_enum_1 (tree key, tree type, tree label)
4788 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4790 /* ??? Not working too hard to print the double-word value.
4791 Should perhaps be done with %lwd in the diagnostic routines? */
4792 if (TREE_INT_CST_HIGH (key) == 0)
4793 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4794 TREE_INT_CST_LOW (key));
4795 else if (!TYPE_UNSIGNED (type)
4796 && TREE_INT_CST_HIGH (key) == -1
4797 && TREE_INT_CST_LOW (key) != 0)
4798 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4799 -TREE_INT_CST_LOW (key));
4801 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4802 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
4803 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
4805 if (TYPE_NAME (type) == 0)
4806 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4807 "%Jcase value %qs not in enumerated type",
4808 CASE_LABEL (label), buf);
4810 warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4811 "%Jcase value %qs not in enumerated type %qT",
4812 CASE_LABEL (label), buf, type);
4815 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4816 Used to verify that case values match up with enumerator values. */
4819 match_case_to_enum (splay_tree_node node, void *data)
4821 tree label = (tree) node->value;
4822 tree type = (tree) data;
4824 /* Skip default case. */
4825 if (!CASE_LOW (label))
4828 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4829 when we did our enum->case scan. Reset our scratch bit after. */
4830 if (!CASE_LOW_SEEN (label))
4831 match_case_to_enum_1 (CASE_LOW (label), type, label);
4833 CASE_LOW_SEEN (label) = 0;
4835 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4836 not set, that means that CASE_HIGH did not appear when we did our
4837 enum->case scan. Reset our scratch bit after. */
4838 if (CASE_HIGH (label))
4840 if (!CASE_HIGH_SEEN (label))
4841 match_case_to_enum_1 (CASE_HIGH (label), type, label);
4843 CASE_HIGH_SEEN (label) = 0;
4849 /* Handle -Wswitch*. Called from the front end after parsing the
4850 switch construct. */
4851 /* ??? Should probably be somewhere generic, since other languages
4852 besides C and C++ would want this. At the moment, however, C/C++
4853 are the only tree-ssa languages that support enumerations at all,
4854 so the point is moot. */
4857 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4858 tree type, tree cond)
4860 splay_tree_node default_node;
4861 splay_tree_node node;
4863 int saved_warn_switch;
4865 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4868 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4870 warning (OPT_Wswitch_default, "%Hswitch missing default case",
4873 /* From here on, we only care about about enumerated types. */
4874 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4877 /* If the switch expression was an enumerated type, check that
4878 exactly all enumeration literals are covered by the cases.
4879 The check is made when -Wswitch was specified and there is no
4880 default case, or when -Wswitch-enum was specified. */
4882 if (!warn_switch_enum
4883 && !(warn_switch && !default_node))
4886 /* Clearing COND if it is not an integer constant simplifies
4887 the tests inside the loop below. */
4888 if (TREE_CODE (cond) != INTEGER_CST)
4891 /* The time complexity here is O(N*lg(N)) worst case, but for the
4892 common case of monotonically increasing enumerators, it is
4893 O(N), since the nature of the splay tree will keep the next
4894 element adjacent to the root at all times. */
4896 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4898 tree value = TREE_VALUE (chain);
4899 if (TREE_CODE (value) == CONST_DECL)
4900 value = DECL_INITIAL (value);
4901 node = splay_tree_lookup (cases, (splay_tree_key) value);
4904 /* Mark the CASE_LOW part of the case entry as seen. */
4905 tree label = (tree) node->value;
4906 CASE_LOW_SEEN (label) = 1;
4910 /* Even though there wasn't an exact match, there might be a
4911 case range which includes the enumerator's value. */
4912 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4913 if (node && CASE_HIGH ((tree) node->value))
4915 tree label = (tree) node->value;
4916 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4919 /* If we match the upper bound exactly, mark the CASE_HIGH
4920 part of the case entry as seen. */
4922 CASE_HIGH_SEEN (label) = 1;
4927 /* We've now determined that this enumerated literal isn't
4928 handled by the case labels of the switch statement. */
4930 /* If the switch expression is a constant, we only really care
4931 about whether that constant is handled by the switch. */
4932 if (cond && tree_int_cst_compare (cond, value))
4935 /* If there is a default_node, the only relevant option is
4936 Wswitch-enum. Otherwise, if both are enabled then we prefer
4937 to warn using -Wswitch because -Wswitch is enabled by -Wall
4938 while -Wswitch-enum is explicit. */
4939 warning ((default_node || !warn_switch)
4940 ? OPT_Wswitch_enum : OPT_Wswitch,
4941 "%Henumeration value %qE not handled in switch",
4942 &switch_location, TREE_PURPOSE (chain));
4945 /* Warn if there are case expressions that don't correspond to
4946 enumerators. This can occur since C and C++ don't enforce
4947 type-checking of assignments to enumeration variables.
4949 The time complexity here is now always O(N) worst case, since
4950 we should have marked both the lower bound and upper bound of
4951 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4952 above. This scan also resets those fields. */
4954 /* If there is a default_node, the only relevant option is
4955 Wswitch-enum. Otherwise, if both are enabled then we prefer
4956 to warn using -Wswitch because -Wswitch is enabled by -Wall
4957 while -Wswitch-enum is explicit. */
4958 saved_warn_switch = warn_switch;
4961 splay_tree_foreach (cases, match_case_to_enum, type);
4962 warn_switch = saved_warn_switch;
4966 /* Finish an expression taking the address of LABEL (an
4967 IDENTIFIER_NODE). Returns an expression for the address.
4969 LOC is the location for the expression returned. */
4972 finish_label_address_expr (tree label, location_t loc)
4976 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
4978 if (label == error_mark_node)
4979 return error_mark_node;
4981 label = lookup_label (label);
4982 if (label == NULL_TREE)
4983 result = null_pointer_node;
4986 TREE_USED (label) = 1;
4987 result = build1 (ADDR_EXPR, ptr_type_node, label);
4988 /* The current function in not necessarily uninlinable.
4989 Computed gotos are incompatible with inlining, but the value
4990 here could be used only in a diagnostic, for example. */
4991 protected_set_expr_location (result, loc);
4997 /* Hook used by expand_expr to expand language-specific tree codes. */
4998 /* The only things that should go here are bits needed to expand
4999 constant initializers. Everything else should be handled by the
5000 gimplification routines. */
5003 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
5004 int modifiera /* Actually enum expand_modifier. */,
5007 enum expand_modifier modifier = (enum expand_modifier) modifiera;
5008 switch (TREE_CODE (exp))
5010 case COMPOUND_LITERAL_EXPR:
5012 /* Initialize the anonymous variable declared in the compound
5013 literal, then return the variable. */
5014 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
5015 emit_local_var (decl);
5016 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
5024 /* Hook used by staticp to handle language-specific tree codes. */
5027 c_staticp (tree exp)
5029 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
5030 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
5035 /* Given a boolean expression ARG, return a tree representing an increment
5036 or decrement (as indicated by CODE) of ARG. The front end must check for
5037 invalid cases (e.g., decrement in C++). */
5039 boolean_increment (enum tree_code code, tree arg)
5042 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5044 arg = stabilize_reference (arg);
5047 case PREINCREMENT_EXPR:
5048 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5050 case POSTINCREMENT_EXPR:
5051 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5052 arg = save_expr (arg);
5053 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5054 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5056 case PREDECREMENT_EXPR:
5057 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5058 invert_truthvalue (arg));
5060 case POSTDECREMENT_EXPR:
5061 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5062 invert_truthvalue (arg));
5063 arg = save_expr (arg);
5064 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5065 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5070 TREE_SIDE_EFFECTS (val) = 1;
5074 /* Built-in macros for stddef.h, that require macros defined in this
5077 c_stddef_cpp_builtins(void)
5079 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5080 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5081 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5082 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5083 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5084 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5085 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5086 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5090 c_init_attributes (void)
5092 /* Fill in the built_in_attributes array. */
5093 #define DEF_ATTR_NULL_TREE(ENUM) \
5094 built_in_attributes[(int) ENUM] = NULL_TREE;
5095 #define DEF_ATTR_INT(ENUM, VALUE) \
5096 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5097 #define DEF_ATTR_IDENT(ENUM, STRING) \
5098 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5099 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5100 built_in_attributes[(int) ENUM] \
5101 = tree_cons (built_in_attributes[(int) PURPOSE], \
5102 built_in_attributes[(int) VALUE], \
5103 built_in_attributes[(int) CHAIN]);
5104 #include "builtin-attrs.def"
5105 #undef DEF_ATTR_NULL_TREE
5107 #undef DEF_ATTR_IDENT
5108 #undef DEF_ATTR_TREE_LIST
5111 /* Attribute handlers common to C front ends. */
5113 /* Handle a "packed" attribute; arguments as in
5114 struct attribute_spec.handler. */
5117 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5118 int flags, bool *no_add_attrs)
5122 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5123 *node = build_variant_type_copy (*node);
5124 TYPE_PACKED (*node) = 1;
5126 else if (TREE_CODE (*node) == FIELD_DECL)
5128 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5129 /* Still pack bitfields. */
5130 && ! DECL_INITIAL (*node))
5131 warning (OPT_Wattributes,
5132 "%qE attribute ignored for field of type %qT",
5133 name, TREE_TYPE (*node));
5135 DECL_PACKED (*node) = 1;
5137 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5138 used for DECL_REGISTER. It wouldn't mean anything anyway.
5139 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5140 that changes what the typedef is typing. */
5143 warning (OPT_Wattributes, "%qE attribute ignored", name);
5144 *no_add_attrs = true;
5150 /* Handle a "nocommon" attribute; arguments as in
5151 struct attribute_spec.handler. */
5154 handle_nocommon_attribute (tree *node, tree name,
5155 tree ARG_UNUSED (args),
5156 int ARG_UNUSED (flags), bool *no_add_attrs)
5158 if (TREE_CODE (*node) == VAR_DECL)
5159 DECL_COMMON (*node) = 0;
5162 warning (OPT_Wattributes, "%qE attribute ignored", name);
5163 *no_add_attrs = true;
5169 /* Handle a "common" attribute; arguments as in
5170 struct attribute_spec.handler. */
5173 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5174 int ARG_UNUSED (flags), bool *no_add_attrs)
5176 if (TREE_CODE (*node) == VAR_DECL)
5177 DECL_COMMON (*node) = 1;
5180 warning (OPT_Wattributes, "%qE attribute ignored", name);
5181 *no_add_attrs = true;
5187 /* Handle a "noreturn" attribute; arguments as in
5188 struct attribute_spec.handler. */
5191 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5192 int ARG_UNUSED (flags), bool *no_add_attrs)
5194 tree type = TREE_TYPE (*node);
5196 /* See FIXME comment in c_common_attribute_table. */
5197 if (TREE_CODE (*node) == FUNCTION_DECL)
5198 TREE_THIS_VOLATILE (*node) = 1;
5199 else if (TREE_CODE (type) == POINTER_TYPE
5200 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5202 = build_pointer_type
5203 (build_type_variant (TREE_TYPE (type),
5204 TYPE_READONLY (TREE_TYPE (type)), 1));
5207 warning (OPT_Wattributes, "%qE attribute ignored", name);
5208 *no_add_attrs = true;
5214 /* Handle a "hot" and attribute; arguments as in
5215 struct attribute_spec.handler. */
5218 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5219 int ARG_UNUSED (flags), bool *no_add_attrs)
5221 if (TREE_CODE (*node) == FUNCTION_DECL)
5223 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5225 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5227 *no_add_attrs = true;
5229 /* Most of the rest of the hot processing is done later with
5230 lookup_attribute. */
5234 warning (OPT_Wattributes, "%qE attribute ignored", name);
5235 *no_add_attrs = true;
5240 /* Handle a "cold" and attribute; arguments as in
5241 struct attribute_spec.handler. */
5244 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5245 int ARG_UNUSED (flags), bool *no_add_attrs)
5247 if (TREE_CODE (*node) == FUNCTION_DECL)
5249 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5251 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5253 *no_add_attrs = true;
5255 /* Most of the rest of the cold processing is done later with
5256 lookup_attribute. */
5260 warning (OPT_Wattributes, "%qE attribute ignored", name);
5261 *no_add_attrs = true;
5267 /* Handle a "noinline" attribute; arguments as in
5268 struct attribute_spec.handler. */
5271 handle_noinline_attribute (tree *node, tree name,
5272 tree ARG_UNUSED (args),
5273 int ARG_UNUSED (flags), bool *no_add_attrs)
5275 if (TREE_CODE (*node) == FUNCTION_DECL)
5276 DECL_UNINLINABLE (*node) = 1;
5279 warning (OPT_Wattributes, "%qE attribute ignored", name);
5280 *no_add_attrs = true;
5286 /* Handle a "always_inline" attribute; arguments as in
5287 struct attribute_spec.handler. */
5290 handle_always_inline_attribute (tree *node, tree name,
5291 tree ARG_UNUSED (args),
5292 int ARG_UNUSED (flags),
5295 if (TREE_CODE (*node) == FUNCTION_DECL)
5297 /* Set the attribute and mark it for disregarding inline
5299 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
5303 warning (OPT_Wattributes, "%qE attribute ignored", name);
5304 *no_add_attrs = true;
5310 /* Handle a "gnu_inline" attribute; arguments as in
5311 struct attribute_spec.handler. */
5314 handle_gnu_inline_attribute (tree *node, tree name,
5315 tree ARG_UNUSED (args),
5316 int ARG_UNUSED (flags),
5319 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5321 /* Do nothing else, just set the attribute. We'll get at
5322 it later with lookup_attribute. */
5326 warning (OPT_Wattributes, "%qE attribute ignored", name);
5327 *no_add_attrs = true;
5333 /* Handle an "artificial" attribute; arguments as in
5334 struct attribute_spec.handler. */
5337 handle_artificial_attribute (tree *node, tree name,
5338 tree ARG_UNUSED (args),
5339 int ARG_UNUSED (flags),
5342 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5344 /* Do nothing else, just set the attribute. We'll get at
5345 it later with lookup_attribute. */
5349 warning (OPT_Wattributes, "%qE attribute ignored", name);
5350 *no_add_attrs = true;
5356 /* Handle a "flatten" attribute; arguments as in
5357 struct attribute_spec.handler. */
5360 handle_flatten_attribute (tree *node, tree name,
5361 tree args ATTRIBUTE_UNUSED,
5362 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5364 if (TREE_CODE (*node) == FUNCTION_DECL)
5365 /* Do nothing else, just set the attribute. We'll get at
5366 it later with lookup_attribute. */
5370 warning (OPT_Wattributes, "%qE attribute ignored", name);
5371 *no_add_attrs = true;
5377 /* Handle a "warning" or "error" attribute; arguments as in
5378 struct attribute_spec.handler. */
5381 handle_error_attribute (tree *node, tree name, tree args,
5382 int ARG_UNUSED (flags), bool *no_add_attrs)
5384 if (TREE_CODE (*node) == FUNCTION_DECL
5385 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5386 /* Do nothing else, just set the attribute. We'll get at
5387 it later with lookup_attribute. */
5391 warning (OPT_Wattributes, "%qE attribute ignored", name);
5392 *no_add_attrs = true;
5398 /* Handle a "used" attribute; arguments as in
5399 struct attribute_spec.handler. */
5402 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
5403 int ARG_UNUSED (flags), bool *no_add_attrs)
5407 if (TREE_CODE (node) == FUNCTION_DECL
5408 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
5410 TREE_USED (node) = 1;
5411 DECL_PRESERVE_P (node) = 1;
5415 warning (OPT_Wattributes, "%qE attribute ignored", name);
5416 *no_add_attrs = true;
5422 /* Handle a "unused" attribute; arguments as in
5423 struct attribute_spec.handler. */
5426 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5427 int flags, bool *no_add_attrs)
5433 if (TREE_CODE (decl) == PARM_DECL
5434 || TREE_CODE (decl) == VAR_DECL
5435 || TREE_CODE (decl) == FUNCTION_DECL
5436 || TREE_CODE (decl) == LABEL_DECL
5437 || TREE_CODE (decl) == TYPE_DECL)
5438 TREE_USED (decl) = 1;
5441 warning (OPT_Wattributes, "%qE attribute ignored", name);
5442 *no_add_attrs = true;
5447 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5448 *node = build_variant_type_copy (*node);
5449 TREE_USED (*node) = 1;
5455 /* Handle a "externally_visible" attribute; arguments as in
5456 struct attribute_spec.handler. */
5459 handle_externally_visible_attribute (tree *pnode, tree name,
5460 tree ARG_UNUSED (args),
5461 int ARG_UNUSED (flags),
5466 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
5468 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
5469 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
5471 warning (OPT_Wattributes,
5472 "%qE attribute have effect only on public objects", name);
5473 *no_add_attrs = true;
5478 warning (OPT_Wattributes, "%qE attribute ignored", name);
5479 *no_add_attrs = true;
5485 /* Handle a "const" attribute; arguments as in
5486 struct attribute_spec.handler. */
5489 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5490 int ARG_UNUSED (flags), bool *no_add_attrs)
5492 tree type = TREE_TYPE (*node);
5494 /* See FIXME comment on noreturn in c_common_attribute_table. */
5495 if (TREE_CODE (*node) == FUNCTION_DECL)
5496 TREE_READONLY (*node) = 1;
5497 else if (TREE_CODE (type) == POINTER_TYPE
5498 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5500 = build_pointer_type
5501 (build_type_variant (TREE_TYPE (type), 1,
5502 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5505 warning (OPT_Wattributes, "%qE attribute ignored", name);
5506 *no_add_attrs = true;
5512 /* Handle a "transparent_union" attribute; arguments as in
5513 struct attribute_spec.handler. */
5516 handle_transparent_union_attribute (tree *node, tree name,
5517 tree ARG_UNUSED (args), int flags,
5522 *no_add_attrs = true;
5524 if (TREE_CODE (*node) == TYPE_DECL)
5525 node = &TREE_TYPE (*node);
5528 if (TREE_CODE (type) == UNION_TYPE)
5530 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5531 the code in finish_struct. */
5532 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5534 if (TYPE_FIELDS (type) == NULL_TREE
5535 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
5538 /* A type variant isn't good enough, since we don't a cast
5539 to such a type removed as a no-op. */
5540 *node = type = build_duplicate_type (type);
5543 TYPE_TRANSPARENT_UNION (type) = 1;
5548 warning (OPT_Wattributes, "%qE attribute ignored", name);
5552 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
5553 get the requested priority for a constructor or destructor,
5554 possibly issuing diagnostics for invalid or reserved
5557 static priority_type
5558 get_priority (tree args, bool is_destructor)
5564 return DEFAULT_INIT_PRIORITY;
5566 if (!SUPPORTS_INIT_PRIORITY)
5569 error ("destructor priorities are not supported");
5571 error ("constructor priorities are not supported");
5572 return DEFAULT_INIT_PRIORITY;
5575 arg = TREE_VALUE (args);
5576 if (!host_integerp (arg, /*pos=*/0)
5577 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
5580 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
5581 if (pri < 0 || pri > MAX_INIT_PRIORITY)
5584 if (pri <= MAX_RESERVED_INIT_PRIORITY)
5588 "destructor priorities from 0 to %d are reserved "
5589 "for the implementation",
5590 MAX_RESERVED_INIT_PRIORITY);
5593 "constructor priorities from 0 to %d are reserved "
5594 "for the implementation",
5595 MAX_RESERVED_INIT_PRIORITY);
5601 error ("destructor priorities must be integers from 0 to %d inclusive",
5604 error ("constructor priorities must be integers from 0 to %d inclusive",
5606 return DEFAULT_INIT_PRIORITY;
5609 /* Handle a "constructor" attribute; arguments as in
5610 struct attribute_spec.handler. */
5613 handle_constructor_attribute (tree *node, tree name, tree args,
5614 int ARG_UNUSED (flags),
5618 tree type = TREE_TYPE (decl);
5620 if (TREE_CODE (decl) == FUNCTION_DECL
5621 && TREE_CODE (type) == FUNCTION_TYPE
5622 && decl_function_context (decl) == 0)
5624 priority_type priority;
5625 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5626 priority = get_priority (args, /*is_destructor=*/false);
5627 SET_DECL_INIT_PRIORITY (decl, priority);
5628 TREE_USED (decl) = 1;
5632 warning (OPT_Wattributes, "%qE attribute ignored", name);
5633 *no_add_attrs = true;
5639 /* Handle a "destructor" attribute; arguments as in
5640 struct attribute_spec.handler. */
5643 handle_destructor_attribute (tree *node, tree name, tree args,
5644 int ARG_UNUSED (flags),
5648 tree type = TREE_TYPE (decl);
5650 if (TREE_CODE (decl) == FUNCTION_DECL
5651 && TREE_CODE (type) == FUNCTION_TYPE
5652 && decl_function_context (decl) == 0)
5654 priority_type priority;
5655 DECL_STATIC_DESTRUCTOR (decl) = 1;
5656 priority = get_priority (args, /*is_destructor=*/true);
5657 SET_DECL_FINI_PRIORITY (decl, priority);
5658 TREE_USED (decl) = 1;
5662 warning (OPT_Wattributes, "%qE attribute ignored", name);
5663 *no_add_attrs = true;
5669 /* Handle a "mode" attribute; arguments as in
5670 struct attribute_spec.handler. */
5673 handle_mode_attribute (tree *node, tree name, tree args,
5674 int ARG_UNUSED (flags), bool *no_add_attrs)
5678 *no_add_attrs = true;
5680 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5681 warning (OPT_Wattributes, "%qE attribute ignored", name);
5685 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5686 int len = strlen (p);
5687 enum machine_mode mode = VOIDmode;
5691 if (len > 4 && p[0] == '_' && p[1] == '_'
5692 && p[len - 1] == '_' && p[len - 2] == '_')
5694 char *newp = (char *) alloca (len - 1);
5696 strcpy (newp, &p[2]);
5697 newp[len - 4] = '\0';
5701 /* Change this type to have a type with the specified mode.
5702 First check for the special modes. */
5703 if (!strcmp (p, "byte"))
5705 else if (!strcmp (p, "word"))
5707 else if (!strcmp (p, "pointer"))
5709 else if (!strcmp (p, "libgcc_cmp_return"))
5710 mode = targetm.libgcc_cmp_return_mode ();
5711 else if (!strcmp (p, "libgcc_shift_count"))
5712 mode = targetm.libgcc_shift_count_mode ();
5713 else if (!strcmp (p, "unwind_word"))
5714 mode = targetm.unwind_word_mode ();
5716 for (j = 0; j < NUM_MACHINE_MODES; j++)
5717 if (!strcmp (p, GET_MODE_NAME (j)))
5719 mode = (enum machine_mode) j;
5723 if (mode == VOIDmode)
5725 error ("unknown machine mode %qs", p);
5730 switch (GET_MODE_CLASS (mode))
5733 case MODE_PARTIAL_INT:
5735 case MODE_DECIMAL_FLOAT:
5740 valid_mode = targetm.scalar_mode_supported_p (mode);
5743 case MODE_COMPLEX_INT:
5744 case MODE_COMPLEX_FLOAT:
5745 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5748 case MODE_VECTOR_INT:
5749 case MODE_VECTOR_FLOAT:
5750 case MODE_VECTOR_FRACT:
5751 case MODE_VECTOR_UFRACT:
5752 case MODE_VECTOR_ACCUM:
5753 case MODE_VECTOR_UACCUM:
5754 warning (OPT_Wattributes, "specifying vector types with "
5755 "__attribute__ ((mode)) is deprecated");
5756 warning (OPT_Wattributes,
5757 "use __attribute__ ((vector_size)) instead");
5758 valid_mode = vector_mode_valid_p (mode);
5766 error ("unable to emulate %qs", p);
5770 if (POINTER_TYPE_P (type))
5772 tree (*fn)(tree, enum machine_mode, bool);
5774 if (!targetm.valid_pointer_mode (mode))
5776 error ("invalid pointer mode %qs", p);
5780 if (TREE_CODE (type) == POINTER_TYPE)
5781 fn = build_pointer_type_for_mode;
5783 fn = build_reference_type_for_mode;
5784 typefm = fn (TREE_TYPE (type), mode, false);
5788 /* For fixed-point modes, we need to test if the signness of type
5789 and the machine mode are consistent. */
5790 if (ALL_FIXED_POINT_MODE_P (mode)
5791 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
5793 error ("signness of type and machine mode %qs don't match", p);
5796 /* For fixed-point modes, we need to pass saturating info. */
5797 typefm = lang_hooks.types.type_for_mode (mode,
5798 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
5799 : TYPE_UNSIGNED (type));
5802 if (typefm == NULL_TREE)
5804 error ("no data type for mode %qs", p);
5807 else if (TREE_CODE (type) == ENUMERAL_TYPE)
5809 /* For enumeral types, copy the precision from the integer
5810 type returned above. If not an INTEGER_TYPE, we can't use
5811 this mode for this type. */
5812 if (TREE_CODE (typefm) != INTEGER_TYPE)
5814 error ("cannot use mode %qs for enumeral types", p);
5818 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5820 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5825 /* We cannot build a type variant, as there's code that assumes
5826 that TYPE_MAIN_VARIANT has the same mode. This includes the
5827 debug generators. Instead, create a subrange type. This
5828 results in all of the enumeral values being emitted only once
5829 in the original, and the subtype gets them by reference. */
5830 if (TYPE_UNSIGNED (type))
5831 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5833 typefm = make_signed_type (TYPE_PRECISION (typefm));
5834 TREE_TYPE (typefm) = type;
5837 else if (VECTOR_MODE_P (mode)
5838 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5839 : TREE_CODE (type) != TREE_CODE (typefm))
5841 error ("mode %qs applied to inappropriate type", p);
5851 /* Handle a "section" attribute; arguments as in
5852 struct attribute_spec.handler. */
5855 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5856 int ARG_UNUSED (flags), bool *no_add_attrs)
5860 if (targetm.have_named_sections)
5862 user_defined_section_attribute = true;
5864 if ((TREE_CODE (decl) == FUNCTION_DECL
5865 || TREE_CODE (decl) == VAR_DECL)
5866 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5868 if (TREE_CODE (decl) == VAR_DECL
5869 && current_function_decl != NULL_TREE
5870 && !TREE_STATIC (decl))
5872 error ("%Jsection attribute cannot be specified for "
5873 "local variables", decl);
5874 *no_add_attrs = true;
5877 /* The decl may have already been given a section attribute
5878 from a previous declaration. Ensure they match. */
5879 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5880 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5881 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5883 error ("section of %q+D conflicts with previous declaration",
5885 *no_add_attrs = true;
5887 else if (TREE_CODE (decl) == VAR_DECL
5888 && !targetm.have_tls && targetm.emutls.tmpl_section
5889 && DECL_THREAD_LOCAL_P (decl))
5891 error ("section of %q+D cannot be overridden", *node);
5892 *no_add_attrs = true;
5895 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5899 error ("section attribute not allowed for %q+D", *node);
5900 *no_add_attrs = true;
5905 error ("%Jsection attributes are not supported for this target", *node);
5906 *no_add_attrs = true;
5912 /* Handle a "aligned" attribute; arguments as in
5913 struct attribute_spec.handler. */
5916 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5917 int flags, bool *no_add_attrs)
5919 tree decl = NULL_TREE;
5922 tree align_expr = (args ? TREE_VALUE (args)
5923 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
5929 type = &TREE_TYPE (decl);
5930 is_type = TREE_CODE (*node) == TYPE_DECL;
5932 else if (TYPE_P (*node))
5933 type = node, is_type = 1;
5935 if (TREE_CODE (align_expr) != INTEGER_CST)
5937 error ("requested alignment is not a constant");
5938 *no_add_attrs = true;
5940 else if ((i = tree_log2 (align_expr)) == -1)
5942 error ("requested alignment is not a power of 2");
5943 *no_add_attrs = true;
5945 else if (i > HOST_BITS_PER_INT - 2)
5947 error ("requested alignment is too large");
5948 *no_add_attrs = true;
5952 if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5953 /* OK, modify the type in place. */;
5954 /* If we have a TYPE_DECL, then copy the type, so that we
5955 don't accidentally modify a builtin type. See pushdecl. */
5956 else if (decl && TREE_TYPE (decl) != error_mark_node
5957 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5959 tree tt = TREE_TYPE (decl);
5960 *type = build_variant_type_copy (*type);
5961 DECL_ORIGINAL_TYPE (decl) = tt;
5962 TYPE_NAME (*type) = decl;
5963 TREE_USED (*type) = TREE_USED (decl);
5964 TREE_TYPE (decl) = *type;
5967 *type = build_variant_type_copy (*type);
5969 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5970 TYPE_USER_ALIGN (*type) = 1;
5972 else if (! VAR_OR_FUNCTION_DECL_P (decl)
5973 && TREE_CODE (decl) != FIELD_DECL)
5975 error ("alignment may not be specified for %q+D", decl);
5976 *no_add_attrs = true;
5978 else if (TREE_CODE (decl) == FUNCTION_DECL
5979 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
5981 if (DECL_USER_ALIGN (decl))
5982 error ("alignment for %q+D was previously specified as %d "
5983 "and may not be decreased", decl,
5984 DECL_ALIGN (decl) / BITS_PER_UNIT);
5986 error ("alignment for %q+D must be at least %d", decl,
5987 DECL_ALIGN (decl) / BITS_PER_UNIT);
5988 *no_add_attrs = true;
5992 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5993 DECL_USER_ALIGN (decl) = 1;
5999 /* Handle a "weak" attribute; arguments as in
6000 struct attribute_spec.handler. */
6003 handle_weak_attribute (tree *node, tree name,
6004 tree ARG_UNUSED (args),
6005 int ARG_UNUSED (flags),
6006 bool * ARG_UNUSED (no_add_attrs))
6008 if (TREE_CODE (*node) == FUNCTION_DECL
6009 && DECL_DECLARED_INLINE_P (*node))
6011 error ("inline function %q+D cannot be declared weak", *node);
6012 *no_add_attrs = true;
6014 else if (TREE_CODE (*node) == FUNCTION_DECL
6015 || TREE_CODE (*node) == VAR_DECL)
6016 declare_weak (*node);
6018 warning (OPT_Wattributes, "%qE attribute ignored", name);
6023 /* Handle an "alias" attribute; arguments as in
6024 struct attribute_spec.handler. */
6027 handle_alias_attribute (tree *node, tree name, tree args,
6028 int ARG_UNUSED (flags), bool *no_add_attrs)
6032 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6034 warning (OPT_Wattributes, "%qE attribute ignored", name);
6035 *no_add_attrs = true;
6037 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6038 || (TREE_CODE (decl) != FUNCTION_DECL
6039 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6040 /* A static variable declaration is always a tentative definition,
6041 but the alias is a non-tentative definition which overrides. */
6042 || (TREE_CODE (decl) != FUNCTION_DECL
6043 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6045 error ("%q+D defined both normally and as an alias", decl);
6046 *no_add_attrs = true;
6049 /* Note that the very first time we process a nested declaration,
6050 decl_function_context will not be set. Indeed, *would* never
6051 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6052 we do below. After such frobbery, pushdecl would set the context.
6053 In any case, this is never what we want. */
6054 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6058 id = TREE_VALUE (args);
6059 if (TREE_CODE (id) != STRING_CST)
6061 error ("alias argument not a string");
6062 *no_add_attrs = true;
6065 id = get_identifier (TREE_STRING_POINTER (id));
6066 /* This counts as a use of the object pointed to. */
6069 if (TREE_CODE (decl) == FUNCTION_DECL)
6070 DECL_INITIAL (decl) = error_mark_node;
6073 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6074 DECL_EXTERNAL (decl) = 1;
6076 DECL_EXTERNAL (decl) = 0;
6077 TREE_STATIC (decl) = 1;
6082 warning (OPT_Wattributes, "%qE attribute ignored", name);
6083 *no_add_attrs = true;
6089 /* Handle a "weakref" attribute; arguments as in struct
6090 attribute_spec.handler. */
6093 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6094 int flags, bool *no_add_attrs)
6096 tree attr = NULL_TREE;
6098 /* We must ignore the attribute when it is associated with
6099 local-scoped decls, since attribute alias is ignored and many
6100 such symbols do not even have a DECL_WEAK field. */
6101 if (decl_function_context (*node)
6102 || current_function_decl
6103 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6105 warning (OPT_Wattributes, "%qE attribute ignored", name);
6106 *no_add_attrs = true;
6110 /* The idea here is that `weakref("name")' mutates into `weakref,
6111 alias("name")', and weakref without arguments, in turn,
6112 implicitly adds weak. */
6116 attr = tree_cons (get_identifier ("alias"), args, attr);
6117 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6119 *no_add_attrs = true;
6121 decl_attributes (node, attr, flags);
6125 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6126 error ("%Jweakref attribute must appear before alias attribute",
6129 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6130 and that isn't supported; and because it wants to add it to
6131 the list of weak decls, which isn't helpful. */
6132 DECL_WEAK (*node) = 1;
6138 /* Handle an "visibility" attribute; arguments as in
6139 struct attribute_spec.handler. */
6142 handle_visibility_attribute (tree *node, tree name, tree args,
6143 int ARG_UNUSED (flags),
6144 bool *ARG_UNUSED (no_add_attrs))
6147 tree id = TREE_VALUE (args);
6148 enum symbol_visibility vis;
6152 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6154 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6156 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6160 else if (TYPE_FIELDS (*node))
6162 error ("%qE attribute ignored because %qT is already defined",
6167 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6169 warning (OPT_Wattributes, "%qE attribute ignored", name);
6173 if (TREE_CODE (id) != STRING_CST)
6175 error ("visibility argument not a string");
6179 /* If this is a type, set the visibility on the type decl. */
6182 decl = TYPE_NAME (decl);
6185 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6187 warning (OPT_Wattributes, "%qE attribute ignored on types",
6193 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6194 vis = VISIBILITY_DEFAULT;
6195 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6196 vis = VISIBILITY_INTERNAL;
6197 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6198 vis = VISIBILITY_HIDDEN;
6199 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6200 vis = VISIBILITY_PROTECTED;
6203 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6204 vis = VISIBILITY_DEFAULT;
6207 if (DECL_VISIBILITY_SPECIFIED (decl)
6208 && vis != DECL_VISIBILITY (decl))
6210 tree attributes = (TYPE_P (*node)
6211 ? TYPE_ATTRIBUTES (*node)
6212 : DECL_ATTRIBUTES (decl));
6213 if (lookup_attribute ("visibility", attributes))
6214 error ("%qD redeclared with different visibility", decl);
6215 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6216 && lookup_attribute ("dllimport", attributes))
6217 error ("%qD was declared %qs which implies default visibility",
6219 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6220 && lookup_attribute ("dllexport", attributes))
6221 error ("%qD was declared %qs which implies default visibility",
6225 DECL_VISIBILITY (decl) = vis;
6226 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6228 /* Go ahead and attach the attribute to the node as well. This is needed
6229 so we can determine whether we have VISIBILITY_DEFAULT because the
6230 visibility was not specified, or because it was explicitly overridden
6231 from the containing scope. */
6236 /* Determine the ELF symbol visibility for DECL, which is either a
6237 variable or a function. It is an error to use this function if a
6238 definition of DECL is not available in this translation unit.
6239 Returns true if the final visibility has been determined by this
6240 function; false if the caller is free to make additional
6244 c_determine_visibility (tree decl)
6246 gcc_assert (TREE_CODE (decl) == VAR_DECL
6247 || TREE_CODE (decl) == FUNCTION_DECL);
6249 /* If the user explicitly specified the visibility with an
6250 attribute, honor that. DECL_VISIBILITY will have been set during
6251 the processing of the attribute. We check for an explicit
6252 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6253 to distinguish the use of an attribute from the use of a "#pragma
6254 GCC visibility push(...)"; in the latter case we still want other
6255 considerations to be able to overrule the #pragma. */
6256 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6257 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6258 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6259 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6262 /* Set default visibility to whatever the user supplied with
6263 visibility_specified depending on #pragma GCC visibility. */
6264 if (!DECL_VISIBILITY_SPECIFIED (decl))
6266 if (visibility_options.inpragma
6267 || DECL_VISIBILITY (decl) != default_visibility)
6269 DECL_VISIBILITY (decl) = default_visibility;
6270 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6271 /* If visibility changed and DECL already has DECL_RTL, ensure
6272 symbol flags are updated. */
6273 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6274 || TREE_CODE (decl) == FUNCTION_DECL)
6275 && DECL_RTL_SET_P (decl))
6276 make_decl_rtl (decl);
6282 /* Handle an "tls_model" attribute; arguments as in
6283 struct attribute_spec.handler. */
6286 handle_tls_model_attribute (tree *node, tree name, tree args,
6287 int ARG_UNUSED (flags), bool *no_add_attrs)
6291 enum tls_model kind;
6293 *no_add_attrs = true;
6295 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
6297 warning (OPT_Wattributes, "%qE attribute ignored", name);
6301 kind = DECL_TLS_MODEL (decl);
6302 id = TREE_VALUE (args);
6303 if (TREE_CODE (id) != STRING_CST)
6305 error ("tls_model argument not a string");
6309 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
6310 kind = TLS_MODEL_LOCAL_EXEC;
6311 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
6312 kind = TLS_MODEL_INITIAL_EXEC;
6313 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
6314 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
6315 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
6316 kind = TLS_MODEL_GLOBAL_DYNAMIC;
6318 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6320 DECL_TLS_MODEL (decl) = kind;
6324 /* Handle a "no_instrument_function" attribute; arguments as in
6325 struct attribute_spec.handler. */
6328 handle_no_instrument_function_attribute (tree *node, tree name,
6329 tree ARG_UNUSED (args),
6330 int ARG_UNUSED (flags),
6335 if (TREE_CODE (decl) != FUNCTION_DECL)
6337 error ("%J%qE attribute applies only to functions", decl, name);
6338 *no_add_attrs = true;
6340 else if (DECL_INITIAL (decl))
6342 error ("%Jcan%'t set %qE attribute after definition", decl, name);
6343 *no_add_attrs = true;
6346 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6351 /* Handle a "malloc" attribute; arguments as in
6352 struct attribute_spec.handler. */
6355 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6356 int ARG_UNUSED (flags), bool *no_add_attrs)
6358 if (TREE_CODE (*node) == FUNCTION_DECL
6359 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
6360 DECL_IS_MALLOC (*node) = 1;
6363 warning (OPT_Wattributes, "%qE attribute ignored", name);
6364 *no_add_attrs = true;
6370 /* Handle a "alloc_size" attribute; arguments as in
6371 struct attribute_spec.handler. */
6374 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6375 int ARG_UNUSED (flags), bool *no_add_attrs)
6377 unsigned arg_count = type_num_arguments (*node);
6378 for (; args; args = TREE_CHAIN (args))
6380 tree position = TREE_VALUE (args);
6382 if (TREE_CODE (position) != INTEGER_CST
6383 || TREE_INT_CST_HIGH (position)
6384 || TREE_INT_CST_LOW (position) < 1
6385 || TREE_INT_CST_LOW (position) > arg_count )
6387 warning (OPT_Wattributes,
6388 "alloc_size parameter outside range");
6389 *no_add_attrs = true;
6396 /* Handle a "returns_twice" attribute; arguments as in
6397 struct attribute_spec.handler. */
6400 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6401 int ARG_UNUSED (flags), bool *no_add_attrs)
6403 if (TREE_CODE (*node) == FUNCTION_DECL)
6404 DECL_IS_RETURNS_TWICE (*node) = 1;
6407 warning (OPT_Wattributes, "%qE attribute ignored", name);
6408 *no_add_attrs = true;
6414 /* Handle a "no_limit_stack" attribute; arguments as in
6415 struct attribute_spec.handler. */
6418 handle_no_limit_stack_attribute (tree *node, tree name,
6419 tree ARG_UNUSED (args),
6420 int ARG_UNUSED (flags),
6425 if (TREE_CODE (decl) != FUNCTION_DECL)
6427 error ("%J%qE attribute applies only to functions", decl, name);
6428 *no_add_attrs = true;
6430 else if (DECL_INITIAL (decl))
6432 error ("%Jcan%'t set %qE attribute after definition", decl, name);
6433 *no_add_attrs = true;
6436 DECL_NO_LIMIT_STACK (decl) = 1;
6441 /* Handle a "pure" attribute; arguments as in
6442 struct attribute_spec.handler. */
6445 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6446 int ARG_UNUSED (flags), bool *no_add_attrs)
6448 if (TREE_CODE (*node) == FUNCTION_DECL)
6449 DECL_PURE_P (*node) = 1;
6450 /* ??? TODO: Support types. */
6453 warning (OPT_Wattributes, "%qE attribute ignored", name);
6454 *no_add_attrs = true;
6460 /* Handle a "no vops" attribute; arguments as in
6461 struct attribute_spec.handler. */
6464 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
6465 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6466 bool *ARG_UNUSED (no_add_attrs))
6468 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
6469 DECL_IS_NOVOPS (*node) = 1;
6473 /* Handle a "deprecated" attribute; arguments as in
6474 struct attribute_spec.handler. */
6477 handle_deprecated_attribute (tree *node, tree name,
6478 tree ARG_UNUSED (args), int flags,
6481 tree type = NULL_TREE;
6483 tree what = NULL_TREE;
6488 type = TREE_TYPE (decl);
6490 if (TREE_CODE (decl) == TYPE_DECL
6491 || TREE_CODE (decl) == PARM_DECL
6492 || TREE_CODE (decl) == VAR_DECL
6493 || TREE_CODE (decl) == FUNCTION_DECL
6494 || TREE_CODE (decl) == FIELD_DECL)
6495 TREE_DEPRECATED (decl) = 1;
6499 else if (TYPE_P (*node))
6501 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6502 *node = build_variant_type_copy (*node);
6503 TREE_DEPRECATED (*node) = 1;
6511 *no_add_attrs = true;
6512 if (type && TYPE_NAME (type))
6514 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6515 what = TYPE_NAME (*node);
6516 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6517 && DECL_NAME (TYPE_NAME (type)))
6518 what = DECL_NAME (TYPE_NAME (type));
6521 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
6523 warning (OPT_Wattributes, "%qE attribute ignored", name);
6529 /* Handle a "vector_size" attribute; arguments as in
6530 struct attribute_spec.handler. */
6533 handle_vector_size_attribute (tree *node, tree name, tree args,
6534 int ARG_UNUSED (flags),
6537 unsigned HOST_WIDE_INT vecsize, nunits;
6538 enum machine_mode orig_mode;
6539 tree type = *node, new_type, size;
6541 *no_add_attrs = true;
6543 size = TREE_VALUE (args);
6545 if (!host_integerp (size, 1))
6547 warning (OPT_Wattributes, "%qE attribute ignored", name);
6551 /* Get the vector size (in bytes). */
6552 vecsize = tree_low_cst (size, 1);
6554 /* We need to provide for vector pointers, vector arrays, and
6555 functions returning vectors. For example:
6557 __attribute__((vector_size(16))) short *foo;
6559 In this case, the mode is SI, but the type being modified is
6560 HI, so we need to look further. */
6562 while (POINTER_TYPE_P (type)
6563 || TREE_CODE (type) == FUNCTION_TYPE
6564 || TREE_CODE (type) == METHOD_TYPE
6565 || TREE_CODE (type) == ARRAY_TYPE
6566 || TREE_CODE (type) == OFFSET_TYPE)
6567 type = TREE_TYPE (type);
6569 /* Get the mode of the type being modified. */
6570 orig_mode = TYPE_MODE (type);
6572 if ((!INTEGRAL_TYPE_P (type)
6573 && !SCALAR_FLOAT_TYPE_P (type)
6574 && !FIXED_POINT_TYPE_P (type))
6575 || (!SCALAR_FLOAT_MODE_P (orig_mode)
6576 && GET_MODE_CLASS (orig_mode) != MODE_INT
6577 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
6578 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
6579 || TREE_CODE (type) == BOOLEAN_TYPE)
6581 error ("invalid vector type for attribute %qE", name);
6585 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
6587 error ("vector size not an integral multiple of component size");
6593 error ("zero vector size");
6597 /* Calculate how many units fit in the vector. */
6598 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6599 if (nunits & (nunits - 1))
6601 error ("number of components of the vector not a power of two");
6605 new_type = build_vector_type (type, nunits);
6607 /* Build back pointers if needed. */
6608 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
6613 /* Handle the "nonnull" attribute. */
6615 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
6616 tree args, int ARG_UNUSED (flags),
6620 unsigned HOST_WIDE_INT attr_arg_num;
6622 /* If no arguments are specified, all pointer arguments should be
6623 non-null. Verify a full prototype is given so that the arguments
6624 will have the correct types when we actually check them later. */
6627 if (!TYPE_ARG_TYPES (type))
6629 error ("nonnull attribute without arguments on a non-prototype");
6630 *no_add_attrs = true;
6635 /* Argument list specified. Verify that each argument number references
6636 a pointer argument. */
6637 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6640 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
6642 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
6644 error ("nonnull argument has invalid operand number (argument %lu)",
6645 (unsigned long) attr_arg_num);
6646 *no_add_attrs = true;
6650 argument = TYPE_ARG_TYPES (type);
6653 for (ck_num = 1; ; ck_num++)
6655 if (!argument || ck_num == arg_num)
6657 argument = TREE_CHAIN (argument);
6661 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6663 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6664 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6665 *no_add_attrs = true;
6669 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6671 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6672 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6673 *no_add_attrs = true;
6682 /* Check the argument list of a function call for null in argument slots
6683 that are marked as requiring a non-null pointer argument. The NARGS
6684 arguments are passed in the array ARGARRAY.
6688 check_function_nonnull (tree attrs, int nargs, tree *argarray)
6693 for (a = attrs; a; a = TREE_CHAIN (a))
6695 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6697 args = TREE_VALUE (a);
6699 /* Walk the argument list. If we encounter an argument number we
6700 should check for non-null, do it. If the attribute has no args,
6701 then every pointer argument is checked (in which case the check
6702 for pointer type is done in check_nonnull_arg). */
6703 for (i = 0; i < nargs; i++)
6705 if (!args || nonnull_check_p (args, i + 1))
6706 check_function_arguments_recurse (check_nonnull_arg, NULL,
6714 /* Check that the Nth argument of a function call (counting backwards
6715 from the end) is a (pointer)0. The NARGS arguments are passed in the
6719 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
6721 tree attr = lookup_attribute ("sentinel", attrs);
6729 /* Skip over the named arguments. */
6730 while (typelist && len < nargs)
6732 typelist = TREE_CHAIN (typelist);
6736 if (TREE_VALUE (attr))
6738 tree p = TREE_VALUE (TREE_VALUE (attr));
6739 pos = TREE_INT_CST_LOW (p);
6742 /* The sentinel must be one of the varargs, i.e.
6743 in position >= the number of fixed arguments. */
6744 if ((nargs - 1 - pos) < len)
6746 warning (OPT_Wformat,
6747 "not enough variable arguments to fit a sentinel");
6751 /* Validate the sentinel. */
6752 sentinel = argarray[nargs - 1 - pos];
6753 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
6754 || !integer_zerop (sentinel))
6755 /* Although __null (in C++) is only an integer we allow it
6756 nevertheless, as we are guaranteed that it's exactly
6757 as wide as a pointer, and we don't want to force
6758 users to cast the NULL they have written there.
6759 We warn with -Wstrict-null-sentinel, though. */
6760 && (warn_strict_null_sentinel || null_node != sentinel))
6761 warning (OPT_Wformat, "missing sentinel in function call");
6765 /* Helper for check_function_nonnull; given a list of operands which
6766 must be non-null in ARGS, determine if operand PARAM_NUM should be
6770 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6772 unsigned HOST_WIDE_INT arg_num = 0;
6774 for (; args; args = TREE_CHAIN (args))
6776 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6780 if (arg_num == param_num)
6786 /* Check that the function argument PARAM (which is operand number
6787 PARAM_NUM) is non-null. This is called by check_function_nonnull
6788 via check_function_arguments_recurse. */
6791 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6792 unsigned HOST_WIDE_INT param_num)
6794 /* Just skip checking the argument if it's not a pointer. This can
6795 happen if the "nonnull" attribute was given without an operand
6796 list (which means to check every pointer argument). */
6798 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6801 if (integer_zerop (param))
6802 warning (OPT_Wnonnull, "null argument where non-null required "
6803 "(argument %lu)", (unsigned long) param_num);
6806 /* Helper for nonnull attribute handling; fetch the operand number
6807 from the attribute argument list. */
6810 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6812 /* Verify the arg number is a constant. */
6813 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6814 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6817 *valp = TREE_INT_CST_LOW (arg_num_expr);
6821 /* Handle a "nothrow" attribute; arguments as in
6822 struct attribute_spec.handler. */
6825 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6826 int ARG_UNUSED (flags), bool *no_add_attrs)
6828 if (TREE_CODE (*node) == FUNCTION_DECL)
6829 TREE_NOTHROW (*node) = 1;
6830 /* ??? TODO: Support types. */
6833 warning (OPT_Wattributes, "%qE attribute ignored", name);
6834 *no_add_attrs = true;
6840 /* Handle a "cleanup" attribute; arguments as in
6841 struct attribute_spec.handler. */
6844 handle_cleanup_attribute (tree *node, tree name, tree args,
6845 int ARG_UNUSED (flags), bool *no_add_attrs)
6848 tree cleanup_id, cleanup_decl;
6850 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6851 for global destructors in C++. This requires infrastructure that
6852 we don't have generically at the moment. It's also not a feature
6853 we'd be missing too much, since we do have attribute constructor. */
6854 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6856 warning (OPT_Wattributes, "%qE attribute ignored", name);
6857 *no_add_attrs = true;
6861 /* Verify that the argument is a function in scope. */
6862 /* ??? We could support pointers to functions here as well, if
6863 that was considered desirable. */
6864 cleanup_id = TREE_VALUE (args);
6865 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6867 error ("cleanup argument not an identifier");
6868 *no_add_attrs = true;
6871 cleanup_decl = lookup_name (cleanup_id);
6872 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6874 error ("cleanup argument not a function");
6875 *no_add_attrs = true;
6879 /* That the function has proper type is checked with the
6880 eventual call to build_function_call. */
6885 /* Handle a "warn_unused_result" attribute. No special handling. */
6888 handle_warn_unused_result_attribute (tree *node, tree name,
6889 tree ARG_UNUSED (args),
6890 int ARG_UNUSED (flags), bool *no_add_attrs)
6892 /* Ignore the attribute for functions not returning any value. */
6893 if (VOID_TYPE_P (TREE_TYPE (*node)))
6895 warning (OPT_Wattributes, "%qE attribute ignored", name);
6896 *no_add_attrs = true;
6902 /* Handle a "sentinel" attribute. */
6905 handle_sentinel_attribute (tree *node, tree name, tree args,
6906 int ARG_UNUSED (flags), bool *no_add_attrs)
6908 tree params = TYPE_ARG_TYPES (*node);
6912 warning (OPT_Wattributes,
6913 "%qE attribute requires prototypes with named arguments", name);
6914 *no_add_attrs = true;
6918 while (TREE_CHAIN (params))
6919 params = TREE_CHAIN (params);
6921 if (VOID_TYPE_P (TREE_VALUE (params)))
6923 warning (OPT_Wattributes,
6924 "%qE attribute only applies to variadic functions", name);
6925 *no_add_attrs = true;
6931 tree position = TREE_VALUE (args);
6933 if (TREE_CODE (position) != INTEGER_CST)
6935 warning (OPT_Wattributes,
6936 "requested position is not an integer constant");
6937 *no_add_attrs = true;
6941 if (tree_int_cst_lt (position, integer_zero_node))
6943 warning (OPT_Wattributes,
6944 "requested position is less than zero");
6945 *no_add_attrs = true;
6953 /* Handle a "type_generic" attribute. */
6956 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6957 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6958 bool * ARG_UNUSED (no_add_attrs))
6962 /* Ensure we have a function type. */
6963 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
6965 params = TYPE_ARG_TYPES (*node);
6966 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
6967 params = TREE_CHAIN (params);
6969 /* Ensure we have a variadic function. */
6970 gcc_assert (!params);
6975 /* Handle a "target" attribute. */
6978 handle_target_attribute (tree *node, tree name, tree args, int flags,
6981 /* Ensure we have a function type. */
6982 if (TREE_CODE (*node) != FUNCTION_DECL)
6984 warning (OPT_Wattributes, "%qE attribute ignored", name);
6985 *no_add_attrs = true;
6987 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
6989 *no_add_attrs = true;
6994 /* Arguments being collected for optimization. */
6995 typedef const char *const_char_p; /* For DEF_VEC_P. */
6996 DEF_VEC_P(const_char_p);
6997 DEF_VEC_ALLOC_P(const_char_p, gc);
6998 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7001 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7002 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7003 false for #pragma GCC optimize. */
7006 parse_optimize_options (tree args, bool attr_p)
7011 int saved_flag_strict_aliasing;
7012 const char **opt_argv;
7015 /* Build up argv vector. Just in case the string is stored away, use garbage
7016 collected strings. */
7017 VEC_truncate (const_char_p, optimize_args, 0);
7018 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7020 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7022 tree value = TREE_VALUE (ap);
7024 if (TREE_CODE (value) == INTEGER_CST)
7027 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7028 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7031 else if (TREE_CODE (value) == STRING_CST)
7033 /* Split string into multiple substrings. */
7034 size_t len = TREE_STRING_LENGTH (value);
7035 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7036 char *end = p + len;
7040 while (next_p != NULL)
7046 comma = strchr (p, ',');
7059 r = q = (char *) ggc_alloc (len2 + 3);
7061 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7063 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7067 warning (OPT_Wattributes,
7068 "Bad option %s to optimize attribute.", p);
7070 warning (OPT_Wpragmas,
7071 "Bad option %s to pragma attribute", p);
7079 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7080 itself is -Os, and any other switch begins with a -f. */
7081 if ((*p >= '0' && *p <= '9')
7082 || (p[0] == 's' && p[1] == '\0'))
7088 memcpy (r, p, len2);
7090 VEC_safe_push (const_char_p, gc, optimize_args, q);
7096 opt_argc = VEC_length (const_char_p, optimize_args);
7097 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7099 for (i = 1; i < opt_argc; i++)
7100 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7102 saved_flag_strict_aliasing = flag_strict_aliasing;
7104 /* Now parse the options. */
7105 decode_options (opt_argc, opt_argv);
7107 /* Don't allow changing -fstrict-aliasing. */
7108 flag_strict_aliasing = saved_flag_strict_aliasing;
7110 VEC_truncate (const_char_p, optimize_args, 0);
7114 /* For handling "optimize" attribute. arguments as in
7115 struct attribute_spec.handler. */
7118 handle_optimize_attribute (tree *node, tree name, tree args,
7119 int ARG_UNUSED (flags), bool *no_add_attrs)
7121 /* Ensure we have a function type. */
7122 if (TREE_CODE (*node) != FUNCTION_DECL)
7124 warning (OPT_Wattributes, "%qE attribute ignored", name);
7125 *no_add_attrs = true;
7129 struct cl_optimization cur_opts;
7130 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7132 /* Save current options. */
7133 cl_optimization_save (&cur_opts);
7135 /* If we previously had some optimization options, use them as the
7138 cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7140 /* Parse options, and update the vector. */
7141 parse_optimize_options (args, true);
7142 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7143 = build_optimization_node ();
7145 /* Restore current options. */
7146 cl_optimization_restore (&cur_opts);
7152 /* Check for valid arguments being passed to a function.
7153 ATTRS is a list of attributes. There are NARGS arguments in the array
7154 ARGARRAY. TYPELIST is the list of argument types for the function.
7157 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7159 /* Check for null being passed in a pointer argument that must be
7160 non-null. We also need to do this if format checking is enabled. */
7163 check_function_nonnull (attrs, nargs, argarray);
7165 /* Check for errors in format strings. */
7167 if (warn_format || warn_missing_format_attribute)
7168 check_function_format (attrs, nargs, argarray);
7171 check_function_sentinel (attrs, nargs, argarray, typelist);
7174 /* Generic argument checking recursion routine. PARAM is the argument to
7175 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7176 once the argument is resolved. CTX is context for the callback. */
7178 check_function_arguments_recurse (void (*callback)
7179 (void *, tree, unsigned HOST_WIDE_INT),
7180 void *ctx, tree param,
7181 unsigned HOST_WIDE_INT param_num)
7183 if (CONVERT_EXPR_P (param)
7184 && (TYPE_PRECISION (TREE_TYPE (param))
7185 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7187 /* Strip coercion. */
7188 check_function_arguments_recurse (callback, ctx,
7189 TREE_OPERAND (param, 0), param_num);
7193 if (TREE_CODE (param) == CALL_EXPR)
7195 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7197 bool found_format_arg = false;
7199 /* See if this is a call to a known internationalization function
7200 that modifies a format arg. Such a function may have multiple
7201 format_arg attributes (for example, ngettext). */
7203 for (attrs = TYPE_ATTRIBUTES (type);
7205 attrs = TREE_CHAIN (attrs))
7206 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7209 tree format_num_expr;
7212 call_expr_arg_iterator iter;
7214 /* Extract the argument number, which was previously checked
7216 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7218 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7219 && !TREE_INT_CST_HIGH (format_num_expr));
7221 format_num = TREE_INT_CST_LOW (format_num_expr);
7223 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7225 inner_arg = next_call_expr_arg (&iter), i++)
7226 if (i == format_num)
7228 check_function_arguments_recurse (callback, ctx,
7229 inner_arg, param_num);
7230 found_format_arg = true;
7235 /* If we found a format_arg attribute and did a recursive check,
7236 we are done with checking this argument. Otherwise, we continue
7237 and this will be considered a non-literal. */
7238 if (found_format_arg)
7242 if (TREE_CODE (param) == COND_EXPR)
7244 /* Check both halves of the conditional expression. */
7245 check_function_arguments_recurse (callback, ctx,
7246 TREE_OPERAND (param, 1), param_num);
7247 check_function_arguments_recurse (callback, ctx,
7248 TREE_OPERAND (param, 2), param_num);
7252 (*callback) (ctx, param, param_num);
7255 /* Checks the number of arguments NARGS against the required number
7256 REQUIRED and issues an error if there is a mismatch. Returns true
7257 if the number of arguments is correct, otherwise false. */
7260 validate_nargs (tree fndecl, int nargs, int required)
7262 if (nargs < required)
7264 error ("not enough arguments to function %qE", fndecl);
7267 else if (nargs > required)
7269 error ("too many arguments to function %qE", fndecl);
7275 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7276 Returns false if there was an error, otherwise true. */
7279 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
7281 if (!DECL_BUILT_IN (fndecl)
7282 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
7285 switch (DECL_FUNCTION_CODE (fndecl))
7287 case BUILT_IN_CONSTANT_P:
7288 return validate_nargs (fndecl, nargs, 1);
7290 case BUILT_IN_ISFINITE:
7291 case BUILT_IN_ISINF:
7292 case BUILT_IN_ISINF_SIGN:
7293 case BUILT_IN_ISNAN:
7294 case BUILT_IN_ISNORMAL:
7295 if (validate_nargs (fndecl, nargs, 1))
7297 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
7299 error ("non-floating-point argument in call to "
7300 "function %qE", fndecl);
7307 case BUILT_IN_ISGREATER:
7308 case BUILT_IN_ISGREATEREQUAL:
7309 case BUILT_IN_ISLESS:
7310 case BUILT_IN_ISLESSEQUAL:
7311 case BUILT_IN_ISLESSGREATER:
7312 case BUILT_IN_ISUNORDERED:
7313 if (validate_nargs (fndecl, nargs, 2))
7315 enum tree_code code0, code1;
7316 code0 = TREE_CODE (TREE_TYPE (args[0]));
7317 code1 = TREE_CODE (TREE_TYPE (args[1]));
7318 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
7319 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7320 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
7322 error ("non-floating-point arguments in call to "
7323 "function %qE", fndecl);
7330 case BUILT_IN_FPCLASSIFY:
7331 if (validate_nargs (fndecl, nargs, 6))
7336 if (TREE_CODE (args[i]) != INTEGER_CST)
7338 error ("non-const integer argument %u in call to function %qE",
7343 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
7345 error ("non-floating-point argument in call to function %qE",
7358 /* Function to help qsort sort FIELD_DECLs by name order. */
7361 field_decl_cmp (const void *x_p, const void *y_p)
7363 const tree *const x = (const tree *const) x_p;
7364 const tree *const y = (const tree *const) y_p;
7366 if (DECL_NAME (*x) == DECL_NAME (*y))
7367 /* A nontype is "greater" than a type. */
7368 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7369 if (DECL_NAME (*x) == NULL_TREE)
7371 if (DECL_NAME (*y) == NULL_TREE)
7373 if (DECL_NAME (*x) < DECL_NAME (*y))
7379 gt_pointer_operator new_value;
7383 /* This routine compares two fields like field_decl_cmp but using the
7384 pointer operator in resort_data. */
7387 resort_field_decl_cmp (const void *x_p, const void *y_p)
7389 const tree *const x = (const tree *const) x_p;
7390 const tree *const y = (const tree *const) y_p;
7392 if (DECL_NAME (*x) == DECL_NAME (*y))
7393 /* A nontype is "greater" than a type. */
7394 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7395 if (DECL_NAME (*x) == NULL_TREE)
7397 if (DECL_NAME (*y) == NULL_TREE)
7400 tree d1 = DECL_NAME (*x);
7401 tree d2 = DECL_NAME (*y);
7402 resort_data.new_value (&d1, resort_data.cookie);
7403 resort_data.new_value (&d2, resort_data.cookie);
7410 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
7413 resort_sorted_fields (void *obj,
7414 void * ARG_UNUSED (orig_obj),
7415 gt_pointer_operator new_value,
7418 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
7419 resort_data.new_value = new_value;
7420 resort_data.cookie = cookie;
7421 qsort (&sf->elts[0], sf->len, sizeof (tree),
7422 resort_field_decl_cmp);
7425 /* Subroutine of c_parse_error.
7426 Return the result of concatenating LHS and RHS. RHS is really
7427 a string literal, its first character is indicated by RHS_START and
7428 RHS_SIZE is its length (including the terminating NUL character).
7430 The caller is responsible for deleting the returned pointer. */
7433 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
7435 const int lhs_size = strlen (lhs);
7436 char *result = XNEWVEC (char, lhs_size + rhs_size);
7437 strncpy (result, lhs, lhs_size);
7438 strncpy (result + lhs_size, rhs_start, rhs_size);
7442 /* Issue the error given by GMSGID, indicating that it occurred before
7443 TOKEN, which had the associated VALUE. */
7446 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
7448 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
7450 char *message = NULL;
7452 if (token == CPP_EOF)
7453 message = catenate_messages (gmsgid, " at end of input");
7454 else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
7455 || token == CPP_CHAR32)
7457 unsigned int val = TREE_INT_CST_LOW (value);
7476 if (val <= UCHAR_MAX && ISGRAPH (val))
7477 message = catenate_messages (gmsgid, " before %s'%c'");
7479 message = catenate_messages (gmsgid, " before %s'\\x%x'");
7481 error (message, prefix, val);
7485 else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
7486 || token == CPP_STRING32)
7487 message = catenate_messages (gmsgid, " before string constant");
7488 else if (token == CPP_NUMBER)
7489 message = catenate_messages (gmsgid, " before numeric constant");
7490 else if (token == CPP_NAME)
7492 message = catenate_messages (gmsgid, " before %qE");
7493 error (message, value);
7497 else if (token == CPP_PRAGMA)
7498 message = catenate_messages (gmsgid, " before %<#pragma%>");
7499 else if (token == CPP_PRAGMA_EOL)
7500 message = catenate_messages (gmsgid, " before end of line");
7501 else if (token < N_TTYPES)
7503 message = catenate_messages (gmsgid, " before %qs token");
7504 error (message, cpp_type2name (token));
7516 #undef catenate_messages
7519 /* Walk a gimplified function and warn for functions whose return value is
7520 ignored and attribute((warn_unused_result)) is set. This is done before
7521 inlining, so we don't have to worry about that. */
7524 c_warn_unused_result (gimple_seq seq)
7527 gimple_stmt_iterator i;
7529 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
7531 gimple g = gsi_stmt (i);
7533 switch (gimple_code (g))
7536 c_warn_unused_result (gimple_bind_body (g));
7539 c_warn_unused_result (gimple_try_eval (g));
7540 c_warn_unused_result (gimple_try_cleanup (g));
7543 c_warn_unused_result (gimple_catch_handler (g));
7545 case GIMPLE_EH_FILTER:
7546 c_warn_unused_result (gimple_eh_filter_failure (g));
7550 if (gimple_call_lhs (g))
7553 /* This is a naked call, as opposed to a GIMPLE_CALL with an
7554 LHS. All calls whose value is ignored should be
7555 represented like this. Look for the attribute. */
7556 fdecl = gimple_call_fndecl (g);
7557 ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
7559 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
7561 location_t loc = gimple_location (g);
7564 warning (0, "%Hignoring return value of %qD, "
7565 "declared with attribute warn_unused_result",
7568 warning (0, "%Hignoring return value of function "
7569 "declared with attribute warn_unused_result",
7575 /* Not a container, not a call, or a call whose value is used. */
7581 /* Convert a character from the host to the target execution character
7582 set. cpplib handles this, mostly. */
7585 c_common_to_target_charset (HOST_WIDE_INT c)
7587 /* Character constants in GCC proper are sign-extended under -fsigned-char,
7588 zero-extended under -fno-signed-char. cpplib insists that characters
7589 and character constants are always unsigned. Hence we must convert
7591 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
7593 uc = cpp_host_to_exec_charset (parse_in, uc);
7595 if (flag_signed_char)
7596 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
7597 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
7602 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
7603 component references, with STOP_REF, or alternatively an INDIRECT_REF of
7604 NULL, at the bottom; much like the traditional rendering of offsetof as a
7605 macro. Returns the folded and properly cast result. */
7608 fold_offsetof_1 (tree expr, tree stop_ref)
7610 enum tree_code code = PLUS_EXPR;
7613 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
7614 return size_zero_node;
7616 switch (TREE_CODE (expr))
7622 error ("cannot apply %<offsetof%> to static data member %qD", expr);
7623 return error_mark_node;
7627 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7628 return error_mark_node;
7632 if (!integer_zerop (TREE_OPERAND (expr, 0)))
7634 error ("cannot apply %<offsetof%> to a non constant address");
7635 return error_mark_node;
7637 return size_zero_node;
7640 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7641 if (base == error_mark_node)
7644 t = TREE_OPERAND (expr, 1);
7645 if (DECL_C_BIT_FIELD (t))
7647 error ("attempt to take address of bit-field structure "
7649 return error_mark_node;
7651 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
7652 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
7657 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7658 if (base == error_mark_node)
7661 t = TREE_OPERAND (expr, 1);
7662 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
7665 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
7667 t = convert (sizetype, t);
7668 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
7672 /* Handle static members of volatile structs. */
7673 t = TREE_OPERAND (expr, 1);
7674 gcc_assert (TREE_CODE (t) == VAR_DECL);
7675 return fold_offsetof_1 (t, stop_ref);
7681 return size_binop (code, base, off);
7685 fold_offsetof (tree expr, tree stop_ref)
7687 /* Convert back from the internal sizetype to size_t. */
7688 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
7691 /* Print an error message for an invalid lvalue. USE says
7692 how the lvalue is being used and so selects the error message. */
7695 lvalue_error (enum lvalue_use use)
7700 error ("lvalue required as left operand of assignment");
7703 error ("lvalue required as increment operand");
7706 error ("lvalue required as decrement operand");
7709 error ("lvalue required as unary %<&%> operand");
7712 error ("lvalue required in asm statement");
7719 /* *PTYPE is an incomplete array. Complete it with a domain based on
7720 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7721 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7722 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
7725 complete_array_type (tree *ptype, tree initial_value, bool do_default)
7727 tree maxindex, type, main_type, elt, unqual_elt;
7728 int failure = 0, quals;
7729 hashval_t hashcode = 0;
7731 maxindex = size_zero_node;
7734 if (TREE_CODE (initial_value) == STRING_CST)
7737 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7738 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
7740 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7742 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
7744 if (VEC_empty (constructor_elt, v))
7748 maxindex = integer_minus_one_node;
7753 unsigned HOST_WIDE_INT cnt;
7754 constructor_elt *ce;
7755 bool fold_p = false;
7757 if (VEC_index (constructor_elt, v, 0)->index)
7758 maxindex = fold_convert (sizetype,
7759 VEC_index (constructor_elt,
7761 curindex = maxindex;
7764 VEC_iterate (constructor_elt, v, cnt, ce);
7767 bool curfold_p = false;
7769 curindex = ce->index, curfold_p = true;
7773 curindex = fold_convert (sizetype, curindex);
7774 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
7776 if (tree_int_cst_lt (maxindex, curindex))
7777 maxindex = curindex, fold_p = curfold_p;
7780 maxindex = fold_convert (sizetype, maxindex);
7785 /* Make an error message unless that happened already. */
7786 if (initial_value != error_mark_node)
7798 elt = TREE_TYPE (type);
7799 quals = TYPE_QUALS (strip_array_types (elt));
7803 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
7805 /* Using build_distinct_type_copy and modifying things afterward instead
7806 of using build_array_type to create a new type preserves all of the
7807 TYPE_LANG_FLAG_? bits that the front end may have set. */
7808 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7809 TREE_TYPE (main_type) = unqual_elt;
7810 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
7811 layout_type (main_type);
7813 /* Make sure we have the canonical MAIN_TYPE. */
7814 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
7815 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
7817 main_type = type_hash_canon (hashcode, main_type);
7819 /* Fix the canonical type. */
7820 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
7821 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
7822 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
7823 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
7824 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
7825 != TYPE_DOMAIN (main_type)))
7826 TYPE_CANONICAL (main_type)
7827 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
7828 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
7830 TYPE_CANONICAL (main_type) = main_type;
7835 type = c_build_qualified_type (main_type, quals);
7837 if (COMPLETE_TYPE_P (type)
7838 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7839 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7841 error ("size of array is too large");
7842 /* If we proceed with the array type as it is, we'll eventually
7843 crash in tree_low_cst(). */
7844 type = error_mark_node;
7852 /* Used to help initialize the builtin-types.def table. When a type of
7853 the correct size doesn't exist, use error_mark_node instead of NULL.
7854 The later results in segfaults even when a decl using the type doesn't
7858 builtin_type_for_size (int size, bool unsignedp)
7860 tree type = lang_hooks.types.type_for_size (size, unsignedp);
7861 return type ? type : error_mark_node;
7864 /* A helper function for resolve_overloaded_builtin in resolving the
7865 overloaded __sync_ builtins. Returns a positive power of 2 if the
7866 first operand of PARAMS is a pointer to a supported data type.
7867 Returns 0 if an error is encountered. */
7870 sync_resolve_size (tree function, tree params)
7877 error ("too few arguments to function %qE", function);
7881 type = TREE_TYPE (TREE_VALUE (params));
7882 if (TREE_CODE (type) != POINTER_TYPE)
7885 type = TREE_TYPE (type);
7886 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
7889 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7890 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
7894 error ("incompatible type for argument %d of %qE", 1, function);
7898 /* A helper function for resolve_overloaded_builtin. Adds casts to
7899 PARAMS to make arguments match up with those of FUNCTION. Drops
7900 the variadic arguments at the end. Returns false if some error
7901 was encountered; true on success. */
7904 sync_resolve_params (tree orig_function, tree function, tree params)
7906 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
7910 /* We've declared the implementation functions to use "volatile void *"
7911 as the pointer parameter, so we shouldn't get any complaints from the
7912 call to check_function_arguments what ever type the user used. */
7913 arg_types = TREE_CHAIN (arg_types);
7914 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7917 /* For the rest of the values, we need to cast these to FTYPE, so that we
7918 don't get warnings for passing pointer types, etc. */
7919 while (arg_types != void_list_node)
7923 params = TREE_CHAIN (params);
7926 error ("too few arguments to function %qE", orig_function);
7930 /* ??? Ideally for the first conversion we'd use convert_for_assignment
7931 so that we get warnings for anything that doesn't match the pointer
7932 type. This isn't portable across the C and C++ front ends atm. */
7933 val = TREE_VALUE (params);
7934 val = convert (ptype, val);
7935 val = convert (TREE_VALUE (arg_types), val);
7936 TREE_VALUE (params) = val;
7938 arg_types = TREE_CHAIN (arg_types);
7942 /* The definition of these primitives is variadic, with the remaining
7943 being "an optional list of variables protected by the memory barrier".
7944 No clue what that's supposed to mean, precisely, but we consider all
7945 call-clobbered variables to be protected so we're safe. */
7946 TREE_CHAIN (params) = NULL;
7951 /* A helper function for resolve_overloaded_builtin. Adds a cast to
7952 RESULT to make it match the type of the first pointer argument in
7956 sync_resolve_return (tree params, tree result)
7958 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7959 ptype = TYPE_MAIN_VARIANT (ptype);
7960 return convert (ptype, result);
7963 /* Some builtin functions are placeholders for other expressions. This
7964 function should be called immediately after parsing the call expression
7965 before surrounding code has committed to the type of the expression.
7967 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7968 PARAMS is the argument list for the call. The return value is non-null
7969 when expansion is complete, and null if normal processing should
7973 resolve_overloaded_builtin (tree function, tree params)
7975 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
7976 switch (DECL_BUILT_IN_CLASS (function))
7978 case BUILT_IN_NORMAL:
7981 if (targetm.resolve_overloaded_builtin)
7982 return targetm.resolve_overloaded_builtin (function, params);
7989 /* Handle BUILT_IN_NORMAL here. */
7992 case BUILT_IN_FETCH_AND_ADD_N:
7993 case BUILT_IN_FETCH_AND_SUB_N:
7994 case BUILT_IN_FETCH_AND_OR_N:
7995 case BUILT_IN_FETCH_AND_AND_N:
7996 case BUILT_IN_FETCH_AND_XOR_N:
7997 case BUILT_IN_FETCH_AND_NAND_N:
7998 case BUILT_IN_ADD_AND_FETCH_N:
7999 case BUILT_IN_SUB_AND_FETCH_N:
8000 case BUILT_IN_OR_AND_FETCH_N:
8001 case BUILT_IN_AND_AND_FETCH_N:
8002 case BUILT_IN_XOR_AND_FETCH_N:
8003 case BUILT_IN_NAND_AND_FETCH_N:
8004 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8005 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8006 case BUILT_IN_LOCK_TEST_AND_SET_N:
8007 case BUILT_IN_LOCK_RELEASE_N:
8009 int n = sync_resolve_size (function, params);
8010 tree new_function, result;
8013 return error_mark_node;
8015 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8016 if (!sync_resolve_params (function, new_function, params))
8017 return error_mark_node;
8019 result = build_function_call (new_function, params);
8020 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8021 && orig_code != BUILT_IN_LOCK_RELEASE_N)
8022 result = sync_resolve_return (params, result);
8032 /* Ignoring their sign, return true if two scalar types are the same. */
8034 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8036 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8038 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8039 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8040 || c2 == FIXED_POINT_TYPE));
8042 /* Equality works here because c_common_signed_type uses
8043 TYPE_MAIN_VARIANT. */
8044 return c_common_signed_type (t1)
8045 == c_common_signed_type (t2);
8048 /* Check for missing format attributes on function pointers. LTYPE is
8049 the new type or left-hand side type. RTYPE is the old type or
8050 right-hand side type. Returns TRUE if LTYPE is missing the desired
8054 check_missing_format_attribute (tree ltype, tree rtype)
8056 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8059 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8060 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8065 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8066 if (is_attribute_p ("format", TREE_PURPOSE (la)))
8074 /* Subscripting with type char is likely to lose on a machine where
8075 chars are signed. So warn on any machine, but optionally. Don't
8076 warn for unsigned char since that type is safe. Don't warn for
8077 signed char because anyone who uses that must have done so
8078 deliberately. Furthermore, we reduce the false positive load by
8079 warning only for non-constant value of type char. */
8082 warn_array_subscript_with_type_char (tree index)
8084 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8085 && TREE_CODE (index) != INTEGER_CST)
8086 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8089 /* Implement -Wparentheses for the unexpected C precedence rules, to
8090 cover cases like x + y << z which readers are likely to
8091 misinterpret. We have seen an expression in which CODE is a binary
8092 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8093 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8094 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8095 expression was not formed using a binary or unary operator, or it
8096 was enclosed in parentheses. */
8099 warn_about_parentheses (enum tree_code code,
8100 enum tree_code code_left, tree arg_left,
8101 enum tree_code code_right, tree arg_right)
8103 if (!warn_parentheses)
8106 /* This macro tests that the expression ARG with original tree code
8107 CODE appears to be a boolean expression. or the result of folding a
8108 boolean expression. */
8109 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8110 (truth_value_p (TREE_CODE (ARG)) \
8111 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8112 /* Folding may create 0 or 1 integers from other expressions. */ \
8113 || ((CODE) != INTEGER_CST \
8114 && (integer_onep (ARG) || integer_zerop (ARG))))
8119 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8120 warning (OPT_Wparentheses,
8121 "suggest parentheses around %<+%> inside %<<<%>");
8122 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8123 warning (OPT_Wparentheses,
8124 "suggest parentheses around %<-%> inside %<<<%>");
8128 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8129 warning (OPT_Wparentheses,
8130 "suggest parentheses around %<+%> inside %<>>%>");
8131 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8132 warning (OPT_Wparentheses,
8133 "suggest parentheses around %<-%> inside %<>>%>");
8136 case TRUTH_ORIF_EXPR:
8137 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8138 warning (OPT_Wparentheses,
8139 "suggest parentheses around %<&&%> within %<||%>");
8143 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8144 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8145 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8146 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8147 warning (OPT_Wparentheses,
8148 "suggest parentheses around arithmetic in operand of %<|%>");
8149 /* Check cases like x|y==z */
8150 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8151 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8152 warning (OPT_Wparentheses,
8153 "suggest parentheses around comparison in operand of %<|%>");
8154 /* Check cases like !x | y */
8155 else if (code_left == TRUTH_NOT_EXPR
8156 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8157 warning (OPT_Wparentheses, "suggest parentheses around operand of "
8158 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8162 if (code_left == BIT_AND_EXPR
8163 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8164 || code_right == BIT_AND_EXPR
8165 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8166 warning (OPT_Wparentheses,
8167 "suggest parentheses around arithmetic in operand of %<^%>");
8168 /* Check cases like x^y==z */
8169 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8170 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8171 warning (OPT_Wparentheses,
8172 "suggest parentheses around comparison in operand of %<^%>");
8176 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8177 warning (OPT_Wparentheses,
8178 "suggest parentheses around %<+%> in operand of %<&%>");
8179 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8180 warning (OPT_Wparentheses,
8181 "suggest parentheses around %<-%> 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 (TREE_CODE_CLASS (code_left) == tcc_comparison
8196 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8197 warning (OPT_Wparentheses,
8198 "suggest parentheses around comparison in operand of %<==%>");
8201 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8202 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8203 warning (OPT_Wparentheses,
8204 "suggest parentheses around comparison in operand of %<!=%>");
8208 if (TREE_CODE_CLASS (code) == tcc_comparison
8209 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
8210 && code_left != NE_EXPR && code_left != EQ_EXPR
8211 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
8212 || (TREE_CODE_CLASS (code_right) == tcc_comparison
8213 && code_right != NE_EXPR && code_right != EQ_EXPR
8214 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
8215 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
8216 "have their mathematical meaning");
8219 #undef NOT_A_BOOLEAN_EXPR_P
8222 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8225 warn_for_unused_label (tree label)
8227 if (!TREE_USED (label))
8229 if (DECL_INITIAL (label))
8230 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
8232 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
8236 #ifndef TARGET_HAS_TARGETCM
8237 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
8240 /* Warn for division by zero according to the value of DIVISOR. LOC
8241 is the location of the division operator. */
8244 warn_for_div_by_zero (location_t loc, tree divisor)
8246 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8247 about division by zero. Do not issue a warning if DIVISOR has a
8248 floating-point type, since we consider 0.0/0.0 a valid way of
8249 generating a NaN. */
8250 if (skip_evaluation == 0
8251 && (integer_zerop (divisor) || fixed_zerop (divisor)))
8252 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
8255 /* Subroutine of build_binary_op. Give warnings for comparisons
8256 between signed and unsigned quantities that may fail. Do the
8257 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8258 so that casts will be considered, but default promotions won't
8261 LOCATION is the location of the comparison operator.
8263 The arguments of this function map directly to local variables
8264 of build_binary_op. */
8267 warn_for_sign_compare (location_t location,
8268 tree orig_op0, tree orig_op1,
8270 tree result_type, enum tree_code resultcode)
8272 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
8273 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
8274 int unsignedp0, unsignedp1;
8276 /* In C++, check for comparison of different enum types. */
8278 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
8279 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
8280 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
8281 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
8283 warning_at (location,
8284 OPT_Wsign_compare, "comparison between types %qT and %qT",
8285 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
8288 /* Do not warn if the comparison is being done in a signed type,
8289 since the signed type will only be chosen if it can represent
8290 all the values of the unsigned type. */
8291 if (!TYPE_UNSIGNED (result_type))
8293 /* Do not warn if both operands are unsigned. */
8294 else if (op0_signed == op1_signed)
8298 tree sop, uop, base_type;
8302 sop = orig_op0, uop = orig_op1;
8304 sop = orig_op1, uop = orig_op0;
8306 STRIP_TYPE_NOPS (sop);
8307 STRIP_TYPE_NOPS (uop);
8308 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
8309 ? TREE_TYPE (result_type) : result_type);
8311 /* Do not warn if the signed quantity is an unsuffixed integer
8312 literal (or some static constant expression involving such
8313 literals or a conditional expression involving such literals)
8314 and it is non-negative. */
8315 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
8317 /* Do not warn if the comparison is an equality operation, the
8318 unsigned quantity is an integral constant, and it would fit
8319 in the result if the result were signed. */
8320 else if (TREE_CODE (uop) == INTEGER_CST
8321 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
8322 && int_fits_type_p (uop, c_common_signed_type (base_type)))
8324 /* In C, do not warn if the unsigned quantity is an enumeration
8325 constant and its maximum value would fit in the result if the
8326 result were signed. */
8327 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
8328 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
8329 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
8330 c_common_signed_type (base_type)))
8333 warning_at (location,
8335 "comparison between signed and unsigned integer expressions");
8338 /* Warn if two unsigned values are being compared in a size larger
8339 than their original size, and one (and only one) is the result of
8340 a `~' operator. This comparison will always fail.
8342 Also warn if one operand is a constant, and the constant does not
8343 have all bits set that are set in the ~ operand when it is
8346 op0 = get_narrower (op0, &unsignedp0);
8347 op1 = get_narrower (op1, &unsignedp1);
8349 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
8350 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
8352 if (TREE_CODE (op0) == BIT_NOT_EXPR)
8353 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
8354 if (TREE_CODE (op1) == BIT_NOT_EXPR)
8355 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
8357 if (host_integerp (op0, 0) || host_integerp (op1, 0))
8360 HOST_WIDE_INT constant, mask;
8364 if (host_integerp (op0, 0))
8367 unsignedp = unsignedp1;
8368 constant = tree_low_cst (op0, 0);
8373 unsignedp = unsignedp0;
8374 constant = tree_low_cst (op1, 0);
8377 bits = TYPE_PRECISION (TREE_TYPE (primop));
8378 if (bits < TYPE_PRECISION (result_type)
8379 && bits < HOST_BITS_PER_LONG && unsignedp)
8381 mask = (~ (HOST_WIDE_INT) 0) << bits;
8382 if ((mask & constant) != mask)
8385 warning (OPT_Wsign_compare,
8386 "promoted ~unsigned is always non-zero");
8388 warning_at (location, OPT_Wsign_compare,
8389 "comparison of promoted ~unsigned with constant");
8393 else if (unsignedp0 && unsignedp1
8394 && (TYPE_PRECISION (TREE_TYPE (op0))
8395 < TYPE_PRECISION (result_type))
8396 && (TYPE_PRECISION (TREE_TYPE (op1))
8397 < TYPE_PRECISION (result_type)))
8398 warning_at (location, OPT_Wsign_compare,
8399 "comparison of promoted ~unsigned with unsigned");
8403 /* Record the types used by the current global variable declaration
8404 being parsed, so that we can decide later to emit their debug info.
8405 Those types are in types_used_by_cur_var_decl, and we are going to
8406 store them in the types_used_by_vars_hash hash table.
8407 DECL is the declaration of the global variable that has been parsed. */
8410 record_types_used_by_current_var_decl (tree decl)
8412 gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
8414 if (types_used_by_cur_var_decl)
8417 for (node = types_used_by_cur_var_decl;
8419 node = TREE_CHAIN (node))
8421 tree type = TREE_PURPOSE (node);
8422 types_used_by_var_decl_insert (type, decl);
8424 types_used_by_cur_var_decl = NULL;
8428 #include "gt-c-common.h"