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, 2010, 2011
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"
38 #include "langhooks.h"
39 #include "tree-inline.h"
41 #include "diagnostic.h"
42 #include "tree-iterator.h"
44 #include "tree-mudflap.h"
47 #include "target-def.h"
50 cpp_reader *parse_in; /* Declared in c-pragma.h. */
52 /* The following symbols are subsumed in the c_global_trees array, and
53 listed here individually for documentation purposes.
55 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
57 tree short_integer_type_node;
58 tree long_integer_type_node;
59 tree long_long_integer_type_node;
60 tree int128_integer_type_node;
62 tree short_unsigned_type_node;
63 tree long_unsigned_type_node;
64 tree long_long_unsigned_type_node;
65 tree int128_unsigned_type_node;
67 tree truthvalue_type_node;
68 tree truthvalue_false_node;
69 tree truthvalue_true_node;
71 tree ptrdiff_type_node;
73 tree unsigned_char_type_node;
74 tree signed_char_type_node;
77 tree char16_type_node;
78 tree char32_type_node;
81 tree double_type_node;
82 tree long_double_type_node;
84 tree complex_integer_type_node;
85 tree complex_float_type_node;
86 tree complex_double_type_node;
87 tree complex_long_double_type_node;
89 tree dfloat32_type_node;
90 tree dfloat64_type_node;
91 tree_dfloat128_type_node;
99 tree unsigned_intQI_type_node;
100 tree unsigned_intHI_type_node;
101 tree unsigned_intSI_type_node;
102 tree unsigned_intDI_type_node;
103 tree unsigned_intTI_type_node;
105 tree widest_integer_literal_type_node;
106 tree widest_unsigned_literal_type_node;
108 Nodes for types `void *' and `const void *'.
110 tree ptr_type_node, const_ptr_type_node;
112 Nodes for types `char *' and `const char *'.
114 tree string_type_node, const_string_type_node;
116 Type `char[SOMENUMBER]'.
117 Used when an array of char is needed and the size is irrelevant.
119 tree char_array_type_node;
121 Type `int[SOMENUMBER]' or something like it.
122 Used when an array of int needed and the size is irrelevant.
124 tree int_array_type_node;
126 Type `wchar_t[SOMENUMBER]' or something like it.
127 Used when a wide string literal is created.
129 tree wchar_array_type_node;
131 Type `char16_t[SOMENUMBER]' or something like it.
132 Used when a UTF-16 string literal is created.
134 tree char16_array_type_node;
136 Type `char32_t[SOMENUMBER]' or something like it.
137 Used when a UTF-32 string literal is created.
139 tree char32_array_type_node;
141 Type `int ()' -- used for implicit declaration of functions.
143 tree default_function_type;
145 A VOID_TYPE node, packaged in a TREE_LIST.
149 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
150 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
151 VAR_DECLS, but C++ does.)
153 tree function_name_decl_node;
154 tree pretty_function_name_decl_node;
155 tree c99_function_name_decl_node;
157 Stack of nested function name VAR_DECLs.
159 tree saved_function_name_decls;
163 tree c_global_trees[CTI_MAX];
165 /* Switches common to the C front ends. */
167 /* Nonzero means don't output line number information. */
169 char flag_no_line_commands;
171 /* Nonzero causes -E output not to be done, but directives such as
172 #define that have side effects are still obeyed. */
176 /* Nonzero means dump macros in some fashion. */
178 char flag_dump_macros;
180 /* Nonzero means pass #include lines through to the output. */
182 char flag_dump_includes;
184 /* Nonzero means process PCH files while preprocessing. */
186 bool flag_pch_preprocess;
188 /* The file name to which we should write a precompiled header, or
189 NULL if no header will be written in this compile. */
191 const char *pch_file;
193 /* Nonzero if an ISO standard was selected. It rejects macros in the
197 /* Warn about #pragma directives that are not recognized. */
199 int warn_unknown_pragmas; /* Tri state variable. */
201 /* Warn about format/argument anomalies in calls to formatted I/O functions
202 (*printf, *scanf, strftime, strfmon, etc.). */
206 /* C/ObjC language option variables. */
209 /* Nonzero means allow type mismatches in conditional expressions;
210 just make their values `void'. */
212 int flag_cond_mismatch;
214 /* Nonzero means enable C89 Amendment 1 features. */
218 /* Nonzero means use the ISO C99 (or C1X) dialect of C. */
222 /* Nonzero means use the ISO C1X dialect of C. */
226 /* Nonzero means that we have builtin functions, and main is an int. */
231 /* ObjC language option variables. */
234 /* Tells the compiler that this is a special run. Do not perform any
235 compiling, instead we are to test some platform dependent features
236 and output a C header file with appropriate definitions. */
238 int print_struct_values;
240 /* Tells the compiler what is the constant string class for ObjC. */
242 const char *constant_string_class_name;
245 /* C++ language option variables. */
248 /* Nonzero means generate separate instantiation control files and
249 juggle them at link time. */
251 int flag_use_repository;
253 /* The C++ dialect being used. C++98 is the default. */
255 enum cxx_dialect cxx_dialect = cxx98;
257 /* Maximum template instantiation depth. This limit exists to limit the
258 time it takes to notice infinite template instantiations; the default
259 value of 1024 is likely to be in the next C++ standard. */
261 int max_tinst_depth = 1024;
265 /* The elements of `ridpointers' are identifier nodes for the reserved
266 type names and storage classes. It is indexed by a RID_... value. */
269 tree (*make_fname_decl) (location_t, tree, int);
271 /* Nonzero means don't warn about problems that occur when the code is
273 int c_inhibit_evaluation_warnings;
275 /* Whether we are building a boolean conversion inside
276 convert_for_assignment, or some other late binary operation. If
277 build_binary_op is called for C (from code shared by C and C++) in
278 this case, then the operands have already been folded and the
279 result will not be folded again, so C_MAYBE_CONST_EXPR should not
281 bool in_late_binary_op;
283 /* Whether lexing has been completed, so subsequent preprocessor
284 errors should use the compiler's input_location. */
285 bool done_lexing = false;
287 /* Information about how a function name is generated. */
290 tree *const decl; /* pointer to the VAR_DECL. */
291 const unsigned rid; /* RID number for the identifier. */
292 const int pretty; /* How pretty is it? */
295 /* The three ways of getting then name of the current function. */
297 const struct fname_var_t fname_vars[] =
299 /* C99 compliant __func__, must be first. */
300 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
301 /* GCC __FUNCTION__ compliant. */
302 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
303 /* GCC __PRETTY_FUNCTION__ compliant. */
304 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
308 /* Global visibility options. */
309 struct visibility_flags visibility_options;
311 static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
312 static tree check_case_value (tree);
313 static bool check_case_bounds (tree, tree, tree *, tree *);
315 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
316 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
317 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
318 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
319 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
320 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
321 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
322 static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
323 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
324 static tree handle_always_inline_attribute (tree *, tree, tree, int,
326 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
327 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
328 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
329 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
330 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
331 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
332 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
334 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
335 static tree handle_transparent_union_attribute (tree *, tree, tree,
337 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
338 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
339 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
340 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
341 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
342 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
343 static tree handle_alias_ifunc_attribute (bool, tree *, tree, tree, bool *);
344 static tree handle_ifunc_attribute (tree *, tree, tree, int, bool *);
345 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
346 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
347 static tree handle_visibility_attribute (tree *, tree, tree, int,
349 static tree handle_tls_model_attribute (tree *, tree, tree, int,
351 static tree handle_no_instrument_function_attribute (tree *, tree,
353 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
354 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
355 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
357 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
358 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
359 static tree handle_deprecated_attribute (tree *, tree, tree, int,
361 static tree handle_vector_size_attribute (tree *, tree, tree, int,
363 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
364 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
365 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
366 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
368 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
369 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
370 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
371 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
372 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
373 static tree handle_no_split_stack_attribute (tree *, tree, tree, int, bool *);
374 static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
376 static void check_function_nonnull (tree, int, tree *);
377 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
378 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
379 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
380 static int resort_field_decl_cmp (const void *, const void *);
382 /* Reserved words. The third field is a mask: keywords are disabled
383 if they match the mask.
386 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
387 C --std=c99: D_CXXONLY | D_OBJC
388 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
389 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
390 C++ --std=c0x: D_CONLY | D_OBJC
391 ObjC++ is like C++ except that D_OBJC is not set
393 If -fno-asm is used, D_ASM is added to the mask. If
394 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
395 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
396 In C with -Wc++-compat, we warn if D_CXXWARN is set.
398 Note the complication of the D_CXX_OBJC keywords. These are
399 reserved words such as 'class'. In C++, 'class' is a reserved
400 word. In Objective-C++ it is too. In Objective-C, it is a
401 reserved word too, but only if it follows an '@' sign.
403 const struct c_common_resword c_common_reswords[] =
405 { "_Bool", RID_BOOL, D_CONLY },
406 { "_Complex", RID_COMPLEX, 0 },
407 { "_Imaginary", RID_IMAGINARY, D_CONLY },
408 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
409 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
410 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
411 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
412 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
413 { "_Sat", RID_SAT, D_CONLY | D_EXT },
414 { "_Static_assert", RID_STATIC_ASSERT, D_CONLY },
415 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
416 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
417 { "__alignof", RID_ALIGNOF, 0 },
418 { "__alignof__", RID_ALIGNOF, 0 },
419 { "__asm", RID_ASM, 0 },
420 { "__asm__", RID_ASM, 0 },
421 { "__attribute", RID_ATTRIBUTE, 0 },
422 { "__attribute__", RID_ATTRIBUTE, 0 },
423 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
424 { "__builtin_offsetof", RID_OFFSETOF, 0 },
425 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
426 { "__builtin_va_arg", RID_VA_ARG, 0 },
427 { "__complex", RID_COMPLEX, 0 },
428 { "__complex__", RID_COMPLEX, 0 },
429 { "__const", RID_CONST, 0 },
430 { "__const__", RID_CONST, 0 },
431 { "__decltype", RID_DECLTYPE, D_CXXONLY },
432 { "__extension__", RID_EXTENSION, 0 },
433 { "__func__", RID_C99_FUNCTION_NAME, 0 },
434 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
435 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
436 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
437 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
438 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
439 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
440 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
441 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
442 { "__int128", RID_INT128, 0 },
443 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
444 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
445 { "__is_class", RID_IS_CLASS, D_CXXONLY },
446 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
447 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
448 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
449 { "__is_pod", RID_IS_POD, D_CXXONLY },
450 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
451 { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY },
452 { "__is_trivial", RID_IS_TRIVIAL, D_CXXONLY },
453 { "__is_union", RID_IS_UNION, D_CXXONLY },
454 { "__is_literal_type", RID_IS_LITERAL_TYPE, D_CXXONLY },
455 { "__imag", RID_IMAGPART, 0 },
456 { "__imag__", RID_IMAGPART, 0 },
457 { "__inline", RID_INLINE, 0 },
458 { "__inline__", RID_INLINE, 0 },
459 { "__label__", RID_LABEL, 0 },
460 { "__null", RID_NULL, 0 },
461 { "__real", RID_REALPART, 0 },
462 { "__real__", RID_REALPART, 0 },
463 { "__restrict", RID_RESTRICT, 0 },
464 { "__restrict__", RID_RESTRICT, 0 },
465 { "__signed", RID_SIGNED, 0 },
466 { "__signed__", RID_SIGNED, 0 },
467 { "__thread", RID_THREAD, 0 },
468 { "__typeof", RID_TYPEOF, 0 },
469 { "__typeof__", RID_TYPEOF, 0 },
470 { "__volatile", RID_VOLATILE, 0 },
471 { "__volatile__", RID_VOLATILE, 0 },
472 { "alignof", RID_ALIGNOF, D_CXXONLY | D_CXX0X | D_CXXWARN },
473 { "asm", RID_ASM, D_ASM },
474 { "auto", RID_AUTO, 0 },
475 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
476 { "break", RID_BREAK, 0 },
477 { "case", RID_CASE, 0 },
478 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
479 { "char", RID_CHAR, 0 },
480 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
481 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
482 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
483 { "const", RID_CONST, 0 },
484 { "constexpr", RID_CONSTEXPR, D_CXXONLY | D_CXX0X | D_CXXWARN },
485 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
486 { "continue", RID_CONTINUE, 0 },
487 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
488 { "default", RID_DEFAULT, 0 },
489 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
491 { "double", RID_DOUBLE, 0 },
492 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
493 { "else", RID_ELSE, 0 },
494 { "enum", RID_ENUM, 0 },
495 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
496 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
497 { "extern", RID_EXTERN, 0 },
498 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
499 { "float", RID_FLOAT, 0 },
500 { "for", RID_FOR, 0 },
501 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
502 { "goto", RID_GOTO, 0 },
504 { "inline", RID_INLINE, D_EXT89 },
505 { "int", RID_INT, 0 },
506 { "long", RID_LONG, 0 },
507 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
508 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
509 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
510 { "noexcept", RID_NOEXCEPT, D_CXXONLY | D_CXX0X | D_CXXWARN },
511 { "nullptr", RID_NULLPTR, D_CXXONLY | D_CXX0X | D_CXXWARN },
512 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
513 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
514 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
515 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
516 { "register", RID_REGISTER, 0 },
517 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
518 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
519 { "return", RID_RETURN, 0 },
520 { "short", RID_SHORT, 0 },
521 { "signed", RID_SIGNED, 0 },
522 { "sizeof", RID_SIZEOF, 0 },
523 { "static", RID_STATIC, 0 },
524 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
525 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
526 { "struct", RID_STRUCT, 0 },
527 { "switch", RID_SWITCH, 0 },
528 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
529 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
530 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
531 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
532 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
533 { "typedef", RID_TYPEDEF, 0 },
534 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
535 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
536 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
537 { "union", RID_UNION, 0 },
538 { "unsigned", RID_UNSIGNED, 0 },
539 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
540 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
541 { "void", RID_VOID, 0 },
542 { "volatile", RID_VOLATILE, 0 },
543 { "wchar_t", RID_WCHAR, D_CXXONLY },
544 { "while", RID_WHILE, 0 },
545 /* These Objective-C keywords are recognized only immediately after
547 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
548 { "defs", RID_AT_DEFS, D_OBJC },
549 { "encode", RID_AT_ENCODE, D_OBJC },
550 { "end", RID_AT_END, D_OBJC },
551 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
552 { "interface", RID_AT_INTERFACE, D_OBJC },
553 { "protocol", RID_AT_PROTOCOL, D_OBJC },
554 { "selector", RID_AT_SELECTOR, D_OBJC },
555 { "finally", RID_AT_FINALLY, D_OBJC },
556 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
557 { "optional", RID_AT_OPTIONAL, D_OBJC },
558 { "required", RID_AT_REQUIRED, D_OBJC },
559 { "property", RID_AT_PROPERTY, D_OBJC },
560 { "package", RID_AT_PACKAGE, D_OBJC },
561 { "synthesize", RID_AT_SYNTHESIZE, D_OBJC },
562 { "dynamic", RID_AT_DYNAMIC, D_OBJC },
563 /* These are recognized only in protocol-qualifier context
565 { "bycopy", RID_BYCOPY, D_OBJC },
566 { "byref", RID_BYREF, D_OBJC },
567 { "in", RID_IN, D_OBJC },
568 { "inout", RID_INOUT, D_OBJC },
569 { "oneway", RID_ONEWAY, D_OBJC },
570 { "out", RID_OUT, D_OBJC },
571 /* These are recognized inside a property attribute list */
572 { "assign", RID_ASSIGN, D_OBJC },
573 { "copy", RID_COPY, D_OBJC },
574 { "getter", RID_GETTER, D_OBJC },
575 { "nonatomic", RID_NONATOMIC, D_OBJC },
576 { "readonly", RID_READONLY, D_OBJC },
577 { "readwrite", RID_READWRITE, D_OBJC },
578 { "retain", RID_RETAIN, D_OBJC },
579 { "setter", RID_SETTER, D_OBJC },
582 const unsigned int num_c_common_reswords =
583 sizeof c_common_reswords / sizeof (struct c_common_resword);
585 /* Table of machine-independent attributes common to all C-like languages. */
586 const struct attribute_spec c_common_attribute_table[] =
588 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
589 { "packed", 0, 0, false, false, false,
590 handle_packed_attribute },
591 { "nocommon", 0, 0, true, false, false,
592 handle_nocommon_attribute },
593 { "common", 0, 0, true, false, false,
594 handle_common_attribute },
595 /* FIXME: logically, noreturn attributes should be listed as
596 "false, true, true" and apply to function types. But implementing this
597 would require all the places in the compiler that use TREE_THIS_VOLATILE
598 on a decl to identify non-returning functions to be located and fixed
599 to check the function type instead. */
600 { "noreturn", 0, 0, true, false, false,
601 handle_noreturn_attribute },
602 { "volatile", 0, 0, true, false, false,
603 handle_noreturn_attribute },
604 { "noinline", 0, 0, true, false, false,
605 handle_noinline_attribute },
606 { "noclone", 0, 0, true, false, false,
607 handle_noclone_attribute },
608 { "leaf", 0, 0, true, false, false,
609 handle_leaf_attribute },
610 { "always_inline", 0, 0, true, false, false,
611 handle_always_inline_attribute },
612 { "gnu_inline", 0, 0, true, false, false,
613 handle_gnu_inline_attribute },
614 { "artificial", 0, 0, true, false, false,
615 handle_artificial_attribute },
616 { "flatten", 0, 0, true, false, false,
617 handle_flatten_attribute },
618 { "used", 0, 0, true, false, false,
619 handle_used_attribute },
620 { "unused", 0, 0, false, false, false,
621 handle_unused_attribute },
622 { "externally_visible", 0, 0, true, false, false,
623 handle_externally_visible_attribute },
624 /* The same comments as for noreturn attributes apply to const ones. */
625 { "const", 0, 0, true, false, false,
626 handle_const_attribute },
627 { "transparent_union", 0, 0, false, false, false,
628 handle_transparent_union_attribute },
629 { "constructor", 0, 1, true, false, false,
630 handle_constructor_attribute },
631 { "destructor", 0, 1, true, false, false,
632 handle_destructor_attribute },
633 { "mode", 1, 1, false, true, false,
634 handle_mode_attribute },
635 { "section", 1, 1, true, false, false,
636 handle_section_attribute },
637 { "aligned", 0, 1, false, false, false,
638 handle_aligned_attribute },
639 { "weak", 0, 0, true, false, false,
640 handle_weak_attribute },
641 { "ifunc", 1, 1, true, false, false,
642 handle_ifunc_attribute },
643 { "alias", 1, 1, true, false, false,
644 handle_alias_attribute },
645 { "weakref", 0, 1, true, false, false,
646 handle_weakref_attribute },
647 { "no_instrument_function", 0, 0, true, false, false,
648 handle_no_instrument_function_attribute },
649 { "malloc", 0, 0, true, false, false,
650 handle_malloc_attribute },
651 { "returns_twice", 0, 0, true, false, false,
652 handle_returns_twice_attribute },
653 { "no_stack_limit", 0, 0, true, false, false,
654 handle_no_limit_stack_attribute },
655 { "pure", 0, 0, true, false, false,
656 handle_pure_attribute },
657 /* For internal use (marking of builtins) only. The name contains space
658 to prevent its usage in source code. */
659 { "no vops", 0, 0, true, false, false,
660 handle_novops_attribute },
661 { "deprecated", 0, 1, false, false, false,
662 handle_deprecated_attribute },
663 { "vector_size", 1, 1, false, true, false,
664 handle_vector_size_attribute },
665 { "visibility", 1, 1, false, false, false,
666 handle_visibility_attribute },
667 { "tls_model", 1, 1, true, false, false,
668 handle_tls_model_attribute },
669 { "nonnull", 0, -1, false, true, true,
670 handle_nonnull_attribute },
671 { "nothrow", 0, 0, true, false, false,
672 handle_nothrow_attribute },
673 { "may_alias", 0, 0, false, true, false, NULL },
674 { "cleanup", 1, 1, true, false, false,
675 handle_cleanup_attribute },
676 { "warn_unused_result", 0, 0, false, true, true,
677 handle_warn_unused_result_attribute },
678 { "sentinel", 0, 1, false, true, true,
679 handle_sentinel_attribute },
680 /* For internal use (marking of builtins) only. The name contains space
681 to prevent its usage in source code. */
682 { "type generic", 0, 0, false, true, true,
683 handle_type_generic_attribute },
684 { "alloc_size", 1, 2, false, true, true,
685 handle_alloc_size_attribute },
686 { "cold", 0, 0, true, false, false,
687 handle_cold_attribute },
688 { "hot", 0, 0, true, false, false,
689 handle_hot_attribute },
690 { "warning", 1, 1, true, false, false,
691 handle_error_attribute },
692 { "error", 1, 1, true, false, false,
693 handle_error_attribute },
694 { "target", 1, -1, true, false, false,
695 handle_target_attribute },
696 { "optimize", 1, -1, true, false, false,
697 handle_optimize_attribute },
698 { "no_split_stack", 0, 0, true, false, false,
699 handle_no_split_stack_attribute },
700 /* For internal use (marking of builtins and runtime functions) only.
701 The name contains space to prevent its usage in source code. */
702 { "fn spec", 1, 1, false, true, true,
703 handle_fnspec_attribute },
704 { NULL, 0, 0, false, false, false, NULL }
707 /* Give the specifications for the format attributes, used by C and all
710 const struct attribute_spec c_common_format_attribute_table[] =
712 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
713 { "format", 3, 3, false, true, true,
714 handle_format_attribute },
715 { "format_arg", 1, 1, false, true, true,
716 handle_format_arg_attribute },
717 { NULL, 0, 0, false, false, false, NULL }
720 /* Return identifier for address space AS. */
723 c_addr_space_name (addr_space_t as)
725 int rid = RID_FIRST_ADDR_SPACE + as;
726 gcc_assert (ridpointers [rid]);
727 return IDENTIFIER_POINTER (ridpointers [rid]);
730 /* Push current bindings for the function name VAR_DECLS. */
733 start_fname_decls (void)
736 tree saved = NULL_TREE;
738 for (ix = 0; fname_vars[ix].decl; ix++)
740 tree decl = *fname_vars[ix].decl;
744 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
745 *fname_vars[ix].decl = NULL_TREE;
748 if (saved || saved_function_name_decls)
749 /* Normally they'll have been NULL, so only push if we've got a
750 stack, or they are non-NULL. */
751 saved_function_name_decls = tree_cons (saved, NULL_TREE,
752 saved_function_name_decls);
755 /* Finish up the current bindings, adding them into the current function's
756 statement tree. This must be done _before_ finish_stmt_tree is called.
757 If there is no current function, we must be at file scope and no statements
758 are involved. Pop the previous bindings. */
761 finish_fname_decls (void)
764 tree stmts = NULL_TREE;
765 tree stack = saved_function_name_decls;
767 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
768 append_to_statement_list (TREE_VALUE (stack), &stmts);
772 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
774 if (TREE_CODE (*bodyp) == BIND_EXPR)
775 bodyp = &BIND_EXPR_BODY (*bodyp);
777 append_to_statement_list_force (*bodyp, &stmts);
781 for (ix = 0; fname_vars[ix].decl; ix++)
782 *fname_vars[ix].decl = NULL_TREE;
786 /* We had saved values, restore them. */
789 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
791 tree decl = TREE_PURPOSE (saved);
792 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
794 *fname_vars[ix].decl = decl;
796 stack = TREE_CHAIN (stack);
798 saved_function_name_decls = stack;
801 /* Return the text name of the current function, suitably prettified
802 by PRETTY_P. Return string must be freed by caller. */
805 fname_as_string (int pretty_p)
807 const char *name = "top level";
810 cpp_string cstr = { 0, 0 }, strname;
818 if (current_function_decl)
819 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
821 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
823 namep = XNEWVEC (char, len);
824 snprintf (namep, len, "\"%s\"", name);
825 strname.text = (unsigned char *) namep;
826 strname.len = len - 1;
828 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
831 return (const char *) cstr.text;
837 /* Return the VAR_DECL for a const char array naming the current
838 function. If the VAR_DECL has not yet been created, create it
839 now. RID indicates how it should be formatted and IDENTIFIER_NODE
840 ID is its name (unfortunately C and C++ hold the RID values of
841 keywords in different places, so we can't derive RID from ID in
842 this language independent code. LOC is the location of the
846 fname_decl (location_t loc, unsigned int rid, tree id)
849 tree decl = NULL_TREE;
851 for (ix = 0; fname_vars[ix].decl; ix++)
852 if (fname_vars[ix].rid == rid)
855 decl = *fname_vars[ix].decl;
858 /* If a tree is built here, it would normally have the lineno of
859 the current statement. Later this tree will be moved to the
860 beginning of the function and this line number will be wrong.
861 To avoid this problem set the lineno to 0 here; that prevents
862 it from appearing in the RTL. */
864 location_t saved_location = input_location;
865 input_location = UNKNOWN_LOCATION;
867 stmts = push_stmt_list ();
868 decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty);
869 stmts = pop_stmt_list (stmts);
870 if (!IS_EMPTY_STMT (stmts))
871 saved_function_name_decls
872 = tree_cons (decl, stmts, saved_function_name_decls);
873 *fname_vars[ix].decl = decl;
874 input_location = saved_location;
876 if (!ix && !current_function_decl)
877 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
882 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
885 fix_string_type (tree value)
887 int length = TREE_STRING_LENGTH (value);
889 tree e_type, i_type, a_type;
891 /* Compute the number of elements, for the array type. */
892 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
895 e_type = char_type_node;
897 else if (TREE_TYPE (value) == char16_array_type_node)
899 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
900 e_type = char16_type_node;
902 else if (TREE_TYPE (value) == char32_array_type_node)
904 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
905 e_type = char32_type_node;
909 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
910 e_type = wchar_type_node;
913 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
914 limit in C++98 Annex B is very large (65536) and is not normative,
915 so we do not diagnose it (warn_overlength_strings is forced off
916 in c_common_post_options). */
917 if (warn_overlength_strings)
919 const int nchars_max = flag_isoc99 ? 4095 : 509;
920 const int relevant_std = flag_isoc99 ? 99 : 90;
921 if (nchars - 1 > nchars_max)
922 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
923 separate the %d from the 'C'. 'ISO' should not be
924 translated, but it may be moved after 'C%d' in languages
925 where modifiers follow nouns. */
926 pedwarn (input_location, OPT_Woverlength_strings,
927 "string length %qd is greater than the length %qd "
928 "ISO C%d compilers are required to support",
929 nchars - 1, nchars_max, relevant_std);
932 /* Create the array type for the string constant. The ISO C++
933 standard says that a string literal has type `const char[N]' or
934 `const wchar_t[N]'. We use the same logic when invoked as a C
935 front-end with -Wwrite-strings.
936 ??? We should change the type of an expression depending on the
937 state of a warning flag. We should just be warning -- see how
938 this is handled in the C++ front-end for the deprecated implicit
939 conversion from string literals to `char*' or `wchar_t*'.
941 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
942 array type being the unqualified version of that type.
943 Therefore, if we are constructing an array of const char, we must
944 construct the matching unqualified array type first. The C front
945 end does not require this, but it does no harm, so we do it
947 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
948 a_type = build_array_type (e_type, i_type);
949 if (c_dialect_cxx() || warn_write_strings)
950 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
952 TREE_TYPE (value) = a_type;
953 TREE_CONSTANT (value) = 1;
954 TREE_READONLY (value) = 1;
955 TREE_STATIC (value) = 1;
959 /* Fully fold EXPR, an expression that was not folded (beyond integer
960 constant expressions and null pointer constants) when being built
961 up. If IN_INIT, this is in a static initializer and certain
962 changes are made to the folding done. Clear *MAYBE_CONST if
963 MAYBE_CONST is not NULL and EXPR is definitely not a constant
964 expression because it contains an evaluated operator (in C99) or an
965 operator outside of sizeof returning an integer constant (in C90)
966 not permitted in constant expressions, or because it contains an
967 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
968 set to true by callers before calling this function.) Return the
969 folded expression. Function arguments have already been folded
970 before calling this function, as have the contents of SAVE_EXPR,
971 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
972 C_MAYBE_CONST_EXPR. */
975 c_fully_fold (tree expr, bool in_init, bool *maybe_const)
978 tree eptype = NULL_TREE;
980 bool maybe_const_itself = true;
981 location_t loc = EXPR_LOCATION (expr);
983 /* This function is not relevant to C++ because C++ folds while
984 parsing, and may need changes to be correct for C++ when C++
985 stops folding while parsing. */
986 if (c_dialect_cxx ())
990 maybe_const = &dummy;
991 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
993 eptype = TREE_TYPE (expr);
994 expr = TREE_OPERAND (expr, 0);
996 ret = c_fully_fold_internal (expr, in_init, maybe_const,
997 &maybe_const_itself);
999 ret = fold_convert_loc (loc, eptype, ret);
1000 *maybe_const &= maybe_const_itself;
1004 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1005 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1006 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1007 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1008 both evaluated and unevaluated subexpressions while
1009 *MAYBE_CONST_ITSELF is carried from only evaluated
1013 c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1014 bool *maybe_const_itself)
1017 enum tree_code code = TREE_CODE (expr);
1018 enum tree_code_class kind = TREE_CODE_CLASS (code);
1019 location_t loc = EXPR_LOCATION (expr);
1020 tree op0, op1, op2, op3;
1021 tree orig_op0, orig_op1, orig_op2;
1022 bool op0_const = true, op1_const = true, op2_const = true;
1023 bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1024 bool nowarning = TREE_NO_WARNING (expr);
1027 /* This function is not relevant to C++ because C++ folds while
1028 parsing, and may need changes to be correct for C++ when C++
1029 stops folding while parsing. */
1030 if (c_dialect_cxx ())
1033 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1034 anything else not counted as an expression cannot usefully be
1035 folded further at this point. */
1036 if (!IS_EXPR_CODE_CLASS (kind)
1037 || kind == tcc_statement
1038 || code == SAVE_EXPR)
1041 /* Operands of variable-length expressions (function calls) have
1042 already been folded, as have __builtin_* function calls, and such
1043 expressions cannot occur in constant expressions. */
1044 if (kind == tcc_vl_exp)
1046 *maybe_const_operands = false;
1051 if (code == C_MAYBE_CONST_EXPR)
1053 tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1054 tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1055 if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1056 *maybe_const_operands = false;
1057 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1058 *maybe_const_itself = false;
1059 if (pre && !in_init)
1060 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1066 /* Assignment, increment, decrement, function call and comma
1067 operators, and statement expressions, cannot occur in constant
1068 expressions if evaluated / outside of sizeof. (Function calls
1069 were handled above, though VA_ARG_EXPR is treated like a function
1070 call here, and statement expressions are handled through
1071 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1075 case PREDECREMENT_EXPR:
1076 case PREINCREMENT_EXPR:
1077 case POSTDECREMENT_EXPR:
1078 case POSTINCREMENT_EXPR:
1080 *maybe_const_operands = false;
1087 *maybe_const_operands = false;
1095 /* Fold individual tree codes as appropriate. */
1098 case COMPOUND_LITERAL_EXPR:
1099 /* Any non-constancy will have been marked in a containing
1100 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1104 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1105 op1 = TREE_OPERAND (expr, 1);
1106 op2 = TREE_OPERAND (expr, 2);
1107 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1108 maybe_const_itself);
1109 STRIP_TYPE_NOPS (op0);
1110 if (op0 != orig_op0)
1111 ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1114 TREE_READONLY (ret) = TREE_READONLY (expr);
1115 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1120 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1121 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1122 op2 = TREE_OPERAND (expr, 2);
1123 op3 = TREE_OPERAND (expr, 3);
1124 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1125 maybe_const_itself);
1126 STRIP_TYPE_NOPS (op0);
1127 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1128 maybe_const_itself);
1129 STRIP_TYPE_NOPS (op1);
1130 op1 = decl_constant_value_for_optimization (op1);
1131 if (op0 != orig_op0 || op1 != orig_op1)
1132 ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1135 TREE_READONLY (ret) = TREE_READONLY (expr);
1136 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1137 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1144 case PREDECREMENT_EXPR:
1145 case PREINCREMENT_EXPR:
1146 case POSTDECREMENT_EXPR:
1147 case POSTINCREMENT_EXPR:
1151 case POINTER_PLUS_EXPR:
1152 case TRUNC_DIV_EXPR:
1154 case FLOOR_DIV_EXPR:
1155 case TRUNC_MOD_EXPR:
1157 case EXACT_DIV_EXPR:
1170 case TRUTH_AND_EXPR:
1172 case TRUTH_XOR_EXPR:
1173 case UNORDERED_EXPR:
1180 /* Binary operations evaluating both arguments (increment and
1181 decrement are binary internally in GCC). */
1182 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1183 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1184 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1185 maybe_const_itself);
1186 STRIP_TYPE_NOPS (op0);
1187 if (code != MODIFY_EXPR
1188 && code != PREDECREMENT_EXPR
1189 && code != PREINCREMENT_EXPR
1190 && code != POSTDECREMENT_EXPR
1191 && code != POSTINCREMENT_EXPR)
1192 op0 = decl_constant_value_for_optimization (op0);
1193 /* The RHS of a MODIFY_EXPR was fully folded when building that
1194 expression for the sake of conversion warnings. */
1195 if (code != MODIFY_EXPR)
1196 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1197 maybe_const_itself);
1198 STRIP_TYPE_NOPS (op1);
1199 op1 = decl_constant_value_for_optimization (op1);
1200 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1202 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1203 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1206 if (TREE_OVERFLOW_P (ret)
1207 && !TREE_OVERFLOW_P (op0)
1208 && !TREE_OVERFLOW_P (op1))
1209 overflow_warning (EXPR_LOCATION (expr), ret);
1213 case FIX_TRUNC_EXPR:
1216 case VIEW_CONVERT_EXPR:
1217 case NON_LVALUE_EXPR:
1220 case TRUTH_NOT_EXPR:
1225 /* Unary operations. */
1226 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1227 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1228 maybe_const_itself);
1229 STRIP_TYPE_NOPS (op0);
1230 if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1231 op0 = decl_constant_value_for_optimization (op0);
1232 if (op0 != orig_op0 || in_init)
1234 ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)
1235 : fold_build1_loc (loc, code, TREE_TYPE (expr), op0);
1238 if (code == INDIRECT_REF
1240 && TREE_CODE (ret) == INDIRECT_REF)
1242 TREE_READONLY (ret) = TREE_READONLY (expr);
1243 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1244 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1248 case FIX_TRUNC_EXPR:
1251 /* Don't warn about explicit conversions. We will already
1252 have warned about suspect implicit conversions. */
1256 if (TREE_OVERFLOW_P (ret) && !TREE_OVERFLOW_P (op0))
1257 overflow_warning (EXPR_LOCATION (expr), ret);
1262 case TRUTH_ANDIF_EXPR:
1263 case TRUTH_ORIF_EXPR:
1264 /* Binary operations not necessarily evaluating both
1266 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1267 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1268 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1269 STRIP_TYPE_NOPS (op0);
1271 unused_p = (op0 == (code == TRUTH_ANDIF_EXPR
1272 ? truthvalue_false_node
1273 : truthvalue_true_node));
1274 c_inhibit_evaluation_warnings += unused_p;
1275 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1276 STRIP_TYPE_NOPS (op1);
1277 c_inhibit_evaluation_warnings -= unused_p;
1279 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1281 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1282 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1285 *maybe_const_operands &= op0_const;
1286 *maybe_const_itself &= op0_const_self;
1290 && (code == TRUTH_ANDIF_EXPR
1291 ? op0 == truthvalue_false_node
1292 : op0 == truthvalue_true_node)))
1293 *maybe_const_operands &= op1_const;
1296 && (code == TRUTH_ANDIF_EXPR
1297 ? op0 == truthvalue_false_node
1298 : op0 == truthvalue_true_node)))
1299 *maybe_const_itself &= op1_const_self;
1303 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1304 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1305 orig_op2 = op2 = TREE_OPERAND (expr, 2);
1306 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1308 STRIP_TYPE_NOPS (op0);
1309 c_inhibit_evaluation_warnings += (op0 == truthvalue_false_node);
1310 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1311 STRIP_TYPE_NOPS (op1);
1312 c_inhibit_evaluation_warnings -= (op0 == truthvalue_false_node);
1314 c_inhibit_evaluation_warnings += (op0 == truthvalue_true_node);
1315 op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
1316 STRIP_TYPE_NOPS (op2);
1317 c_inhibit_evaluation_warnings -= (op0 == truthvalue_true_node);
1319 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
1320 ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
1323 *maybe_const_operands &= op0_const;
1324 *maybe_const_itself &= op0_const_self;
1328 && op0 == truthvalue_false_node))
1329 *maybe_const_operands &= op1_const;
1332 && op0 == truthvalue_false_node))
1333 *maybe_const_itself &= op1_const_self;
1337 && op0 == truthvalue_true_node))
1338 *maybe_const_operands &= op2_const;
1341 && op0 == truthvalue_true_node))
1342 *maybe_const_itself &= op2_const_self;
1345 case EXCESS_PRECISION_EXPR:
1346 /* Each case where an operand with excess precision may be
1347 encountered must remove the EXCESS_PRECISION_EXPR around
1348 inner operands and possibly put one around the whole
1349 expression or possibly convert to the semantic type (which
1350 c_fully_fold does); we cannot tell at this stage which is
1351 appropriate in any particular case. */
1355 /* Various codes may appear through folding built-in functions
1356 and their arguments. */
1361 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1362 have been done by this point, so remove them again. */
1363 nowarning |= TREE_NO_WARNING (ret);
1364 STRIP_TYPE_NOPS (ret);
1365 if (nowarning && !TREE_NO_WARNING (ret))
1367 if (!CAN_HAVE_LOCATION_P (ret))
1368 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1369 TREE_NO_WARNING (ret) = 1;
1372 protected_set_expr_location (ret, loc);
1376 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1377 return EXP. Otherwise, return either EXP or its known constant
1378 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1379 Is the BLKmode test appropriate? */
1382 decl_constant_value_for_optimization (tree exp)
1386 /* This function is only used by C, for c_fully_fold and other
1387 optimization, and may not be correct for C++. */
1388 if (c_dialect_cxx ())
1392 || TREE_CODE (exp) != VAR_DECL
1393 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1394 || DECL_MODE (exp) == BLKmode)
1397 ret = decl_constant_value (exp);
1398 /* Avoid unwanted tree sharing between the initializer and current
1399 function's body where the tree can be modified e.g. by the
1401 if (ret != exp && TREE_STATIC (exp))
1402 ret = unshare_expr (ret);
1406 /* Print a warning if a constant expression had overflow in folding.
1407 Invoke this function on every expression that the language
1408 requires to be a constant expression.
1409 Note the ANSI C standard says it is erroneous for a
1410 constant expression to overflow. */
1413 constant_expression_warning (tree value)
1415 if (warn_overflow && pedantic
1416 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1417 || TREE_CODE (value) == FIXED_CST
1418 || TREE_CODE (value) == VECTOR_CST
1419 || TREE_CODE (value) == COMPLEX_CST)
1420 && TREE_OVERFLOW (value))
1421 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1424 /* The same as above but print an unconditional error. */
1426 constant_expression_error (tree value)
1428 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1429 || TREE_CODE (value) == FIXED_CST
1430 || TREE_CODE (value) == VECTOR_CST
1431 || TREE_CODE (value) == COMPLEX_CST)
1432 && TREE_OVERFLOW (value))
1433 error ("overflow in constant expression");
1436 /* Print a warning if an expression had overflow in folding and its
1439 Invoke this function on every expression that
1440 (1) appears in the source code, and
1441 (2) is a constant expression that overflowed, and
1442 (3) is not already checked by convert_and_check;
1443 however, do not invoke this function on operands of explicit casts
1444 or when the expression is the result of an operator and any operand
1445 already overflowed. */
1448 overflow_warning (location_t loc, tree value)
1450 if (c_inhibit_evaluation_warnings != 0)
1453 switch (TREE_CODE (value))
1456 warning_at (loc, OPT_Woverflow, "integer overflow in expression");
1460 warning_at (loc, OPT_Woverflow,
1461 "floating point overflow in expression");
1465 warning_at (loc, OPT_Woverflow, "fixed-point overflow in expression");
1469 warning_at (loc, OPT_Woverflow, "vector overflow in expression");
1473 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1474 warning_at (loc, OPT_Woverflow,
1475 "complex integer overflow in expression");
1476 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1477 warning_at (loc, OPT_Woverflow,
1478 "complex floating point overflow in expression");
1486 /* Warn about uses of logical || / && operator in a context where it
1487 is likely that the bitwise equivalent was intended by the
1488 programmer. We have seen an expression in which CODE is a binary
1489 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1490 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1492 warn_logical_operator (location_t location, enum tree_code code, tree type,
1493 enum tree_code code_left, tree op_left,
1494 enum tree_code ARG_UNUSED (code_right), tree op_right)
1496 int or_op = (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR);
1497 int in0_p, in1_p, in_p;
1498 tree low0, low1, low, high0, high1, high, lhs, rhs, tem;
1499 bool strict_overflow_p = false;
1501 if (code != TRUTH_ANDIF_EXPR
1502 && code != TRUTH_AND_EXPR
1503 && code != TRUTH_ORIF_EXPR
1504 && code != TRUTH_OR_EXPR)
1507 /* Warn if &&/|| are being used in a context where it is
1508 likely that the bitwise equivalent was intended by the
1509 programmer. That is, an expression such as op && MASK
1510 where op should not be any boolean expression, nor a
1511 constant, and mask seems to be a non-boolean integer constant. */
1512 if (!truth_value_p (code_left)
1513 && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1514 && !CONSTANT_CLASS_P (op_left)
1515 && !TREE_NO_WARNING (op_left)
1516 && TREE_CODE (op_right) == INTEGER_CST
1517 && !integer_zerop (op_right)
1518 && !integer_onep (op_right))
1521 warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1522 " applied to non-boolean constant");
1524 warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1525 " applied to non-boolean constant");
1526 TREE_NO_WARNING (op_left) = true;
1530 /* We do not warn for constants because they are typical of macro
1531 expansions that test for features. */
1532 if (CONSTANT_CLASS_P (op_left) || CONSTANT_CLASS_P (op_right))
1535 /* This warning only makes sense with logical operands. */
1536 if (!(truth_value_p (TREE_CODE (op_left))
1537 || INTEGRAL_TYPE_P (TREE_TYPE (op_left)))
1538 || !(truth_value_p (TREE_CODE (op_right))
1539 || INTEGRAL_TYPE_P (TREE_TYPE (op_right))))
1542 lhs = make_range (op_left, &in0_p, &low0, &high0, &strict_overflow_p);
1543 rhs = make_range (op_right, &in1_p, &low1, &high1, &strict_overflow_p);
1545 if (lhs && TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
1546 lhs = C_MAYBE_CONST_EXPR_EXPR (lhs);
1548 if (rhs && TREE_CODE (rhs) == C_MAYBE_CONST_EXPR)
1549 rhs = C_MAYBE_CONST_EXPR_EXPR (rhs);
1551 /* If this is an OR operation, invert both sides; we will invert
1552 again at the end. */
1554 in0_p = !in0_p, in1_p = !in1_p;
1556 /* If both expressions are the same, if we can merge the ranges, and we
1557 can build the range test, return it or it inverted. */
1558 if (lhs && rhs && operand_equal_p (lhs, rhs, 0)
1559 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
1561 && 0 != (tem = build_range_check (UNKNOWN_LOCATION,
1562 type, lhs, in_p, low, high)))
1564 if (TREE_CODE (tem) != INTEGER_CST)
1568 warning_at (location, OPT_Wlogical_op,
1570 "of collectively exhaustive tests is always true");
1572 warning_at (location, OPT_Wlogical_op,
1574 "of mutually exclusive tests is always false");
1579 /* Print a warning about casts that might indicate violation
1580 of strict aliasing rules if -Wstrict-aliasing is used and
1581 strict aliasing mode is in effect. OTYPE is the original
1582 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1585 strict_aliasing_warning (tree otype, tree type, tree expr)
1587 /* Strip pointer conversion chains and get to the correct original type. */
1589 otype = TREE_TYPE (expr);
1591 if (!(flag_strict_aliasing
1592 && POINTER_TYPE_P (type)
1593 && POINTER_TYPE_P (otype)
1594 && !VOID_TYPE_P (TREE_TYPE (type)))
1595 /* If the type we are casting to is a ref-all pointer
1596 dereferencing it is always valid. */
1597 || TYPE_REF_CAN_ALIAS_ALL (type))
1600 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1601 && (DECL_P (TREE_OPERAND (expr, 0))
1602 || handled_component_p (TREE_OPERAND (expr, 0))))
1604 /* Casting the address of an object to non void pointer. Warn
1605 if the cast breaks type based aliasing. */
1606 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1608 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1609 "might break strict-aliasing rules");
1614 /* warn_strict_aliasing >= 3. This includes the default (3).
1615 Only warn if the cast is dereferenced immediately. */
1616 alias_set_type set1 =
1617 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1618 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1620 if (set1 != set2 && set2 != 0
1621 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1623 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1624 "pointer will break strict-aliasing rules");
1627 else if (warn_strict_aliasing == 2
1628 && !alias_sets_must_conflict_p (set1, set2))
1630 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1631 "pointer might break strict-aliasing rules");
1637 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1639 /* At this level, warn for any conversions, even if an address is
1640 not taken in the same statement. This will likely produce many
1641 false positives, but could be useful to pinpoint problems that
1642 are not revealed at higher levels. */
1643 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1644 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1645 if (!COMPLETE_TYPE_P (type)
1646 || !alias_sets_must_conflict_p (set1, set2))
1648 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1649 "pointer might break strict-aliasing rules");
1657 /* Warn for unlikely, improbable, or stupid DECL declarations
1661 check_main_parameter_types (tree decl)
1666 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1667 args = TREE_CHAIN (args))
1669 tree type = args ? TREE_VALUE (args) : 0;
1671 if (type == void_type_node || type == error_mark_node )
1678 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1679 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1684 if (TREE_CODE (type) != POINTER_TYPE
1685 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1686 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1688 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1693 if (TREE_CODE (type) != POINTER_TYPE
1694 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1695 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1697 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1698 "%<char **%>", decl);
1703 /* It is intentional that this message does not mention the third
1704 argument because it's only mentioned in an appendix of the
1706 if (argct > 0 && (argct < 2 || argct > 3))
1707 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1710 /* True if pointers to distinct types T1 and T2 can be converted to
1711 each other without an explicit cast. Only returns true for opaque
1714 vector_targets_convertible_p (const_tree t1, const_tree t2)
1716 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1717 && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1718 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1724 /* True if vector types T1 and T2 can be converted to each other
1725 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1726 can only be converted with -flax-vector-conversions yet that is not
1727 in effect, emit a note telling the user about that option if such
1728 a note has not previously been emitted. */
1730 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1732 static bool emitted_lax_note = false;
1733 bool convertible_lax;
1735 if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1736 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1740 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1741 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1742 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1743 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1744 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1746 if (!convertible_lax || flag_lax_vector_conversions)
1747 return convertible_lax;
1749 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1750 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1753 if (emit_lax_note && !emitted_lax_note)
1755 emitted_lax_note = true;
1756 inform (input_location, "use -flax-vector-conversions to permit "
1757 "conversions between vectors with differing "
1758 "element types or numbers of subparts");
1764 /* This is a helper function of build_binary_op.
1766 For certain operations if both args were extended from the same
1767 smaller type, do the arithmetic in that type and then extend.
1769 BITWISE indicates a bitwise operation.
1770 For them, this optimization is safe only if
1771 both args are zero-extended or both are sign-extended.
1772 Otherwise, we might change the result.
1773 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1774 but calculated in (unsigned short) it would be (unsigned short)-1.
1776 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1778 int unsigned0, unsigned1;
1783 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1784 excessive narrowing when we call get_narrower below. For
1785 example, suppose that OP0 is of unsigned int extended
1786 from signed char and that RESULT_TYPE is long long int.
1787 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1790 (long long int) (unsigned int) signed_char
1792 which get_narrower would narrow down to
1794 (unsigned int) signed char
1796 If we do not cast OP0 first, get_narrower would return
1797 signed_char, which is inconsistent with the case of the
1799 op0 = convert (result_type, op0);
1800 op1 = convert (result_type, op1);
1802 arg0 = get_narrower (op0, &unsigned0);
1803 arg1 = get_narrower (op1, &unsigned1);
1805 /* UNS is 1 if the operation to be done is an unsigned one. */
1806 uns = TYPE_UNSIGNED (result_type);
1808 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1809 but it *requires* conversion to FINAL_TYPE. */
1811 if ((TYPE_PRECISION (TREE_TYPE (op0))
1812 == TYPE_PRECISION (TREE_TYPE (arg0)))
1813 && TREE_TYPE (op0) != result_type)
1814 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1815 if ((TYPE_PRECISION (TREE_TYPE (op1))
1816 == TYPE_PRECISION (TREE_TYPE (arg1)))
1817 && TREE_TYPE (op1) != result_type)
1818 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1820 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1822 /* For bitwise operations, signedness of nominal type
1823 does not matter. Consider only how operands were extended. */
1827 /* Note that in all three cases below we refrain from optimizing
1828 an unsigned operation on sign-extended args.
1829 That would not be valid. */
1831 /* Both args variable: if both extended in same way
1832 from same width, do it in that width.
1833 Do it unsigned if args were zero-extended. */
1834 if ((TYPE_PRECISION (TREE_TYPE (arg0))
1835 < TYPE_PRECISION (result_type))
1836 && (TYPE_PRECISION (TREE_TYPE (arg1))
1837 == TYPE_PRECISION (TREE_TYPE (arg0)))
1838 && unsigned0 == unsigned1
1839 && (unsigned0 || !uns))
1840 return c_common_signed_or_unsigned_type
1841 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1843 else if (TREE_CODE (arg0) == INTEGER_CST
1844 && (unsigned1 || !uns)
1845 && (TYPE_PRECISION (TREE_TYPE (arg1))
1846 < TYPE_PRECISION (result_type))
1848 = c_common_signed_or_unsigned_type (unsigned1,
1850 && !POINTER_TYPE_P (type)
1851 && int_fits_type_p (arg0, type))
1854 else if (TREE_CODE (arg1) == INTEGER_CST
1855 && (unsigned0 || !uns)
1856 && (TYPE_PRECISION (TREE_TYPE (arg0))
1857 < TYPE_PRECISION (result_type))
1859 = c_common_signed_or_unsigned_type (unsigned0,
1861 && !POINTER_TYPE_P (type)
1862 && int_fits_type_p (arg1, type))
1868 /* Warns if the conversion of EXPR to TYPE may alter a value.
1869 This is a helper function for warnings_for_convert_and_check. */
1872 conversion_warning (tree type, tree expr)
1874 bool give_warning = false;
1877 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
1878 tree expr_type = TREE_TYPE (expr);
1879 location_t loc = EXPR_LOC_OR_HERE (expr);
1881 if (!warn_conversion && !warn_sign_conversion)
1884 /* If any operand is artificial, then this expression was generated
1885 by the compiler and we do not warn. */
1886 for (i = 0; i < expr_num_operands; i++)
1888 tree op = TREE_OPERAND (expr, i);
1889 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
1893 switch (TREE_CODE (expr))
1901 case TRUTH_ANDIF_EXPR:
1902 case TRUTH_ORIF_EXPR:
1903 case TRUTH_AND_EXPR:
1905 case TRUTH_XOR_EXPR:
1906 case TRUTH_NOT_EXPR:
1907 /* Conversion from boolean to a signed:1 bit-field (which only
1908 can hold the values 0 and -1) doesn't lose information - but
1909 it does change the value. */
1910 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
1911 warning_at (loc, OPT_Wconversion,
1912 "conversion to %qT from boolean expression", type);
1918 /* Warn for real constant that is not an exact integer converted
1920 if (TREE_CODE (expr_type) == REAL_TYPE
1921 && TREE_CODE (type) == INTEGER_TYPE)
1923 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
1924 give_warning = true;
1926 /* Warn for an integer constant that does not fit into integer type. */
1927 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1928 && TREE_CODE (type) == INTEGER_TYPE
1929 && !int_fits_type_p (expr, type))
1931 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
1932 && tree_int_cst_sgn (expr) < 0)
1933 warning_at (loc, OPT_Wsign_conversion, "negative integer"
1934 " implicitly converted to unsigned type");
1935 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
1936 warning_at (loc, OPT_Wsign_conversion, "conversion of unsigned"
1937 " constant value to negative integer");
1939 give_warning = true;
1941 else if (TREE_CODE (type) == REAL_TYPE)
1943 /* Warn for an integer constant that does not fit into real type. */
1944 if (TREE_CODE (expr_type) == INTEGER_TYPE)
1946 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1947 if (!exact_real_truncate (TYPE_MODE (type), &a))
1948 give_warning = true;
1950 /* Warn for a real constant that does not fit into a smaller
1952 else if (TREE_CODE (expr_type) == REAL_TYPE
1953 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1955 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1956 if (!exact_real_truncate (TYPE_MODE (type), &a))
1957 give_warning = true;
1962 warning_at (loc, OPT_Wconversion,
1963 "conversion to %qT alters %qT constant value",
1970 /* In case of COND_EXPR, if both operands are constants or
1971 COND_EXPR, then we do not care about the type of COND_EXPR,
1972 only about the conversion of each operand. */
1973 tree op1 = TREE_OPERAND (expr, 1);
1974 tree op2 = TREE_OPERAND (expr, 2);
1976 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
1977 || TREE_CODE (op1) == COND_EXPR)
1978 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
1979 || TREE_CODE (op2) == COND_EXPR))
1981 conversion_warning (type, op1);
1982 conversion_warning (type, op2);
1988 default: /* 'expr' is not a constant. */
1990 /* Warn for real types converted to integer types. */
1991 if (TREE_CODE (expr_type) == REAL_TYPE
1992 && TREE_CODE (type) == INTEGER_TYPE)
1993 give_warning = true;
1995 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1996 && TREE_CODE (type) == INTEGER_TYPE)
1998 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1999 expr = get_unwidened (expr, 0);
2000 expr_type = TREE_TYPE (expr);
2002 /* Don't warn for short y; short x = ((int)y & 0xff); */
2003 if (TREE_CODE (expr) == BIT_AND_EXPR
2004 || TREE_CODE (expr) == BIT_IOR_EXPR
2005 || TREE_CODE (expr) == BIT_XOR_EXPR)
2007 /* If both args were extended from a shortest type,
2008 use that type if that is safe. */
2009 expr_type = shorten_binary_op (expr_type,
2010 TREE_OPERAND (expr, 0),
2011 TREE_OPERAND (expr, 1),
2014 if (TREE_CODE (expr) == BIT_AND_EXPR)
2016 tree op0 = TREE_OPERAND (expr, 0);
2017 tree op1 = TREE_OPERAND (expr, 1);
2018 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2019 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2021 /* If one of the operands is a non-negative constant
2022 that fits in the target type, then the type of the
2023 other operand does not matter. */
2024 if ((TREE_CODE (op0) == INTEGER_CST
2025 && int_fits_type_p (op0, c_common_signed_type (type))
2026 && int_fits_type_p (op0, c_common_unsigned_type (type)))
2027 || (TREE_CODE (op1) == INTEGER_CST
2028 && int_fits_type_p (op1, c_common_signed_type (type))
2029 && int_fits_type_p (op1,
2030 c_common_unsigned_type (type))))
2032 /* If constant is unsigned and fits in the target
2033 type, then the result will also fit. */
2034 else if ((TREE_CODE (op0) == INTEGER_CST
2036 && int_fits_type_p (op0, type))
2037 || (TREE_CODE (op1) == INTEGER_CST
2039 && int_fits_type_p (op1, type)))
2043 /* Warn for integer types converted to smaller integer types. */
2044 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2045 give_warning = true;
2047 /* When they are the same width but different signedness,
2048 then the value may change. */
2049 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2050 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
2051 /* Even when converted to a bigger type, if the type is
2052 unsigned but expr is signed, then negative values
2054 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
2055 warning_at (loc, OPT_Wsign_conversion, "conversion to %qT from %qT "
2056 "may change the sign of the result",
2060 /* Warn for integer types converted to real types if and only if
2061 all the range of values of the integer type cannot be
2062 represented by the real type. */
2063 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2064 && TREE_CODE (type) == REAL_TYPE)
2066 tree type_low_bound, type_high_bound;
2067 REAL_VALUE_TYPE real_low_bound, real_high_bound;
2069 /* Don't warn about char y = 0xff; float x = (int) y; */
2070 expr = get_unwidened (expr, 0);
2071 expr_type = TREE_TYPE (expr);
2073 type_low_bound = TYPE_MIN_VALUE (expr_type);
2074 type_high_bound = TYPE_MAX_VALUE (expr_type);
2075 real_low_bound = real_value_from_int_cst (0, type_low_bound);
2076 real_high_bound = real_value_from_int_cst (0, type_high_bound);
2078 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2079 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2080 give_warning = true;
2083 /* Warn for real types converted to smaller real types. */
2084 else if (TREE_CODE (expr_type) == REAL_TYPE
2085 && TREE_CODE (type) == REAL_TYPE
2086 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2087 give_warning = true;
2091 warning_at (loc, OPT_Wconversion,
2092 "conversion to %qT from %qT may alter its value",
2097 /* Produce warnings after a conversion. RESULT is the result of
2098 converting EXPR to TYPE. This is a helper function for
2099 convert_and_check and cp_convert_and_check. */
2102 warnings_for_convert_and_check (tree type, tree expr, tree result)
2104 if (TREE_CODE (expr) == INTEGER_CST
2105 && (TREE_CODE (type) == INTEGER_TYPE
2106 || TREE_CODE (type) == ENUMERAL_TYPE)
2107 && !int_fits_type_p (expr, type))
2109 /* Do not diagnose overflow in a constant expression merely
2110 because a conversion overflowed. */
2111 if (TREE_OVERFLOW (result))
2112 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2114 if (TYPE_UNSIGNED (type))
2116 /* This detects cases like converting -129 or 256 to
2118 if (!int_fits_type_p (expr, c_common_signed_type (type)))
2119 warning (OPT_Woverflow,
2120 "large integer implicitly truncated to unsigned type");
2122 conversion_warning (type, expr);
2124 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
2125 warning (OPT_Woverflow,
2126 "overflow in implicit constant conversion");
2127 /* No warning for converting 0x80000000 to int. */
2129 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2130 || TYPE_PRECISION (TREE_TYPE (expr))
2131 != TYPE_PRECISION (type)))
2132 warning (OPT_Woverflow,
2133 "overflow in implicit constant conversion");
2136 conversion_warning (type, expr);
2138 else if ((TREE_CODE (result) == INTEGER_CST
2139 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
2140 warning (OPT_Woverflow,
2141 "overflow in implicit constant conversion");
2143 conversion_warning (type, expr);
2147 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2148 Invoke this function on every expression that is converted implicitly,
2149 i.e. because of language rules and not because of an explicit cast. */
2152 convert_and_check (tree type, tree expr)
2155 tree expr_for_warning;
2157 /* Convert from a value with possible excess precision rather than
2158 via the semantic type, but do not warn about values not fitting
2159 exactly in the semantic type. */
2160 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2162 tree orig_type = TREE_TYPE (expr);
2163 expr = TREE_OPERAND (expr, 0);
2164 expr_for_warning = convert (orig_type, expr);
2165 if (orig_type == type)
2166 return expr_for_warning;
2169 expr_for_warning = expr;
2171 if (TREE_TYPE (expr) == type)
2174 result = convert (type, expr);
2176 if (c_inhibit_evaluation_warnings == 0
2177 && !TREE_OVERFLOW_P (expr)
2178 && result != error_mark_node)
2179 warnings_for_convert_and_check (type, expr_for_warning, result);
2184 /* A node in a list that describes references to variables (EXPR), which are
2185 either read accesses if WRITER is zero, or write accesses, in which case
2186 WRITER is the parent of EXPR. */
2193 /* Used to implement a cache the results of a call to verify_tree. We only
2194 use this for SAVE_EXPRs. */
2197 struct tlist_cache *next;
2198 struct tlist *cache_before_sp;
2199 struct tlist *cache_after_sp;
2203 /* Obstack to use when allocating tlist structures, and corresponding
2205 static struct obstack tlist_obstack;
2206 static char *tlist_firstobj = 0;
2208 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2210 static struct tlist *warned_ids;
2211 /* SAVE_EXPRs need special treatment. We process them only once and then
2212 cache the results. */
2213 static struct tlist_cache *save_expr_cache;
2215 static void add_tlist (struct tlist **, struct tlist *, tree, int);
2216 static void merge_tlist (struct tlist **, struct tlist *, int);
2217 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2218 static int warning_candidate_p (tree);
2219 static bool candidate_equal_p (const_tree, const_tree);
2220 static void warn_for_collisions (struct tlist *);
2221 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2222 static struct tlist *new_tlist (struct tlist *, tree, tree);
2224 /* Create a new struct tlist and fill in its fields. */
2225 static struct tlist *
2226 new_tlist (struct tlist *next, tree t, tree writer)
2229 l = XOBNEW (&tlist_obstack, struct tlist);
2236 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2237 is nonnull, we ignore any node we find which has a writer equal to it. */
2240 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
2244 struct tlist *next = add->next;
2247 if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer))
2248 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2253 /* Merge the nodes of ADD into TO. This merging process is done so that for
2254 each variable that already exists in TO, no new node is added; however if
2255 there is a write access recorded in ADD, and an occurrence on TO is only
2256 a read access, then the occurrence in TO will be modified to record the
2260 merge_tlist (struct tlist **to, struct tlist *add, int copy)
2262 struct tlist **end = to;
2265 end = &(*end)->next;
2271 struct tlist *next = add->next;
2273 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
2274 if (candidate_equal_p (tmp2->expr, add->expr))
2278 tmp2->writer = add->writer;
2282 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2283 end = &(*end)->next;
2290 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2291 references in list LIST conflict with it, excluding reads if ONLY writers
2295 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2300 /* Avoid duplicate warnings. */
2301 for (tmp = warned_ids; tmp; tmp = tmp->next)
2302 if (candidate_equal_p (tmp->expr, written))
2307 if (candidate_equal_p (list->expr, written)
2308 && !candidate_equal_p (list->writer, writer)
2309 && (!only_writes || list->writer))
2311 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
2312 warning_at (EXPR_LOC_OR_HERE (writer),
2313 OPT_Wsequence_point, "operation on %qE may be undefined",
2320 /* Given a list LIST of references to variables, find whether any of these
2321 can cause conflicts due to missing sequence points. */
2324 warn_for_collisions (struct tlist *list)
2328 for (tmp = list; tmp; tmp = tmp->next)
2331 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2335 /* Return nonzero if X is a tree that can be verified by the sequence point
2338 warning_candidate_p (tree x)
2340 if (DECL_P (x) && DECL_ARTIFICIAL (x))
2343 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2344 (lvalue_p) crash on TRY/CATCH. */
2345 if (TREE_TYPE (x) == NULL_TREE || VOID_TYPE_P (TREE_TYPE (x)))
2351 /* No point to track non-const calls, they will never satisfy
2353 if (TREE_CODE (x) == CALL_EXPR && (call_expr_flags (x) & ECF_CONST) == 0)
2356 if (TREE_CODE (x) == STRING_CST)
2362 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2364 candidate_equal_p (const_tree x, const_tree y)
2366 return (x == y) || (x && y && operand_equal_p (x, y, 0));
2369 /* Walk the tree X, and record accesses to variables. If X is written by the
2370 parent tree, WRITER is the parent.
2371 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2372 expression or its only operand forces a sequence point, then everything up
2373 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2375 Once we return, we will have emitted warnings if any subexpression before
2376 such a sequence point could be undefined. On a higher level, however, the
2377 sequence point may not be relevant, and we'll merge the two lists.
2379 Example: (b++, a) + b;
2380 The call that processes the COMPOUND_EXPR will store the increment of B
2381 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2382 processes the PLUS_EXPR will need to merge the two lists so that
2383 eventually, all accesses end up on the same list (and we'll warn about the
2384 unordered subexpressions b++ and b.
2386 A note on merging. If we modify the former example so that our expression
2389 care must be taken not simply to add all three expressions into the final
2390 PNO_SP list. The function merge_tlist takes care of that by merging the
2391 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2392 way, so that no more than one access to B is recorded. */
2395 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2398 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2399 enum tree_code code;
2400 enum tree_code_class cl;
2402 /* X may be NULL if it is the operand of an empty statement expression
2408 code = TREE_CODE (x);
2409 cl = TREE_CODE_CLASS (code);
2411 if (warning_candidate_p (x))
2412 *pno_sp = new_tlist (*pno_sp, x, writer);
2420 case TRUTH_ANDIF_EXPR:
2421 case TRUTH_ORIF_EXPR:
2422 tmp_before = tmp_nosp = tmp_list3 = 0;
2423 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2424 warn_for_collisions (tmp_nosp);
2425 merge_tlist (pbefore_sp, tmp_before, 0);
2426 merge_tlist (pbefore_sp, tmp_nosp, 0);
2427 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2428 merge_tlist (pbefore_sp, tmp_list3, 0);
2432 tmp_before = tmp_list2 = 0;
2433 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2434 warn_for_collisions (tmp_list2);
2435 merge_tlist (pbefore_sp, tmp_before, 0);
2436 merge_tlist (pbefore_sp, tmp_list2, 1);
2438 tmp_list3 = tmp_nosp = 0;
2439 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2440 warn_for_collisions (tmp_nosp);
2441 merge_tlist (pbefore_sp, tmp_list3, 0);
2443 tmp_list3 = tmp_list2 = 0;
2444 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2445 warn_for_collisions (tmp_list2);
2446 merge_tlist (pbefore_sp, tmp_list3, 0);
2447 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2448 two first, to avoid warning for (a ? b++ : b++). */
2449 merge_tlist (&tmp_nosp, tmp_list2, 0);
2450 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2453 case PREDECREMENT_EXPR:
2454 case PREINCREMENT_EXPR:
2455 case POSTDECREMENT_EXPR:
2456 case POSTINCREMENT_EXPR:
2457 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2461 tmp_before = tmp_nosp = tmp_list3 = 0;
2462 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2463 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2464 /* Expressions inside the LHS are not ordered wrt. the sequence points
2465 in the RHS. Example:
2467 Despite the fact that the modification of "a" is in the before_sp
2468 list (tmp_before), it conflicts with the use of "a" in the LHS.
2469 We can handle this by adding the contents of tmp_list3
2470 to those of tmp_before, and redoing the collision warnings for that
2472 add_tlist (&tmp_before, tmp_list3, x, 1);
2473 warn_for_collisions (tmp_before);
2474 /* Exclude the LHS itself here; we first have to merge it into the
2475 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2476 didn't exclude the LHS, we'd get it twice, once as a read and once
2478 add_tlist (pno_sp, tmp_list3, x, 0);
2479 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2481 merge_tlist (pbefore_sp, tmp_before, 0);
2482 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2483 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2484 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2488 /* We need to warn about conflicts among arguments and conflicts between
2489 args and the function address. Side effects of the function address,
2490 however, are not ordered by the sequence point of the call. */
2492 call_expr_arg_iterator iter;
2494 tmp_before = tmp_nosp = 0;
2495 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2496 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2498 tmp_list2 = tmp_list3 = 0;
2499 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2500 merge_tlist (&tmp_list3, tmp_list2, 0);
2501 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2503 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2504 warn_for_collisions (tmp_before);
2505 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2510 /* Scan all the list, e.g. indices of multi dimensional array. */
2513 tmp_before = tmp_nosp = 0;
2514 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2515 merge_tlist (&tmp_nosp, tmp_before, 0);
2516 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2523 struct tlist_cache *t;
2524 for (t = save_expr_cache; t; t = t->next)
2525 if (candidate_equal_p (t->expr, x))
2530 t = XOBNEW (&tlist_obstack, struct tlist_cache);
2531 t->next = save_expr_cache;
2533 save_expr_cache = t;
2535 tmp_before = tmp_nosp = 0;
2536 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2537 warn_for_collisions (tmp_nosp);
2542 struct tlist *t = tmp_nosp;
2544 merge_tlist (&tmp_list3, t, 0);
2546 t->cache_before_sp = tmp_before;
2547 t->cache_after_sp = tmp_list3;
2549 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2550 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2555 x = TREE_OPERAND (x, 0);
2562 /* For other expressions, simply recurse on their operands.
2563 Manual tail recursion for unary expressions.
2564 Other non-expressions need not be processed. */
2565 if (cl == tcc_unary)
2567 x = TREE_OPERAND (x, 0);
2571 else if (IS_EXPR_CODE_CLASS (cl))
2574 int max = TREE_OPERAND_LENGTH (x);
2575 for (lp = 0; lp < max; lp++)
2577 tmp_before = tmp_nosp = 0;
2578 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2579 merge_tlist (&tmp_nosp, tmp_before, 0);
2580 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2587 /* Try to warn for undefined behavior in EXPR due to missing sequence
2591 verify_sequence_points (tree expr)
2593 struct tlist *before_sp = 0, *after_sp = 0;
2596 save_expr_cache = 0;
2597 if (tlist_firstobj == 0)
2599 gcc_obstack_init (&tlist_obstack);
2600 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2603 verify_tree (expr, &before_sp, &after_sp, 0);
2604 warn_for_collisions (after_sp);
2605 obstack_free (&tlist_obstack, tlist_firstobj);
2608 /* Validate the expression after `case' and apply default promotions. */
2611 check_case_value (tree value)
2613 if (value == NULL_TREE)
2616 if (TREE_CODE (value) == INTEGER_CST)
2617 /* Promote char or short to int. */
2618 value = perform_integral_promotions (value);
2619 else if (value != error_mark_node)
2621 error ("case label does not reduce to an integer constant");
2622 value = error_mark_node;
2625 constant_expression_warning (value);
2630 /* See if the case values LOW and HIGH are in the range of the original
2631 type (i.e. before the default conversion to int) of the switch testing
2633 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2634 the type before promoting it. CASE_LOW_P is a pointer to the lower
2635 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2636 if the case is not a case range.
2637 The caller has to make sure that we are not called with NULL for
2638 CASE_LOW_P (i.e. the default case).
2639 Returns true if the case label is in range of ORIG_TYPE (saturated or
2640 untouched) or false if the label is out of range. */
2643 check_case_bounds (tree type, tree orig_type,
2644 tree *case_low_p, tree *case_high_p)
2646 tree min_value, max_value;
2647 tree case_low = *case_low_p;
2648 tree case_high = case_high_p ? *case_high_p : case_low;
2650 /* If there was a problem with the original type, do nothing. */
2651 if (orig_type == error_mark_node)
2654 min_value = TYPE_MIN_VALUE (orig_type);
2655 max_value = TYPE_MAX_VALUE (orig_type);
2657 /* Case label is less than minimum for type. */
2658 if (tree_int_cst_compare (case_low, min_value) < 0
2659 && tree_int_cst_compare (case_high, min_value) < 0)
2661 warning (0, "case label value is less than minimum value for type");
2665 /* Case value is greater than maximum for type. */
2666 if (tree_int_cst_compare (case_low, max_value) > 0
2667 && tree_int_cst_compare (case_high, max_value) > 0)
2669 warning (0, "case label value exceeds maximum value for type");
2673 /* Saturate lower case label value to minimum. */
2674 if (tree_int_cst_compare (case_high, min_value) >= 0
2675 && tree_int_cst_compare (case_low, min_value) < 0)
2677 warning (0, "lower value in case label range"
2678 " less than minimum value for type");
2679 case_low = min_value;
2682 /* Saturate upper case label value to maximum. */
2683 if (tree_int_cst_compare (case_low, max_value) <= 0
2684 && tree_int_cst_compare (case_high, max_value) > 0)
2686 warning (0, "upper value in case label range"
2687 " exceeds maximum value for type");
2688 case_high = max_value;
2691 if (*case_low_p != case_low)
2692 *case_low_p = convert (type, case_low);
2693 if (case_high_p && *case_high_p != case_high)
2694 *case_high_p = convert (type, case_high);
2699 /* Return an integer type with BITS bits of precision,
2700 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2703 c_common_type_for_size (unsigned int bits, int unsignedp)
2705 if (bits == TYPE_PRECISION (integer_type_node))
2706 return unsignedp ? unsigned_type_node : integer_type_node;
2708 if (bits == TYPE_PRECISION (signed_char_type_node))
2709 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2711 if (bits == TYPE_PRECISION (short_integer_type_node))
2712 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2714 if (bits == TYPE_PRECISION (long_integer_type_node))
2715 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2717 if (bits == TYPE_PRECISION (long_long_integer_type_node))
2718 return (unsignedp ? long_long_unsigned_type_node
2719 : long_long_integer_type_node);
2721 if (int128_integer_type_node
2722 && bits == TYPE_PRECISION (int128_integer_type_node))
2723 return (unsignedp ? int128_unsigned_type_node
2724 : int128_integer_type_node);
2726 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2727 return (unsignedp ? widest_unsigned_literal_type_node
2728 : widest_integer_literal_type_node);
2730 if (bits <= TYPE_PRECISION (intQI_type_node))
2731 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2733 if (bits <= TYPE_PRECISION (intHI_type_node))
2734 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2736 if (bits <= TYPE_PRECISION (intSI_type_node))
2737 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2739 if (bits <= TYPE_PRECISION (intDI_type_node))
2740 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2745 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2746 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2747 and saturating if SATP is nonzero, otherwise not saturating. */
2750 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2751 int unsignedp, int satp)
2753 enum machine_mode mode;
2755 mode = unsignedp ? UQQmode : QQmode;
2757 mode = unsignedp ? UHAmode : HAmode;
2759 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2760 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2763 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2765 sorry ("GCC cannot support operators with integer types and "
2766 "fixed-point types that have too many integral and "
2767 "fractional bits together");
2771 return c_common_type_for_mode (mode, satp);
2774 /* Used for communication between c_common_type_for_mode and
2775 c_register_builtin_type. */
2776 static GTY(()) tree registered_builtin_types;
2778 /* Return a data type that has machine mode MODE.
2779 If the mode is an integer,
2780 then UNSIGNEDP selects between signed and unsigned types.
2781 If the mode is a fixed-point mode,
2782 then UNSIGNEDP selects between saturating and nonsaturating types. */
2785 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2789 if (mode == TYPE_MODE (integer_type_node))
2790 return unsignedp ? unsigned_type_node : integer_type_node;
2792 if (mode == TYPE_MODE (signed_char_type_node))
2793 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2795 if (mode == TYPE_MODE (short_integer_type_node))
2796 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2798 if (mode == TYPE_MODE (long_integer_type_node))
2799 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2801 if (mode == TYPE_MODE (long_long_integer_type_node))
2802 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2804 if (int128_integer_type_node
2805 && mode == TYPE_MODE (int128_integer_type_node))
2806 return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
2808 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2809 return unsignedp ? widest_unsigned_literal_type_node
2810 : widest_integer_literal_type_node;
2813 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2816 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2819 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2822 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2824 #if HOST_BITS_PER_WIDE_INT >= 64
2825 if (mode == TYPE_MODE (intTI_type_node))
2826 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2829 if (mode == TYPE_MODE (float_type_node))
2830 return float_type_node;
2832 if (mode == TYPE_MODE (double_type_node))
2833 return double_type_node;
2835 if (mode == TYPE_MODE (long_double_type_node))
2836 return long_double_type_node;
2838 if (mode == TYPE_MODE (void_type_node))
2839 return void_type_node;
2841 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2843 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2844 : make_signed_type (GET_MODE_PRECISION (mode)));
2846 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2848 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2849 : make_signed_type (GET_MODE_PRECISION (mode)));
2851 if (COMPLEX_MODE_P (mode))
2853 enum machine_mode inner_mode;
2856 if (mode == TYPE_MODE (complex_float_type_node))
2857 return complex_float_type_node;
2858 if (mode == TYPE_MODE (complex_double_type_node))
2859 return complex_double_type_node;
2860 if (mode == TYPE_MODE (complex_long_double_type_node))
2861 return complex_long_double_type_node;
2863 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2864 return complex_integer_type_node;
2866 inner_mode = GET_MODE_INNER (mode);
2867 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2868 if (inner_type != NULL_TREE)
2869 return build_complex_type (inner_type);
2871 else if (VECTOR_MODE_P (mode))
2873 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2874 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2875 if (inner_type != NULL_TREE)
2876 return build_vector_type_for_mode (inner_type, mode);
2879 if (mode == TYPE_MODE (dfloat32_type_node))
2880 return dfloat32_type_node;
2881 if (mode == TYPE_MODE (dfloat64_type_node))
2882 return dfloat64_type_node;
2883 if (mode == TYPE_MODE (dfloat128_type_node))
2884 return dfloat128_type_node;
2886 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2888 if (mode == TYPE_MODE (short_fract_type_node))
2889 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2890 if (mode == TYPE_MODE (fract_type_node))
2891 return unsignedp ? sat_fract_type_node : fract_type_node;
2892 if (mode == TYPE_MODE (long_fract_type_node))
2893 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2894 if (mode == TYPE_MODE (long_long_fract_type_node))
2895 return unsignedp ? sat_long_long_fract_type_node
2896 : long_long_fract_type_node;
2898 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2899 return unsignedp ? sat_unsigned_short_fract_type_node
2900 : unsigned_short_fract_type_node;
2901 if (mode == TYPE_MODE (unsigned_fract_type_node))
2902 return unsignedp ? sat_unsigned_fract_type_node
2903 : unsigned_fract_type_node;
2904 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2905 return unsignedp ? sat_unsigned_long_fract_type_node
2906 : unsigned_long_fract_type_node;
2907 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2908 return unsignedp ? sat_unsigned_long_long_fract_type_node
2909 : unsigned_long_long_fract_type_node;
2911 if (mode == TYPE_MODE (short_accum_type_node))
2912 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2913 if (mode == TYPE_MODE (accum_type_node))
2914 return unsignedp ? sat_accum_type_node : accum_type_node;
2915 if (mode == TYPE_MODE (long_accum_type_node))
2916 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2917 if (mode == TYPE_MODE (long_long_accum_type_node))
2918 return unsignedp ? sat_long_long_accum_type_node
2919 : long_long_accum_type_node;
2921 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2922 return unsignedp ? sat_unsigned_short_accum_type_node
2923 : unsigned_short_accum_type_node;
2924 if (mode == TYPE_MODE (unsigned_accum_type_node))
2925 return unsignedp ? sat_unsigned_accum_type_node
2926 : unsigned_accum_type_node;
2927 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2928 return unsignedp ? sat_unsigned_long_accum_type_node
2929 : unsigned_long_accum_type_node;
2930 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2931 return unsignedp ? sat_unsigned_long_long_accum_type_node
2932 : unsigned_long_long_accum_type_node;
2935 return unsignedp ? sat_qq_type_node : qq_type_node;
2937 return unsignedp ? sat_hq_type_node : hq_type_node;
2939 return unsignedp ? sat_sq_type_node : sq_type_node;
2941 return unsignedp ? sat_dq_type_node : dq_type_node;
2943 return unsignedp ? sat_tq_type_node : tq_type_node;
2945 if (mode == UQQmode)
2946 return unsignedp ? sat_uqq_type_node : uqq_type_node;
2947 if (mode == UHQmode)
2948 return unsignedp ? sat_uhq_type_node : uhq_type_node;
2949 if (mode == USQmode)
2950 return unsignedp ? sat_usq_type_node : usq_type_node;
2951 if (mode == UDQmode)
2952 return unsignedp ? sat_udq_type_node : udq_type_node;
2953 if (mode == UTQmode)
2954 return unsignedp ? sat_utq_type_node : utq_type_node;
2957 return unsignedp ? sat_ha_type_node : ha_type_node;
2959 return unsignedp ? sat_sa_type_node : sa_type_node;
2961 return unsignedp ? sat_da_type_node : da_type_node;
2963 return unsignedp ? sat_ta_type_node : ta_type_node;
2965 if (mode == UHAmode)
2966 return unsignedp ? sat_uha_type_node : uha_type_node;
2967 if (mode == USAmode)
2968 return unsignedp ? sat_usa_type_node : usa_type_node;
2969 if (mode == UDAmode)
2970 return unsignedp ? sat_uda_type_node : uda_type_node;
2971 if (mode == UTAmode)
2972 return unsignedp ? sat_uta_type_node : uta_type_node;
2975 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2976 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2977 return TREE_VALUE (t);
2983 c_common_unsigned_type (tree type)
2985 return c_common_signed_or_unsigned_type (1, type);
2988 /* Return a signed type the same as TYPE in other respects. */
2991 c_common_signed_type (tree type)
2993 return c_common_signed_or_unsigned_type (0, type);
2996 /* Return a type the same as TYPE except unsigned or
2997 signed according to UNSIGNEDP. */
3000 c_common_signed_or_unsigned_type (int unsignedp, tree type)
3004 /* This block of code emulates the behavior of the old
3005 c_common_unsigned_type. In particular, it returns
3006 long_unsigned_type_node if passed a long, even when a int would
3007 have the same size. This is necessary for warnings to work
3008 correctly in archs where sizeof(int) == sizeof(long) */
3010 type1 = TYPE_MAIN_VARIANT (type);
3011 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3012 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3013 if (type1 == integer_type_node || type1 == unsigned_type_node)
3014 return unsignedp ? unsigned_type_node : integer_type_node;
3015 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3016 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3017 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3018 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3019 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3020 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3021 if (int128_integer_type_node
3022 && (type1 == int128_integer_type_node
3023 || type1 == int128_unsigned_type_node))
3024 return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
3025 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3026 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3027 #if HOST_BITS_PER_WIDE_INT >= 64
3028 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3029 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3031 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3032 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3033 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3034 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3035 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3036 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3037 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3038 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3040 #define C_COMMON_FIXED_TYPES(NAME) \
3041 if (type1 == short_ ## NAME ## _type_node \
3042 || type1 == unsigned_short_ ## NAME ## _type_node) \
3043 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3044 : short_ ## NAME ## _type_node; \
3045 if (type1 == NAME ## _type_node \
3046 || type1 == unsigned_ ## NAME ## _type_node) \
3047 return unsignedp ? unsigned_ ## NAME ## _type_node \
3048 : NAME ## _type_node; \
3049 if (type1 == long_ ## NAME ## _type_node \
3050 || type1 == unsigned_long_ ## NAME ## _type_node) \
3051 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3052 : long_ ## NAME ## _type_node; \
3053 if (type1 == long_long_ ## NAME ## _type_node \
3054 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3055 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3056 : long_long_ ## NAME ## _type_node;
3058 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3059 if (type1 == NAME ## _type_node \
3060 || type1 == u ## NAME ## _type_node) \
3061 return unsignedp ? u ## NAME ## _type_node \
3062 : NAME ## _type_node;
3064 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3065 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3066 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3067 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3068 : sat_ ## short_ ## NAME ## _type_node; \
3069 if (type1 == sat_ ## NAME ## _type_node \
3070 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3071 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3072 : sat_ ## NAME ## _type_node; \
3073 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3074 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3075 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3076 : sat_ ## long_ ## NAME ## _type_node; \
3077 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3078 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3079 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3080 : sat_ ## long_long_ ## NAME ## _type_node;
3082 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3083 if (type1 == sat_ ## NAME ## _type_node \
3084 || type1 == sat_ ## u ## NAME ## _type_node) \
3085 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3086 : sat_ ## NAME ## _type_node;
3088 C_COMMON_FIXED_TYPES (fract);
3089 C_COMMON_FIXED_TYPES_SAT (fract);
3090 C_COMMON_FIXED_TYPES (accum);
3091 C_COMMON_FIXED_TYPES_SAT (accum);
3093 C_COMMON_FIXED_MODE_TYPES (qq);
3094 C_COMMON_FIXED_MODE_TYPES (hq);
3095 C_COMMON_FIXED_MODE_TYPES (sq);
3096 C_COMMON_FIXED_MODE_TYPES (dq);
3097 C_COMMON_FIXED_MODE_TYPES (tq);
3098 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3099 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3100 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3101 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3102 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3103 C_COMMON_FIXED_MODE_TYPES (ha);
3104 C_COMMON_FIXED_MODE_TYPES (sa);
3105 C_COMMON_FIXED_MODE_TYPES (da);
3106 C_COMMON_FIXED_MODE_TYPES (ta);
3107 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3108 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3109 C_COMMON_FIXED_MODE_TYPES_SAT (da);
3110 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3112 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3113 the precision; they have precision set to match their range, but
3114 may use a wider mode to match an ABI. If we change modes, we may
3115 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3116 the precision as well, so as to yield correct results for
3117 bit-field types. C++ does not have these separate bit-field
3118 types, and producing a signed or unsigned variant of an
3119 ENUMERAL_TYPE may cause other problems as well. */
3121 if (!INTEGRAL_TYPE_P (type)
3122 || TYPE_UNSIGNED (type) == unsignedp)
3125 #define TYPE_OK(node) \
3126 (TYPE_MODE (type) == TYPE_MODE (node) \
3127 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3128 if (TYPE_OK (signed_char_type_node))
3129 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3130 if (TYPE_OK (integer_type_node))
3131 return unsignedp ? unsigned_type_node : integer_type_node;
3132 if (TYPE_OK (short_integer_type_node))
3133 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3134 if (TYPE_OK (long_integer_type_node))
3135 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3136 if (TYPE_OK (long_long_integer_type_node))
3137 return (unsignedp ? long_long_unsigned_type_node
3138 : long_long_integer_type_node);
3139 if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
3140 return (unsignedp ? int128_unsigned_type_node
3141 : int128_integer_type_node);
3142 if (TYPE_OK (widest_integer_literal_type_node))
3143 return (unsignedp ? widest_unsigned_literal_type_node
3144 : widest_integer_literal_type_node);
3146 #if HOST_BITS_PER_WIDE_INT >= 64
3147 if (TYPE_OK (intTI_type_node))
3148 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3150 if (TYPE_OK (intDI_type_node))
3151 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3152 if (TYPE_OK (intSI_type_node))
3153 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3154 if (TYPE_OK (intHI_type_node))
3155 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3156 if (TYPE_OK (intQI_type_node))
3157 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3160 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3163 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3166 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3168 /* Extended integer types of the same width as a standard type have
3169 lesser rank, so those of the same width as int promote to int or
3170 unsigned int and are valid for printf formats expecting int or
3171 unsigned int. To avoid such special cases, avoid creating
3172 extended integer types for bit-fields if a standard integer type
3174 if (width == TYPE_PRECISION (integer_type_node))
3175 return unsignedp ? unsigned_type_node : integer_type_node;
3176 if (width == TYPE_PRECISION (signed_char_type_node))
3177 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3178 if (width == TYPE_PRECISION (short_integer_type_node))
3179 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3180 if (width == TYPE_PRECISION (long_integer_type_node))
3181 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3182 if (width == TYPE_PRECISION (long_long_integer_type_node))
3183 return (unsignedp ? long_long_unsigned_type_node
3184 : long_long_integer_type_node);
3185 if (int128_integer_type_node
3186 && width == TYPE_PRECISION (int128_integer_type_node))
3187 return (unsignedp ? int128_unsigned_type_node
3188 : int128_integer_type_node);
3189 return build_nonstandard_integer_type (width, unsignedp);
3192 /* The C version of the register_builtin_type langhook. */
3195 c_register_builtin_type (tree type, const char* name)
3199 decl = build_decl (UNKNOWN_LOCATION,
3200 TYPE_DECL, get_identifier (name), type);
3201 DECL_ARTIFICIAL (decl) = 1;
3202 if (!TYPE_NAME (type))
3203 TYPE_NAME (type) = decl;
3206 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3209 /* Print an error message for invalid operands to arith operation
3210 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3211 LOCATION is the location of the message. */
3214 binary_op_error (location_t location, enum tree_code code,
3215 tree type0, tree type1)
3222 opname = "+"; break;
3224 opname = "-"; break;
3226 opname = "*"; break;
3228 opname = "max"; break;
3230 opname = "min"; break;
3232 opname = "=="; break;
3234 opname = "!="; break;
3236 opname = "<="; break;
3238 opname = ">="; break;
3240 opname = "<"; break;
3242 opname = ">"; break;
3244 opname = "<<"; break;
3246 opname = ">>"; break;
3247 case TRUNC_MOD_EXPR:
3248 case FLOOR_MOD_EXPR:
3249 opname = "%"; break;
3250 case TRUNC_DIV_EXPR:
3251 case FLOOR_DIV_EXPR:
3252 opname = "/"; break;
3254 opname = "&"; break;
3256 opname = "|"; break;
3257 case TRUTH_ANDIF_EXPR:
3258 opname = "&&"; break;
3259 case TRUTH_ORIF_EXPR:
3260 opname = "||"; break;
3262 opname = "^"; break;
3267 "invalid operands to binary %s (have %qT and %qT)", opname,
3271 /* Subroutine of build_binary_op, used for comparison operations.
3272 See if the operands have both been converted from subword integer types
3273 and, if so, perhaps change them both back to their original type.
3274 This function is also responsible for converting the two operands
3275 to the proper common type for comparison.
3277 The arguments of this function are all pointers to local variables
3278 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3279 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3281 If this function returns nonzero, it means that the comparison has
3282 a constant value. What this function returns is an expression for
3286 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3287 enum tree_code *rescode_ptr)
3290 tree op0 = *op0_ptr;
3291 tree op1 = *op1_ptr;
3292 int unsignedp0, unsignedp1;
3294 tree primop0, primop1;
3295 enum tree_code code = *rescode_ptr;
3297 /* Throw away any conversions to wider types
3298 already present in the operands. */
3300 primop0 = get_narrower (op0, &unsignedp0);
3301 primop1 = get_narrower (op1, &unsignedp1);
3303 /* Handle the case that OP0 does not *contain* a conversion
3304 but it *requires* conversion to FINAL_TYPE. */
3306 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3307 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3308 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3309 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3311 /* If one of the operands must be floated, we cannot optimize. */
3312 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3313 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3315 /* If first arg is constant, swap the args (changing operation
3316 so value is preserved), for canonicalization. Don't do this if
3317 the second arg is 0. */
3319 if (TREE_CONSTANT (primop0)
3320 && !integer_zerop (primop1) && !real_zerop (primop1)
3321 && !fixed_zerop (primop1))
3324 int temi = unsignedp0;
3332 unsignedp0 = unsignedp1;
3355 *rescode_ptr = code;
3358 /* If comparing an integer against a constant more bits wide,
3359 maybe we can deduce a value of 1 or 0 independent of the data.
3360 Or else truncate the constant now
3361 rather than extend the variable at run time.
3363 This is only interesting if the constant is the wider arg.
3364 Also, it is not safe if the constant is unsigned and the
3365 variable arg is signed, since in this case the variable
3366 would be sign-extended and then regarded as unsigned.
3367 Our technique fails in this case because the lowest/highest
3368 possible unsigned results don't follow naturally from the
3369 lowest/highest possible values of the variable operand.
3370 For just EQ_EXPR and NE_EXPR there is another technique that
3371 could be used: see if the constant can be faithfully represented
3372 in the other operand's type, by truncating it and reextending it
3373 and see if that preserves the constant's value. */
3375 if (!real1 && !real2
3376 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
3377 && TREE_CODE (primop1) == INTEGER_CST
3378 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3380 int min_gt, max_gt, min_lt, max_lt;
3381 tree maxval, minval;
3382 /* 1 if comparison is nominally unsigned. */
3383 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
3386 type = c_common_signed_or_unsigned_type (unsignedp0,
3387 TREE_TYPE (primop0));
3389 maxval = TYPE_MAX_VALUE (type);
3390 minval = TYPE_MIN_VALUE (type);
3392 if (unsignedp && !unsignedp0)
3393 *restype_ptr = c_common_signed_type (*restype_ptr);
3395 if (TREE_TYPE (primop1) != *restype_ptr)
3397 /* Convert primop1 to target type, but do not introduce
3398 additional overflow. We know primop1 is an int_cst. */
3399 primop1 = force_fit_type_double (*restype_ptr,
3400 tree_to_double_int (primop1),
3401 0, TREE_OVERFLOW (primop1));
3403 if (type != *restype_ptr)
3405 minval = convert (*restype_ptr, minval);
3406 maxval = convert (*restype_ptr, maxval);
3409 if (unsignedp && unsignedp0)
3411 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3412 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3413 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3414 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3418 min_gt = INT_CST_LT (primop1, minval);
3419 max_gt = INT_CST_LT (primop1, maxval);
3420 min_lt = INT_CST_LT (minval, primop1);
3421 max_lt = INT_CST_LT (maxval, primop1);
3425 /* This used to be a switch, but Genix compiler can't handle that. */
3426 if (code == NE_EXPR)
3428 if (max_lt || min_gt)
3429 val = truthvalue_true_node;
3431 else if (code == EQ_EXPR)
3433 if (max_lt || min_gt)
3434 val = truthvalue_false_node;
3436 else if (code == LT_EXPR)
3439 val = truthvalue_true_node;
3441 val = truthvalue_false_node;
3443 else if (code == GT_EXPR)
3446 val = truthvalue_true_node;
3448 val = truthvalue_false_node;
3450 else if (code == LE_EXPR)
3453 val = truthvalue_true_node;
3455 val = truthvalue_false_node;
3457 else if (code == GE_EXPR)
3460 val = truthvalue_true_node;
3462 val = truthvalue_false_node;
3465 /* If primop0 was sign-extended and unsigned comparison specd,
3466 we did a signed comparison above using the signed type bounds.
3467 But the comparison we output must be unsigned.
3469 Also, for inequalities, VAL is no good; but if the signed
3470 comparison had *any* fixed result, it follows that the
3471 unsigned comparison just tests the sign in reverse
3472 (positive values are LE, negative ones GE).
3473 So we can generate an unsigned comparison
3474 against an extreme value of the signed type. */
3476 if (unsignedp && !unsignedp0)
3483 primop1 = TYPE_MIN_VALUE (type);
3489 primop1 = TYPE_MAX_VALUE (type);
3496 type = c_common_unsigned_type (type);
3499 if (TREE_CODE (primop0) != INTEGER_CST)
3501 if (val == truthvalue_false_node)
3502 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3503 if (val == truthvalue_true_node)
3504 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3509 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3510 if (TREE_SIDE_EFFECTS (primop0))
3511 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3515 /* Value is not predetermined, but do the comparison
3516 in the type of the operand that is not constant.
3517 TYPE is already properly set. */
3520 /* If either arg is decimal float and the other is float, find the
3521 proper common type to use for comparison. */
3522 else if (real1 && real2
3523 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3524 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3525 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3527 else if (real1 && real2
3528 && (TYPE_PRECISION (TREE_TYPE (primop0))
3529 == TYPE_PRECISION (TREE_TYPE (primop1))))
3530 type = TREE_TYPE (primop0);
3532 /* If args' natural types are both narrower than nominal type
3533 and both extend in the same manner, compare them
3534 in the type of the wider arg.
3535 Otherwise must actually extend both to the nominal
3536 common type lest different ways of extending
3538 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3540 else if (unsignedp0 == unsignedp1 && real1 == real2
3541 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3542 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3544 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3545 type = c_common_signed_or_unsigned_type (unsignedp0
3546 || TYPE_UNSIGNED (*restype_ptr),
3548 /* Make sure shorter operand is extended the right way
3549 to match the longer operand. */
3551 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3552 TREE_TYPE (primop0)),
3555 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3556 TREE_TYPE (primop1)),
3561 /* Here we must do the comparison on the nominal type
3562 using the args exactly as we received them. */
3563 type = *restype_ptr;
3567 if (!real1 && !real2 && integer_zerop (primop1)
3568 && TYPE_UNSIGNED (*restype_ptr))
3574 /* All unsigned values are >= 0, so we warn. However,
3575 if OP0 is a constant that is >= 0, the signedness of
3576 the comparison isn't an issue, so suppress the
3578 if (warn_type_limits && !in_system_header
3579 && !(TREE_CODE (primop0) == INTEGER_CST
3580 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3582 warning (OPT_Wtype_limits,
3583 "comparison of unsigned expression >= 0 is always true");
3584 value = truthvalue_true_node;
3588 if (warn_type_limits && !in_system_header
3589 && !(TREE_CODE (primop0) == INTEGER_CST
3590 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3592 warning (OPT_Wtype_limits,
3593 "comparison of unsigned expression < 0 is always false");
3594 value = truthvalue_false_node;
3603 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3604 if (TREE_SIDE_EFFECTS (primop0))
3605 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3612 *op0_ptr = convert (type, primop0);
3613 *op1_ptr = convert (type, primop1);
3615 *restype_ptr = truthvalue_type_node;
3620 /* Return a tree for the sum or difference (RESULTCODE says which)
3621 of pointer PTROP and integer INTOP. */
3624 pointer_int_sum (location_t loc, enum tree_code resultcode,
3625 tree ptrop, tree intop)
3629 /* The result is a pointer of the same type that is being added. */
3630 tree result_type = TREE_TYPE (ptrop);
3632 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3634 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3635 "pointer of type %<void *%> used in arithmetic");
3636 size_exp = integer_one_node;
3638 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3640 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3641 "pointer to a function used in arithmetic");
3642 size_exp = integer_one_node;
3644 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3646 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3647 "pointer to member function used in arithmetic");
3648 size_exp = integer_one_node;
3651 size_exp = size_in_bytes (TREE_TYPE (result_type));
3653 /* We are manipulating pointer values, so we don't need to warn
3654 about relying on undefined signed overflow. We disable the
3655 warning here because we use integer types so fold won't know that
3656 they are really pointers. */
3657 fold_defer_overflow_warnings ();
3659 /* If what we are about to multiply by the size of the elements
3660 contains a constant term, apply distributive law
3661 and multiply that constant term separately.
3662 This helps produce common subexpressions. */
3663 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3664 && !TREE_CONSTANT (intop)
3665 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3666 && TREE_CONSTANT (size_exp)
3667 /* If the constant comes from pointer subtraction,
3668 skip this optimization--it would cause an error. */
3669 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3670 /* If the constant is unsigned, and smaller than the pointer size,
3671 then we must skip this optimization. This is because it could cause
3672 an overflow error if the constant is negative but INTOP is not. */
3673 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3674 || (TYPE_PRECISION (TREE_TYPE (intop))
3675 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3677 enum tree_code subcode = resultcode;
3678 tree int_type = TREE_TYPE (intop);
3679 if (TREE_CODE (intop) == MINUS_EXPR)
3680 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3681 /* Convert both subexpression types to the type of intop,
3682 because weird cases involving pointer arithmetic
3683 can result in a sum or difference with different type args. */
3684 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3686 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3687 intop = convert (int_type, TREE_OPERAND (intop, 0));
3690 /* Convert the integer argument to a type the same size as sizetype
3691 so the multiply won't overflow spuriously. */
3692 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3693 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3694 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3695 TYPE_UNSIGNED (sizetype)), intop);
3697 /* Replace the integer argument with a suitable product by the object size.
3698 Do this multiplication as signed, then convert to the appropriate type
3699 for the pointer operation and disregard an overflow that occured only
3700 because of the sign-extension change in the latter conversion. */
3702 tree t = build_binary_op (loc,
3704 convert (TREE_TYPE (intop), size_exp), 1);
3705 intop = convert (sizetype, t);
3706 if (TREE_OVERFLOW_P (intop) && !TREE_OVERFLOW (t))
3707 intop = build_int_cst_wide (TREE_TYPE (intop), TREE_INT_CST_LOW (intop),
3708 TREE_INT_CST_HIGH (intop));
3711 /* Create the sum or difference. */
3712 if (resultcode == MINUS_EXPR)
3713 intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop);
3715 ret = fold_build2_loc (loc, POINTER_PLUS_EXPR, result_type, ptrop, intop);
3717 fold_undefer_and_ignore_overflow_warnings ();
3722 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3723 and if NON_CONST is known not to be permitted in an evaluated part
3724 of a constant expression. */
3727 c_wrap_maybe_const (tree expr, bool non_const)
3729 bool nowarning = TREE_NO_WARNING (expr);
3730 location_t loc = EXPR_LOCATION (expr);
3732 /* This should never be called for C++. */
3733 if (c_dialect_cxx ())
3736 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3737 STRIP_TYPE_NOPS (expr);
3738 expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3739 C_MAYBE_CONST_EXPR_NON_CONST (expr) = non_const;
3741 TREE_NO_WARNING (expr) = 1;
3742 protected_set_expr_location (expr, loc);
3747 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3748 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3749 around the SAVE_EXPR if needed so that c_fully_fold does not need
3750 to look inside SAVE_EXPRs. */
3753 c_save_expr (tree expr)
3755 bool maybe_const = true;
3756 if (c_dialect_cxx ())
3757 return save_expr (expr);
3758 expr = c_fully_fold (expr, false, &maybe_const);
3759 expr = save_expr (expr);
3761 expr = c_wrap_maybe_const (expr, true);
3765 /* Return whether EXPR is a declaration whose address can never be
3769 decl_with_nonnull_addr_p (const_tree expr)
3771 return (DECL_P (expr)
3772 && (TREE_CODE (expr) == PARM_DECL
3773 || TREE_CODE (expr) == LABEL_DECL
3774 || !DECL_WEAK (expr)));
3777 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3778 or for an `if' or `while' statement or ?..: exp. It should already
3779 have been validated to be of suitable type; otherwise, a bad
3780 diagnostic may result.
3782 The EXPR is located at LOCATION.
3784 This preparation consists of taking the ordinary
3785 representation of an expression expr and producing a valid tree
3786 boolean expression describing whether expr is nonzero. We could
3787 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3788 but we optimize comparisons, &&, ||, and !.
3790 The resulting type should always be `truthvalue_type_node'. */
3793 c_common_truthvalue_conversion (location_t location, tree expr)
3795 switch (TREE_CODE (expr))
3797 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
3798 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3799 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3800 case ORDERED_EXPR: case UNORDERED_EXPR:
3801 if (TREE_TYPE (expr) == truthvalue_type_node)
3803 expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3804 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3807 case TRUTH_ANDIF_EXPR:
3808 case TRUTH_ORIF_EXPR:
3809 case TRUTH_AND_EXPR:
3811 case TRUTH_XOR_EXPR:
3812 if (TREE_TYPE (expr) == truthvalue_type_node)
3814 expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3815 c_common_truthvalue_conversion (location,
3816 TREE_OPERAND (expr, 0)),
3817 c_common_truthvalue_conversion (location,
3818 TREE_OPERAND (expr, 1)));
3821 case TRUTH_NOT_EXPR:
3822 if (TREE_TYPE (expr) == truthvalue_type_node)
3824 expr = build1 (TREE_CODE (expr), truthvalue_type_node,
3825 c_common_truthvalue_conversion (location,
3826 TREE_OPERAND (expr, 0)));
3833 return integer_zerop (expr) ? truthvalue_false_node
3834 : truthvalue_true_node;
3837 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3838 ? truthvalue_true_node
3839 : truthvalue_false_node;
3842 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3843 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3844 ? truthvalue_true_node
3845 : truthvalue_false_node;
3848 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3853 tree inner = TREE_OPERAND (expr, 0);
3854 if (decl_with_nonnull_addr_p (inner))
3856 /* Common Ada/Pascal programmer's mistake. */
3857 warning_at (location,
3859 "the address of %qD will always evaluate as %<true%>",
3861 return truthvalue_true_node;
3867 expr = build_binary_op (EXPR_LOCATION (expr),
3868 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3869 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3870 c_common_truthvalue_conversion (location,
3871 TREE_OPERAND (expr, 0)),
3872 c_common_truthvalue_conversion (location,
3873 TREE_OPERAND (expr, 1)),
3880 case EXCESS_PRECISION_EXPR:
3881 /* These don't change whether an object is nonzero or zero. */
3882 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
3886 /* These don't change whether an object is zero or nonzero, but
3887 we can't ignore them if their second arg has side-effects. */
3888 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3890 expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
3891 TREE_OPERAND (expr, 1),
3892 c_common_truthvalue_conversion
3893 (location, TREE_OPERAND (expr, 0)));
3897 return c_common_truthvalue_conversion (location,
3898 TREE_OPERAND (expr, 0));
3901 /* Distribute the conversion into the arms of a COND_EXPR. */
3902 if (c_dialect_cxx ())
3904 expr = fold_build3_loc (location, COND_EXPR, truthvalue_type_node,
3905 TREE_OPERAND (expr, 0),
3906 c_common_truthvalue_conversion (location,
3909 c_common_truthvalue_conversion (location,
3916 /* Folding will happen later for C. */
3917 expr = build3 (COND_EXPR, truthvalue_type_node,
3918 TREE_OPERAND (expr, 0),
3919 c_common_truthvalue_conversion (location,
3920 TREE_OPERAND (expr, 1)),
3921 c_common_truthvalue_conversion (location,
3922 TREE_OPERAND (expr, 2)));
3927 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3928 since that affects how `default_conversion' will behave. */
3929 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3930 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3932 /* If this is widening the argument, we can ignore it. */
3933 if (TYPE_PRECISION (TREE_TYPE (expr))
3934 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3935 return c_common_truthvalue_conversion (location,
3936 TREE_OPERAND (expr, 0));
3940 if (!TREE_NO_WARNING (expr)
3941 && warn_parentheses)
3943 warning (OPT_Wparentheses,
3944 "suggest parentheses around assignment used as truth value");
3945 TREE_NO_WARNING (expr) = 1;
3953 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3955 tree t = (in_late_binary_op ? save_expr (expr) : c_save_expr (expr));
3956 expr = (build_binary_op
3957 (EXPR_LOCATION (expr),
3958 (TREE_SIDE_EFFECTS (expr)
3959 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3960 c_common_truthvalue_conversion
3962 build_unary_op (location, REALPART_EXPR, t, 0)),
3963 c_common_truthvalue_conversion
3965 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3970 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3972 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3974 (TREE_TYPE (expr))));
3975 return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
3978 return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
3981 protected_set_expr_location (expr, location);
3985 static void def_builtin_1 (enum built_in_function fncode,
3987 enum built_in_class fnclass,
3988 tree fntype, tree libtype,
3989 bool both_p, bool fallback_p, bool nonansi_p,
3990 tree fnattrs, bool implicit_p);
3993 /* Apply the TYPE_QUALS to the new DECL. */
3996 c_apply_type_quals_to_decl (int type_quals, tree decl)
3998 tree type = TREE_TYPE (decl);
4000 if (type == error_mark_node)
4003 if (((type_quals & TYPE_QUAL_CONST)
4004 || (type && TREE_CODE (type) == REFERENCE_TYPE))
4005 /* An object declared 'const' is only readonly after it is
4006 initialized. We don't have any way of expressing this currently,
4007 so we need to be conservative and unset TREE_READONLY for types
4008 with constructors. Otherwise aliasing code will ignore stores in
4009 an inline constructor. */
4010 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
4011 TREE_READONLY (decl) = 1;
4012 if (type_quals & TYPE_QUAL_VOLATILE)
4014 TREE_SIDE_EFFECTS (decl) = 1;
4015 TREE_THIS_VOLATILE (decl) = 1;
4017 if (type_quals & TYPE_QUAL_RESTRICT)
4019 while (type && TREE_CODE (type) == ARRAY_TYPE)
4020 /* Allow 'restrict' on arrays of pointers.
4021 FIXME currently we just ignore it. */
4022 type = TREE_TYPE (type);
4024 || !POINTER_TYPE_P (type)
4025 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
4026 error ("invalid use of %<restrict%>");
4030 /* Hash function for the problem of multiple type definitions in
4031 different files. This must hash all types that will compare
4032 equal via comptypes to the same value. In practice it hashes
4033 on some of the simple stuff and leaves the details to comptypes. */
4036 c_type_hash (const void *p)
4040 const_tree const t = (const_tree) p;
4042 switch (TREE_CODE (t))
4044 /* For pointers, hash on pointee type plus some swizzling. */
4046 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4047 /* Hash on number of elements and total size. */
4050 t2 = TYPE_VALUES (t);
4054 t2 = TYPE_FIELDS (t);
4056 case QUAL_UNION_TYPE:
4058 t2 = TYPE_FIELDS (t);
4062 t2 = TYPE_FIELDS (t);
4067 /* FIXME: We want to use a DECL_CHAIN iteration method here, but
4068 TYPE_VALUES of ENUMERAL_TYPEs is stored as a TREE_LIST. */
4069 n_elements = list_length (t2);
4070 /* We might have a VLA here. */
4071 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4074 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
4075 return ((size << 24) | (n_elements << shift));
4078 static GTY((param_is (union tree_node))) htab_t type_hash_table;
4080 /* Return the typed-based alias set for T, which may be an expression
4081 or a type. Return -1 if we don't do anything special. */
4084 c_common_get_alias_set (tree t)
4089 /* For VLAs, use the alias set of the element type rather than the
4090 default of alias set 0 for types compared structurally. */
4091 if (TYPE_P (t) && TYPE_STRUCTURAL_EQUALITY_P (t))
4093 if (TREE_CODE (t) == ARRAY_TYPE)
4094 return get_alias_set (TREE_TYPE (t));
4098 /* Permit type-punning when accessing a union, provided the access
4099 is directly through the union. For example, this code does not
4100 permit taking the address of a union member and then storing
4101 through it. Even the type-punning allowed here is a GCC
4102 extension, albeit a common and useful one; the C standard says
4103 that such accesses have implementation-defined behavior. */
4105 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4106 u = TREE_OPERAND (u, 0))
4107 if (TREE_CODE (u) == COMPONENT_REF
4108 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4111 /* That's all the expressions we handle specially. */
4115 /* The C standard guarantees that any object may be accessed via an
4116 lvalue that has character type. */
4117 if (t == char_type_node
4118 || t == signed_char_type_node
4119 || t == unsigned_char_type_node)
4122 /* The C standard specifically allows aliasing between signed and
4123 unsigned variants of the same type. We treat the signed
4124 variant as canonical. */
4125 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4127 tree t1 = c_common_signed_type (t);
4129 /* t1 == t can happen for boolean nodes which are always unsigned. */
4131 return get_alias_set (t1);
4134 /* Handle the case of multiple type nodes referring to "the same" type,
4135 which occurs with IMA. These share an alias set. FIXME: Currently only
4136 C90 is handled. (In C99 type compatibility is not transitive, which
4137 complicates things mightily. The alias set splay trees can theoretically
4138 represent this, but insertion is tricky when you consider all the
4139 different orders things might arrive in.) */
4141 if (c_language != clk_c || flag_isoc99)
4144 /* Save time if there's only one input file. */
4145 if (num_in_fnames == 1)
4148 /* Pointers need special handling if they point to any type that
4149 needs special handling (below). */
4150 if (TREE_CODE (t) == POINTER_TYPE)
4153 /* Find bottom type under any nested POINTERs. */
4154 for (t2 = TREE_TYPE (t);
4155 TREE_CODE (t2) == POINTER_TYPE;
4156 t2 = TREE_TYPE (t2))
4158 if (TREE_CODE (t2) != RECORD_TYPE
4159 && TREE_CODE (t2) != ENUMERAL_TYPE
4160 && TREE_CODE (t2) != QUAL_UNION_TYPE
4161 && TREE_CODE (t2) != UNION_TYPE)
4163 if (TYPE_SIZE (t2) == 0)
4166 /* These are the only cases that need special handling. */
4167 if (TREE_CODE (t) != RECORD_TYPE
4168 && TREE_CODE (t) != ENUMERAL_TYPE
4169 && TREE_CODE (t) != QUAL_UNION_TYPE
4170 && TREE_CODE (t) != UNION_TYPE
4171 && TREE_CODE (t) != POINTER_TYPE)
4174 if (TYPE_SIZE (t) == 0)
4177 /* Look up t in hash table. Only one of the compatible types within each
4178 alias set is recorded in the table. */
4179 if (!type_hash_table)
4180 type_hash_table = htab_create_ggc (1021, c_type_hash,
4181 (htab_eq) lang_hooks.types_compatible_p,
4183 slot = htab_find_slot (type_hash_table, t, INSERT);
4186 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4187 return TYPE_ALIAS_SET ((tree)*slot);
4190 /* Our caller will assign and record (in t) a new alias set; all we need
4191 to do is remember t in the hash table. */
4197 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4198 the second parameter indicates which OPERATOR is being applied.
4199 The COMPLAIN flag controls whether we should diagnose possibly
4200 ill-formed constructs or not. LOC is the location of the SIZEOF or
4204 c_sizeof_or_alignof_type (location_t loc,
4205 tree type, bool is_sizeof, int complain)
4207 const char *op_name;
4209 enum tree_code type_code = TREE_CODE (type);
4211 op_name = is_sizeof ? "sizeof" : "__alignof__";
4213 if (type_code == FUNCTION_TYPE)
4217 if (complain && (pedantic || warn_pointer_arith))
4218 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4219 "invalid application of %<sizeof%> to a function type");
4221 return error_mark_node;
4222 value = size_one_node;
4225 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4227 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4229 if (type_code == VOID_TYPE
4230 && complain && (pedantic || warn_pointer_arith))
4231 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4232 "invalid application of %qs to a void type", op_name);
4234 return error_mark_node;
4235 value = size_one_node;
4237 else if (!COMPLETE_TYPE_P (type))
4240 error_at (loc, "invalid application of %qs to incomplete type %qT ",
4242 return error_mark_node;
4247 /* Convert in case a char is more than one unit. */
4248 value = size_binop_loc (loc, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4249 size_int (TYPE_PRECISION (char_type_node)
4252 value = size_int (TYPE_ALIGN_UNIT (type));
4255 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4256 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4257 never happen. However, this node should really have type
4258 `size_t', which is just a typedef for an ordinary integer type. */
4259 value = fold_convert_loc (loc, size_type_node, value);
4260 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
4265 /* Implement the __alignof keyword: Return the minimum required
4266 alignment of EXPR, measured in bytes. For VAR_DECLs,
4267 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4268 from an "aligned" __attribute__ specification). LOC is the
4269 location of the ALIGNOF operator. */
4272 c_alignof_expr (location_t loc, tree expr)
4276 if (VAR_OR_FUNCTION_DECL_P (expr))
4277 t = size_int (DECL_ALIGN_UNIT (expr));
4279 else if (TREE_CODE (expr) == COMPONENT_REF
4280 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4282 error_at (loc, "%<__alignof%> applied to a bit-field");
4285 else if (TREE_CODE (expr) == COMPONENT_REF
4286 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
4287 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
4289 else if (TREE_CODE (expr) == INDIRECT_REF)
4291 tree t = TREE_OPERAND (expr, 0);
4293 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4295 while (CONVERT_EXPR_P (t)
4296 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
4300 t = TREE_OPERAND (t, 0);
4301 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4302 if (thisalign > bestalign)
4303 best = t, bestalign = thisalign;
4305 return c_alignof (loc, TREE_TYPE (TREE_TYPE (best)));
4308 return c_alignof (loc, TREE_TYPE (expr));
4310 return fold_convert_loc (loc, size_type_node, t);
4313 /* Handle C and C++ default attributes. */
4315 enum built_in_attribute
4317 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4318 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4319 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4320 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4321 #include "builtin-attrs.def"
4322 #undef DEF_ATTR_NULL_TREE
4324 #undef DEF_ATTR_IDENT
4325 #undef DEF_ATTR_TREE_LIST
4329 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4331 static void c_init_attributes (void);
4335 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4336 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4337 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4338 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4339 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4340 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4341 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4342 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4343 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4344 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4345 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4346 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4347 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4348 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4349 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4351 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4352 #include "builtin-types.def"
4353 #undef DEF_PRIMITIVE_TYPE
4354 #undef DEF_FUNCTION_TYPE_0
4355 #undef DEF_FUNCTION_TYPE_1
4356 #undef DEF_FUNCTION_TYPE_2
4357 #undef DEF_FUNCTION_TYPE_3
4358 #undef DEF_FUNCTION_TYPE_4
4359 #undef DEF_FUNCTION_TYPE_5
4360 #undef DEF_FUNCTION_TYPE_6
4361 #undef DEF_FUNCTION_TYPE_7
4362 #undef DEF_FUNCTION_TYPE_VAR_0
4363 #undef DEF_FUNCTION_TYPE_VAR_1
4364 #undef DEF_FUNCTION_TYPE_VAR_2
4365 #undef DEF_FUNCTION_TYPE_VAR_3
4366 #undef DEF_FUNCTION_TYPE_VAR_4
4367 #undef DEF_FUNCTION_TYPE_VAR_5
4368 #undef DEF_POINTER_TYPE
4372 typedef enum c_builtin_type builtin_type;
4374 /* A temporary array for c_common_nodes_and_builtins. Used in
4375 communication with def_fn_type. */
4376 static tree builtin_types[(int) BT_LAST + 1];
4378 /* A helper function for c_common_nodes_and_builtins. Build function type
4379 for DEF with return type RET and N arguments. If VAR is true, then the
4380 function should be variadic after those N arguments.
4382 Takes special care not to ICE if any of the types involved are
4383 error_mark_node, which indicates that said type is not in fact available
4384 (see builtin_type_for_size). In which case the function type as a whole
4385 should be error_mark_node. */
4388 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4390 tree args = NULL, t;
4395 for (i = 0; i < n; ++i)
4397 builtin_type a = (builtin_type) va_arg (list, int);
4398 t = builtin_types[a];
4399 if (t == error_mark_node)
4401 args = tree_cons (NULL_TREE, t, args);
4405 args = nreverse (args);
4407 args = chainon (args, void_list_node);
4409 t = builtin_types[ret];
4410 if (t == error_mark_node)
4412 t = build_function_type (t, args);
4415 builtin_types[def] = t;
4418 /* Build builtin functions common to both C and C++ language
4422 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4424 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4425 builtin_types[ENUM] = VALUE;
4426 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4427 def_fn_type (ENUM, RETURN, 0, 0);
4428 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4429 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4430 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4431 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4432 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4433 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4434 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4435 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4436 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4437 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4438 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4440 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4441 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4443 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4444 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4445 def_fn_type (ENUM, RETURN, 1, 0);
4446 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4447 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4448 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4449 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4450 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4451 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4452 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4453 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4454 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4455 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4456 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4457 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4459 #include "builtin-types.def"
4461 #undef DEF_PRIMITIVE_TYPE
4462 #undef DEF_FUNCTION_TYPE_1
4463 #undef DEF_FUNCTION_TYPE_2
4464 #undef DEF_FUNCTION_TYPE_3
4465 #undef DEF_FUNCTION_TYPE_4
4466 #undef DEF_FUNCTION_TYPE_5
4467 #undef DEF_FUNCTION_TYPE_6
4468 #undef DEF_FUNCTION_TYPE_VAR_0
4469 #undef DEF_FUNCTION_TYPE_VAR_1
4470 #undef DEF_FUNCTION_TYPE_VAR_2
4471 #undef DEF_FUNCTION_TYPE_VAR_3
4472 #undef DEF_FUNCTION_TYPE_VAR_4
4473 #undef DEF_FUNCTION_TYPE_VAR_5
4474 #undef DEF_POINTER_TYPE
4475 builtin_types[(int) BT_LAST] = NULL_TREE;
4477 c_init_attributes ();
4479 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4480 NONANSI_P, ATTRS, IMPLICIT, COND) \
4482 def_builtin_1 (ENUM, NAME, CLASS, \
4483 builtin_types[(int) TYPE], \
4484 builtin_types[(int) LIBTYPE], \
4485 BOTH_P, FALLBACK_P, NONANSI_P, \
4486 built_in_attributes[(int) ATTRS], IMPLICIT);
4487 #include "builtins.def"
4490 targetm.init_builtins ();
4492 build_common_builtin_nodes ();
4498 /* Like get_identifier, but avoid warnings about null arguments when
4499 the argument may be NULL for targets where GCC lacks stdint.h type
4503 c_get_ident (const char *id)
4505 return get_identifier (id);
4508 /* Build tree nodes and builtin functions common to both C and C++ language
4512 c_common_nodes_and_builtins (void)
4514 int char16_type_size;
4515 int char32_type_size;
4516 int wchar_type_size;
4517 tree array_domain_type;
4518 tree va_list_ref_type_node;
4519 tree va_list_arg_type_node;
4521 /* Define `int' and `char' first so that dbx will output them first. */
4522 record_builtin_type (RID_INT, NULL, integer_type_node);
4523 record_builtin_type (RID_CHAR, "char", char_type_node);
4525 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4526 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4527 but not C. Are the conditionals here needed? */
4528 if (c_dialect_cxx ())
4529 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4530 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4531 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4532 record_builtin_type (RID_MAX, "long unsigned int",
4533 long_unsigned_type_node);
4534 if (int128_integer_type_node != NULL_TREE)
4536 record_builtin_type (RID_INT128, "__int128",
4537 int128_integer_type_node);
4538 record_builtin_type (RID_MAX, "__int128 unsigned",
4539 int128_unsigned_type_node);
4541 if (c_dialect_cxx ())
4542 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4543 record_builtin_type (RID_MAX, "long long int",
4544 long_long_integer_type_node);
4545 record_builtin_type (RID_MAX, "long long unsigned int",
4546 long_long_unsigned_type_node);
4547 if (c_dialect_cxx ())
4548 record_builtin_type (RID_MAX, "long long unsigned",
4549 long_long_unsigned_type_node);
4550 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4551 record_builtin_type (RID_MAX, "short unsigned int",
4552 short_unsigned_type_node);
4553 if (c_dialect_cxx ())
4554 record_builtin_type (RID_MAX, "unsigned short",
4555 short_unsigned_type_node);
4557 /* Define both `signed char' and `unsigned char'. */
4558 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4559 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4561 /* These are types that c_common_type_for_size and
4562 c_common_type_for_mode use. */
4563 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4564 TYPE_DECL, NULL_TREE,
4566 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4567 TYPE_DECL, NULL_TREE,
4569 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4570 TYPE_DECL, NULL_TREE,
4572 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4573 TYPE_DECL, NULL_TREE,
4575 #if HOST_BITS_PER_WIDE_INT >= 64
4576 if (targetm.scalar_mode_supported_p (TImode))
4577 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4579 get_identifier ("__int128_t"),
4582 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4583 TYPE_DECL, NULL_TREE,
4584 unsigned_intQI_type_node));
4585 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4586 TYPE_DECL, NULL_TREE,
4587 unsigned_intHI_type_node));
4588 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4589 TYPE_DECL, NULL_TREE,
4590 unsigned_intSI_type_node));
4591 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4592 TYPE_DECL, NULL_TREE,
4593 unsigned_intDI_type_node));
4594 #if HOST_BITS_PER_WIDE_INT >= 64
4595 if (targetm.scalar_mode_supported_p (TImode))
4596 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4598 get_identifier ("__uint128_t"),
4599 unsigned_intTI_type_node));
4602 /* Create the widest literal types. */
4603 widest_integer_literal_type_node
4604 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4605 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4606 TYPE_DECL, NULL_TREE,
4607 widest_integer_literal_type_node));
4609 widest_unsigned_literal_type_node
4610 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4611 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4612 TYPE_DECL, NULL_TREE,
4613 widest_unsigned_literal_type_node));
4615 /* `unsigned long' is the standard type for sizeof.
4616 Note that stddef.h uses `unsigned long',
4617 and this must agree, even if long and int are the same size. */
4619 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4620 signed_size_type_node = c_common_signed_type (size_type_node);
4621 set_sizetype (size_type_node);
4624 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4626 build_common_tree_nodes_2 (flag_short_double);
4628 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4629 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4630 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4632 /* Only supported decimal floating point extension if the target
4633 actually supports underlying modes. */
4634 if (targetm.scalar_mode_supported_p (SDmode)
4635 && targetm.scalar_mode_supported_p (DDmode)
4636 && targetm.scalar_mode_supported_p (TDmode))
4638 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4639 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4640 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4643 if (targetm.fixed_point_supported_p ())
4645 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4646 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4647 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4648 record_builtin_type (RID_MAX, "long long _Fract",
4649 long_long_fract_type_node);
4650 record_builtin_type (RID_MAX, "unsigned short _Fract",
4651 unsigned_short_fract_type_node);
4652 record_builtin_type (RID_MAX, "unsigned _Fract",
4653 unsigned_fract_type_node);
4654 record_builtin_type (RID_MAX, "unsigned long _Fract",
4655 unsigned_long_fract_type_node);
4656 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4657 unsigned_long_long_fract_type_node);
4658 record_builtin_type (RID_MAX, "_Sat short _Fract",
4659 sat_short_fract_type_node);
4660 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4661 record_builtin_type (RID_MAX, "_Sat long _Fract",
4662 sat_long_fract_type_node);
4663 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4664 sat_long_long_fract_type_node);
4665 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4666 sat_unsigned_short_fract_type_node);
4667 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4668 sat_unsigned_fract_type_node);
4669 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4670 sat_unsigned_long_fract_type_node);
4671 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4672 sat_unsigned_long_long_fract_type_node);
4673 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4674 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4675 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4676 record_builtin_type (RID_MAX, "long long _Accum",
4677 long_long_accum_type_node);
4678 record_builtin_type (RID_MAX, "unsigned short _Accum",
4679 unsigned_short_accum_type_node);
4680 record_builtin_type (RID_MAX, "unsigned _Accum",
4681 unsigned_accum_type_node);
4682 record_builtin_type (RID_MAX, "unsigned long _Accum",
4683 unsigned_long_accum_type_node);
4684 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4685 unsigned_long_long_accum_type_node);
4686 record_builtin_type (RID_MAX, "_Sat short _Accum",
4687 sat_short_accum_type_node);
4688 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4689 record_builtin_type (RID_MAX, "_Sat long _Accum",
4690 sat_long_accum_type_node);
4691 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4692 sat_long_long_accum_type_node);
4693 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4694 sat_unsigned_short_accum_type_node);
4695 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4696 sat_unsigned_accum_type_node);
4697 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4698 sat_unsigned_long_accum_type_node);
4699 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4700 sat_unsigned_long_long_accum_type_node);
4704 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4706 get_identifier ("complex int"),
4707 complex_integer_type_node));
4708 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4710 get_identifier ("complex float"),
4711 complex_float_type_node));
4712 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4714 get_identifier ("complex double"),
4715 complex_double_type_node));
4716 lang_hooks.decls.pushdecl
4717 (build_decl (UNKNOWN_LOCATION,
4718 TYPE_DECL, get_identifier ("complex long double"),
4719 complex_long_double_type_node));
4721 if (c_dialect_cxx ())
4722 /* For C++, make fileptr_type_node a distinct void * type until
4723 FILE type is defined. */
4724 fileptr_type_node = build_variant_type_copy (ptr_type_node);
4726 record_builtin_type (RID_VOID, NULL, void_type_node);
4728 /* Set the TYPE_NAME for any variants that were built before
4729 record_builtin_type gave names to the built-in types. */
4731 tree void_name = TYPE_NAME (void_type_node);
4732 TYPE_NAME (void_type_node) = NULL_TREE;
4733 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4735 TYPE_NAME (void_type_node) = void_name;
4738 /* This node must not be shared. */
4739 void_zero_node = make_node (INTEGER_CST);
4740 TREE_TYPE (void_zero_node) = void_type_node;
4742 void_list_node = build_void_list_node ();
4744 /* Make a type to be the domain of a few array types
4745 whose domains don't really matter.
4746 200 is small enough that it always fits in size_t
4747 and large enough that it can hold most function names for the
4748 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4749 array_domain_type = build_index_type (size_int (200));
4751 /* Make a type for arrays of characters.
4752 With luck nothing will ever really depend on the length of this
4754 char_array_type_node
4755 = build_array_type (char_type_node, array_domain_type);
4757 /* Likewise for arrays of ints. */
4759 = build_array_type (integer_type_node, array_domain_type);
4761 string_type_node = build_pointer_type (char_type_node);
4762 const_string_type_node
4763 = build_pointer_type (build_qualified_type
4764 (char_type_node, TYPE_QUAL_CONST));
4766 /* This is special for C++ so functions can be overloaded. */
4767 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4768 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4769 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4770 underlying_wchar_type_node = wchar_type_node;
4771 if (c_dialect_cxx ())
4773 if (TYPE_UNSIGNED (wchar_type_node))
4774 wchar_type_node = make_unsigned_type (wchar_type_size);
4776 wchar_type_node = make_signed_type (wchar_type_size);
4777 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4780 /* This is for wide string constants. */
4781 wchar_array_type_node
4782 = build_array_type (wchar_type_node, array_domain_type);
4784 /* Define 'char16_t'. */
4785 char16_type_node = get_identifier (CHAR16_TYPE);
4786 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4787 char16_type_size = TYPE_PRECISION (char16_type_node);
4788 if (c_dialect_cxx ())
4790 char16_type_node = make_unsigned_type (char16_type_size);
4792 if (cxx_dialect == cxx0x)
4793 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4796 /* This is for UTF-16 string constants. */
4797 char16_array_type_node
4798 = build_array_type (char16_type_node, array_domain_type);
4800 /* Define 'char32_t'. */
4801 char32_type_node = get_identifier (CHAR32_TYPE);
4802 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4803 char32_type_size = TYPE_PRECISION (char32_type_node);
4804 if (c_dialect_cxx ())
4806 char32_type_node = make_unsigned_type (char32_type_size);
4808 if (cxx_dialect == cxx0x)
4809 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4812 /* This is for UTF-32 string constants. */
4813 char32_array_type_node
4814 = build_array_type (char32_type_node, array_domain_type);
4817 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4820 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4822 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4824 if (SIG_ATOMIC_TYPE)
4825 sig_atomic_type_node =
4826 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
4829 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
4832 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
4835 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
4838 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
4841 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
4844 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
4846 c_uint32_type_node =
4847 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
4849 c_uint64_type_node =
4850 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
4851 if (INT_LEAST8_TYPE)
4852 int_least8_type_node =
4853 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
4854 if (INT_LEAST16_TYPE)
4855 int_least16_type_node =
4856 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
4857 if (INT_LEAST32_TYPE)
4858 int_least32_type_node =
4859 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
4860 if (INT_LEAST64_TYPE)
4861 int_least64_type_node =
4862 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
4863 if (UINT_LEAST8_TYPE)
4864 uint_least8_type_node =
4865 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
4866 if (UINT_LEAST16_TYPE)
4867 uint_least16_type_node =
4868 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
4869 if (UINT_LEAST32_TYPE)
4870 uint_least32_type_node =
4871 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
4872 if (UINT_LEAST64_TYPE)
4873 uint_least64_type_node =
4874 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
4876 int_fast8_type_node =
4877 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
4878 if (INT_FAST16_TYPE)
4879 int_fast16_type_node =
4880 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
4881 if (INT_FAST32_TYPE)
4882 int_fast32_type_node =
4883 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
4884 if (INT_FAST64_TYPE)
4885 int_fast64_type_node =
4886 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
4887 if (UINT_FAST8_TYPE)
4888 uint_fast8_type_node =
4889 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
4890 if (UINT_FAST16_TYPE)
4891 uint_fast16_type_node =
4892 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
4893 if (UINT_FAST32_TYPE)
4894 uint_fast32_type_node =
4895 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
4896 if (UINT_FAST64_TYPE)
4897 uint_fast64_type_node =
4898 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
4901 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
4904 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
4906 default_function_type = build_function_type (integer_type_node, NULL_TREE);
4908 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
4909 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
4911 lang_hooks.decls.pushdecl
4912 (build_decl (UNKNOWN_LOCATION,
4913 TYPE_DECL, get_identifier ("__builtin_va_list"),
4914 va_list_type_node));
4915 if (targetm.enum_va_list_p)
4921 for (l = 0; targetm.enum_va_list_p (l, &pname, &ptype); ++l)
4923 lang_hooks.decls.pushdecl
4924 (build_decl (UNKNOWN_LOCATION,
4925 TYPE_DECL, get_identifier (pname),
4931 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4933 va_list_arg_type_node = va_list_ref_type_node =
4934 build_pointer_type (TREE_TYPE (va_list_type_node));
4938 va_list_arg_type_node = va_list_type_node;
4939 va_list_ref_type_node = build_reference_type (va_list_type_node);
4942 if (!flag_preprocess_only)
4943 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4945 main_identifier_node = get_identifier ("main");
4947 /* Create the built-in __null node. It is important that this is
4949 null_node = make_node (INTEGER_CST);
4950 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
4952 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4953 memset (builtin_types, 0, sizeof (builtin_types));
4956 /* The number of named compound-literals generated thus far. */
4957 static GTY(()) int compound_literal_number;
4959 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4962 set_compound_literal_name (tree decl)
4965 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4966 compound_literal_number);
4967 compound_literal_number++;
4968 DECL_NAME (decl) = get_identifier (name);
4972 build_va_arg (location_t loc, tree expr, tree type)
4974 expr = build1 (VA_ARG_EXPR, type, expr);
4975 SET_EXPR_LOCATION (expr, loc);
4980 /* Linked list of disabled built-in functions. */
4982 typedef struct disabled_builtin
4985 struct disabled_builtin *next;
4987 static disabled_builtin *disabled_builtins = NULL;
4989 static bool builtin_function_disabled_p (const char *);
4991 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4992 begins with "__builtin_", give an error. */
4995 disable_builtin_function (const char *name)
4997 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4998 error ("cannot disable built-in function %qs", name);
5001 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
5002 new_disabled_builtin->name = name;
5003 new_disabled_builtin->next = disabled_builtins;
5004 disabled_builtins = new_disabled_builtin;
5009 /* Return true if the built-in function NAME has been disabled, false
5013 builtin_function_disabled_p (const char *name)
5015 disabled_builtin *p;
5016 for (p = disabled_builtins; p != NULL; p = p->next)
5018 if (strcmp (name, p->name) == 0)
5025 /* Worker for DEF_BUILTIN.
5026 Possibly define a builtin function with one or two names.
5027 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5028 nonansi_p and flag_no_nonansi_builtin. */
5031 def_builtin_1 (enum built_in_function fncode,
5033 enum built_in_class fnclass,
5034 tree fntype, tree libtype,
5035 bool both_p, bool fallback_p, bool nonansi_p,
5036 tree fnattrs, bool implicit_p)
5039 const char *libname;
5041 if (fntype == error_mark_node)
5044 gcc_assert ((!both_p && !fallback_p)
5045 || !strncmp (name, "__builtin_",
5046 strlen ("__builtin_")));
5048 libname = name + strlen ("__builtin_");
5049 decl = add_builtin_function (name, fntype, fncode, fnclass,
5050 (fallback_p ? libname : NULL),
5053 && !flag_no_builtin && !builtin_function_disabled_p (libname)
5054 && !(nonansi_p && flag_no_nonansi_builtin))
5055 add_builtin_function (libname, libtype, fncode, fnclass,
5058 built_in_decls[(int) fncode] = decl;
5060 implicit_built_in_decls[(int) fncode] = decl;
5063 /* Nonzero if the type T promotes to int. This is (nearly) the
5064 integral promotions defined in ISO C99 6.3.1.1/2. */
5067 c_promoting_integer_type_p (const_tree t)
5069 switch (TREE_CODE (t))
5072 return (TYPE_MAIN_VARIANT (t) == char_type_node
5073 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5074 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5075 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
5076 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5077 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
5080 /* ??? Technically all enumerations not larger than an int
5081 promote to an int. But this is used along code paths
5082 that only want to notice a size change. */
5083 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5093 /* Return 1 if PARMS specifies a fixed number of parameters
5094 and none of their types is affected by default promotions. */
5097 self_promoting_args_p (const_tree parms)
5100 for (t = parms; t; t = TREE_CHAIN (t))
5102 tree type = TREE_VALUE (t);
5104 if (type == error_mark_node)
5107 if (TREE_CHAIN (t) == 0 && type != void_type_node)
5113 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5116 if (c_promoting_integer_type_p (type))
5122 /* Recursively remove any '*' or '&' operator from TYPE. */
5124 strip_pointer_operator (tree t)
5126 while (POINTER_TYPE_P (t))
5131 /* Recursively remove pointer or array type from TYPE. */
5133 strip_pointer_or_array_types (tree t)
5135 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5140 /* Used to compare case labels. K1 and K2 are actually tree nodes
5141 representing case labels, or NULL_TREE for a `default' label.
5142 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5143 K2, and 0 if K1 and K2 are equal. */
5146 case_compare (splay_tree_key k1, splay_tree_key k2)
5148 /* Consider a NULL key (such as arises with a `default' label) to be
5149 smaller than anything else. */
5155 return tree_int_cst_compare ((tree) k1, (tree) k2);
5158 /* Process a case label, located at LOC, for the range LOW_VALUE
5159 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5160 then this case label is actually a `default' label. If only
5161 HIGH_VALUE is NULL_TREE, then case label was declared using the
5162 usual C/C++ syntax, rather than the GNU case range extension.
5163 CASES is a tree containing all the case ranges processed so far;
5164 COND is the condition for the switch-statement itself. Returns the
5165 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5169 c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type,
5170 tree low_value, tree high_value)
5175 splay_tree_node node;
5177 /* Create the LABEL_DECL itself. */
5178 label = create_artificial_label (loc);
5180 /* If there was an error processing the switch condition, bail now
5181 before we get more confused. */
5182 if (!cond || cond == error_mark_node)
5185 if ((low_value && TREE_TYPE (low_value)
5186 && POINTER_TYPE_P (TREE_TYPE (low_value)))
5187 || (high_value && TREE_TYPE (high_value)
5188 && POINTER_TYPE_P (TREE_TYPE (high_value))))
5190 error_at (loc, "pointers are not permitted as case values");
5194 /* Case ranges are a GNU extension. */
5196 pedwarn (loc, OPT_pedantic,
5197 "range expressions in switch statements are non-standard");
5199 type = TREE_TYPE (cond);
5202 low_value = check_case_value (low_value);
5203 low_value = convert_and_check (type, low_value);
5204 if (low_value == error_mark_node)
5209 high_value = check_case_value (high_value);
5210 high_value = convert_and_check (type, high_value);
5211 if (high_value == error_mark_node)
5215 if (low_value && high_value)
5217 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5218 really a case range, even though it was written that way.
5219 Remove the HIGH_VALUE to simplify later processing. */
5220 if (tree_int_cst_equal (low_value, high_value))
5221 high_value = NULL_TREE;
5222 else if (!tree_int_cst_lt (low_value, high_value))
5223 warning_at (loc, 0, "empty range specified");
5226 /* See if the case is in range of the type of the original testing
5227 expression. If both low_value and high_value are out of range,
5228 don't insert the case label and return NULL_TREE. */
5230 && !check_case_bounds (type, orig_type,
5231 &low_value, high_value ? &high_value : NULL))
5234 /* Look up the LOW_VALUE in the table of case labels we already
5236 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5237 /* If there was not an exact match, check for overlapping ranges.
5238 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5239 that's a `default' label and the only overlap is an exact match. */
5240 if (!node && (low_value || high_value))
5242 splay_tree_node low_bound;
5243 splay_tree_node high_bound;
5245 /* Even though there wasn't an exact match, there might be an
5246 overlap between this case range and another case range.
5247 Since we've (inductively) not allowed any overlapping case
5248 ranges, we simply need to find the greatest low case label
5249 that is smaller that LOW_VALUE, and the smallest low case
5250 label that is greater than LOW_VALUE. If there is an overlap
5251 it will occur in one of these two ranges. */
5252 low_bound = splay_tree_predecessor (cases,
5253 (splay_tree_key) low_value);
5254 high_bound = splay_tree_successor (cases,
5255 (splay_tree_key) low_value);
5257 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5258 the LOW_VALUE, so there is no need to check unless the
5259 LOW_BOUND is in fact itself a case range. */
5261 && CASE_HIGH ((tree) low_bound->value)
5262 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5265 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5266 range is bigger than the low end of the current range, so we
5267 are only interested if the current range is a real range, and
5268 not an ordinary case label. */
5271 && (tree_int_cst_compare ((tree) high_bound->key,
5276 /* If there was an overlap, issue an error. */
5279 tree duplicate = CASE_LABEL ((tree) node->value);
5283 error_at (loc, "duplicate (or overlapping) case value");
5284 error_at (DECL_SOURCE_LOCATION (duplicate),
5285 "this is the first entry overlapping that value");
5289 error_at (loc, "duplicate case value") ;
5290 error_at (DECL_SOURCE_LOCATION (duplicate), "previously used here");
5294 error_at (loc, "multiple default labels in one switch");
5295 error_at (DECL_SOURCE_LOCATION (duplicate),
5296 "this is the first default label");
5301 /* Add a CASE_LABEL to the statement-tree. */
5302 case_label = add_stmt (build_case_label (loc, low_value, high_value, label));
5303 /* Register this case label in the splay tree. */
5304 splay_tree_insert (cases,
5305 (splay_tree_key) low_value,
5306 (splay_tree_value) case_label);
5311 /* Add a label so that the back-end doesn't think that the beginning of
5312 the switch is unreachable. Note that we do not add a case label, as
5313 that just leads to duplicates and thence to failure later on. */
5316 tree t = create_artificial_label (loc);
5317 add_stmt (build_stmt (loc, LABEL_EXPR, t));
5319 return error_mark_node;
5322 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5323 Used to verify that case values match up with enumerator values. */
5326 match_case_to_enum_1 (tree key, tree type, tree label)
5328 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5330 /* ??? Not working too hard to print the double-word value.
5331 Should perhaps be done with %lwd in the diagnostic routines? */
5332 if (TREE_INT_CST_HIGH (key) == 0)
5333 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5334 TREE_INT_CST_LOW (key));
5335 else if (!TYPE_UNSIGNED (type)
5336 && TREE_INT_CST_HIGH (key) == -1
5337 && TREE_INT_CST_LOW (key) != 0)
5338 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5339 -TREE_INT_CST_LOW (key));
5341 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5342 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5343 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
5345 if (TYPE_NAME (type) == 0)
5346 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5347 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5348 "case value %qs not in enumerated type",
5351 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5352 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5353 "case value %qs not in enumerated type %qT",
5357 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5358 Used to verify that case values match up with enumerator values. */
5361 match_case_to_enum (splay_tree_node node, void *data)
5363 tree label = (tree) node->value;
5364 tree type = (tree) data;
5366 /* Skip default case. */
5367 if (!CASE_LOW (label))
5370 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5371 when we did our enum->case scan. Reset our scratch bit after. */
5372 if (!CASE_LOW_SEEN (label))
5373 match_case_to_enum_1 (CASE_LOW (label), type, label);
5375 CASE_LOW_SEEN (label) = 0;
5377 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5378 not set, that means that CASE_HIGH did not appear when we did our
5379 enum->case scan. Reset our scratch bit after. */
5380 if (CASE_HIGH (label))
5382 if (!CASE_HIGH_SEEN (label))
5383 match_case_to_enum_1 (CASE_HIGH (label), type, label);
5385 CASE_HIGH_SEEN (label) = 0;
5391 /* Handle -Wswitch*. Called from the front end after parsing the
5392 switch construct. */
5393 /* ??? Should probably be somewhere generic, since other languages
5394 besides C and C++ would want this. At the moment, however, C/C++
5395 are the only tree-ssa languages that support enumerations at all,
5396 so the point is moot. */
5399 c_do_switch_warnings (splay_tree cases, location_t switch_location,
5400 tree type, tree cond)
5402 splay_tree_node default_node;
5403 splay_tree_node node;
5406 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5409 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
5411 warning_at (switch_location, OPT_Wswitch_default,
5412 "switch missing default case");
5414 /* From here on, we only care about about enumerated types. */
5415 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5418 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
5419 if (!warn_switch_enum && !warn_switch)
5422 /* Check the cases. Warn about case values which are not members of
5423 the enumerated type. For -Wswitch-enum, or for -Wswitch when
5424 there is no default case, check that exactly all enumeration
5425 literals are covered by the cases. */
5427 /* Clearing COND if it is not an integer constant simplifies
5428 the tests inside the loop below. */
5429 if (TREE_CODE (cond) != INTEGER_CST)
5432 /* The time complexity here is O(N*lg(N)) worst case, but for the
5433 common case of monotonically increasing enumerators, it is
5434 O(N), since the nature of the splay tree will keep the next
5435 element adjacent to the root at all times. */
5437 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5439 tree value = TREE_VALUE (chain);
5440 if (TREE_CODE (value) == CONST_DECL)
5441 value = DECL_INITIAL (value);
5442 node = splay_tree_lookup (cases, (splay_tree_key) value);
5445 /* Mark the CASE_LOW part of the case entry as seen. */
5446 tree label = (tree) node->value;
5447 CASE_LOW_SEEN (label) = 1;
5451 /* Even though there wasn't an exact match, there might be a
5452 case range which includes the enumerator's value. */
5453 node = splay_tree_predecessor (cases, (splay_tree_key) value);
5454 if (node && CASE_HIGH ((tree) node->value))
5456 tree label = (tree) node->value;
5457 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5460 /* If we match the upper bound exactly, mark the CASE_HIGH
5461 part of the case entry as seen. */
5463 CASE_HIGH_SEEN (label) = 1;
5468 /* We've now determined that this enumerated literal isn't
5469 handled by the case labels of the switch statement. */
5471 /* If the switch expression is a constant, we only really care
5472 about whether that constant is handled by the switch. */
5473 if (cond && tree_int_cst_compare (cond, value))
5476 /* If there is a default_node, the only relevant option is
5477 Wswitch-enum. Otherwise, if both are enabled then we prefer
5478 to warn using -Wswitch because -Wswitch is enabled by -Wall
5479 while -Wswitch-enum is explicit. */
5480 warning_at (switch_location,
5481 (default_node || !warn_switch
5484 "enumeration value %qE not handled in switch",
5485 TREE_PURPOSE (chain));
5488 /* Warn if there are case expressions that don't correspond to
5489 enumerators. This can occur since C and C++ don't enforce
5490 type-checking of assignments to enumeration variables.
5492 The time complexity here is now always O(N) worst case, since
5493 we should have marked both the lower bound and upper bound of
5494 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5495 above. This scan also resets those fields. */
5497 splay_tree_foreach (cases, match_case_to_enum, type);
5500 /* Finish an expression taking the address of LABEL (an
5501 IDENTIFIER_NODE). Returns an expression for the address.
5503 LOC is the location for the expression returned. */
5506 finish_label_address_expr (tree label, location_t loc)
5510 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5512 if (label == error_mark_node)
5513 return error_mark_node;
5515 label = lookup_label (label);
5516 if (label == NULL_TREE)
5517 result = null_pointer_node;
5520 TREE_USED (label) = 1;
5521 result = build1 (ADDR_EXPR, ptr_type_node, label);
5522 /* The current function is not necessarily uninlinable.
5523 Computed gotos are incompatible with inlining, but the value
5524 here could be used only in a diagnostic, for example. */
5525 protected_set_expr_location (result, loc);
5532 /* Given a boolean expression ARG, return a tree representing an increment
5533 or decrement (as indicated by CODE) of ARG. The front end must check for
5534 invalid cases (e.g., decrement in C++). */
5536 boolean_increment (enum tree_code code, tree arg)
5539 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5541 arg = stabilize_reference (arg);
5544 case PREINCREMENT_EXPR:
5545 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5547 case POSTINCREMENT_EXPR:
5548 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5549 arg = save_expr (arg);
5550 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5551 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5553 case PREDECREMENT_EXPR:
5554 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5555 invert_truthvalue_loc (input_location, arg));
5557 case POSTDECREMENT_EXPR:
5558 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5559 invert_truthvalue_loc (input_location, arg));
5560 arg = save_expr (arg);
5561 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5562 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5567 TREE_SIDE_EFFECTS (val) = 1;
5571 /* Built-in macros for stddef.h and stdint.h, that require macros
5572 defined in this file. */
5574 c_stddef_cpp_builtins(void)
5576 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5577 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5578 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5579 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5580 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5581 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5582 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5583 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5584 if (SIG_ATOMIC_TYPE)
5585 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5587 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5589 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5591 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5593 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5595 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5597 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5599 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5601 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5602 if (INT_LEAST8_TYPE)
5603 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5604 if (INT_LEAST16_TYPE)
5605 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5606 if (INT_LEAST32_TYPE)
5607 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5608 if (INT_LEAST64_TYPE)
5609 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5610 if (UINT_LEAST8_TYPE)
5611 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5612 if (UINT_LEAST16_TYPE)
5613 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5614 if (UINT_LEAST32_TYPE)
5615 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5616 if (UINT_LEAST64_TYPE)
5617 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5619 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5620 if (INT_FAST16_TYPE)
5621 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5622 if (INT_FAST32_TYPE)
5623 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5624 if (INT_FAST64_TYPE)
5625 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5626 if (UINT_FAST8_TYPE)
5627 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5628 if (UINT_FAST16_TYPE)
5629 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5630 if (UINT_FAST32_TYPE)
5631 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5632 if (UINT_FAST64_TYPE)
5633 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5635 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5637 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
5641 c_init_attributes (void)
5643 /* Fill in the built_in_attributes array. */
5644 #define DEF_ATTR_NULL_TREE(ENUM) \
5645 built_in_attributes[(int) ENUM] = NULL_TREE;
5646 #define DEF_ATTR_INT(ENUM, VALUE) \
5647 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5648 #define DEF_ATTR_IDENT(ENUM, STRING) \
5649 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5650 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5651 built_in_attributes[(int) ENUM] \
5652 = tree_cons (built_in_attributes[(int) PURPOSE], \
5653 built_in_attributes[(int) VALUE], \
5654 built_in_attributes[(int) CHAIN]);
5655 #include "builtin-attrs.def"
5656 #undef DEF_ATTR_NULL_TREE
5658 #undef DEF_ATTR_IDENT
5659 #undef DEF_ATTR_TREE_LIST
5662 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
5663 identifier as an argument, so the front end shouldn't look it up. */
5666 attribute_takes_identifier_p (const_tree attr_id)
5668 struct attribute_spec *spec = lookup_attribute_spec (attr_id);
5670 /* Unknown attribute that we'll end up ignoring, return true so we
5671 don't complain about an identifier argument. */
5673 else if (!strcmp ("mode", spec->name)
5674 || !strcmp ("format", spec->name)
5675 || !strcmp ("cleanup", spec->name))
5678 return targetm.attribute_takes_identifier_p (attr_id);
5681 /* Attribute handlers common to C front ends. */
5683 /* Handle a "packed" attribute; arguments as in
5684 struct attribute_spec.handler. */
5687 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5688 int flags, bool *no_add_attrs)
5692 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5693 *node = build_variant_type_copy (*node);
5694 TYPE_PACKED (*node) = 1;
5696 else if (TREE_CODE (*node) == FIELD_DECL)
5698 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5699 /* Still pack bitfields. */
5700 && ! DECL_INITIAL (*node))
5701 warning (OPT_Wattributes,
5702 "%qE attribute ignored for field of type %qT",
5703 name, TREE_TYPE (*node));
5705 DECL_PACKED (*node) = 1;
5707 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5708 used for DECL_REGISTER. It wouldn't mean anything anyway.
5709 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5710 that changes what the typedef is typing. */
5713 warning (OPT_Wattributes, "%qE attribute ignored", name);
5714 *no_add_attrs = true;
5720 /* Handle a "nocommon" attribute; arguments as in
5721 struct attribute_spec.handler. */
5724 handle_nocommon_attribute (tree *node, tree name,
5725 tree ARG_UNUSED (args),
5726 int ARG_UNUSED (flags), bool *no_add_attrs)
5728 if (TREE_CODE (*node) == VAR_DECL)
5729 DECL_COMMON (*node) = 0;
5732 warning (OPT_Wattributes, "%qE attribute ignored", name);
5733 *no_add_attrs = true;
5739 /* Handle a "common" attribute; arguments as in
5740 struct attribute_spec.handler. */
5743 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5744 int ARG_UNUSED (flags), bool *no_add_attrs)
5746 if (TREE_CODE (*node) == VAR_DECL)
5747 DECL_COMMON (*node) = 1;
5750 warning (OPT_Wattributes, "%qE attribute ignored", name);
5751 *no_add_attrs = true;
5757 /* Handle a "noreturn" attribute; arguments as in
5758 struct attribute_spec.handler. */
5761 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5762 int ARG_UNUSED (flags), bool *no_add_attrs)
5764 tree type = TREE_TYPE (*node);
5766 /* See FIXME comment in c_common_attribute_table. */
5767 if (TREE_CODE (*node) == FUNCTION_DECL
5768 || objc_method_decl (TREE_CODE (*node)))
5769 TREE_THIS_VOLATILE (*node) = 1;
5770 else if (TREE_CODE (type) == POINTER_TYPE
5771 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5773 = build_pointer_type
5774 (build_type_variant (TREE_TYPE (type),
5775 TYPE_READONLY (TREE_TYPE (type)), 1));
5778 warning (OPT_Wattributes, "%qE attribute ignored", name);
5779 *no_add_attrs = true;
5785 /* Handle a "hot" and attribute; arguments as in
5786 struct attribute_spec.handler. */
5789 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5790 int ARG_UNUSED (flags), bool *no_add_attrs)
5792 if (TREE_CODE (*node) == FUNCTION_DECL)
5794 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5796 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5798 *no_add_attrs = true;
5800 /* Most of the rest of the hot processing is done later with
5801 lookup_attribute. */
5805 warning (OPT_Wattributes, "%qE attribute ignored", name);
5806 *no_add_attrs = true;
5811 /* Handle a "cold" and attribute; arguments as in
5812 struct attribute_spec.handler. */
5815 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5816 int ARG_UNUSED (flags), bool *no_add_attrs)
5818 if (TREE_CODE (*node) == FUNCTION_DECL)
5820 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5822 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5824 *no_add_attrs = true;
5826 /* Most of the rest of the cold processing is done later with
5827 lookup_attribute. */
5831 warning (OPT_Wattributes, "%qE attribute ignored", name);
5832 *no_add_attrs = true;
5838 /* Handle a "noinline" attribute; arguments as in
5839 struct attribute_spec.handler. */
5842 handle_noinline_attribute (tree *node, tree name,
5843 tree ARG_UNUSED (args),
5844 int ARG_UNUSED (flags), bool *no_add_attrs)
5846 if (TREE_CODE (*node) == FUNCTION_DECL)
5847 DECL_UNINLINABLE (*node) = 1;
5850 warning (OPT_Wattributes, "%qE attribute ignored", name);
5851 *no_add_attrs = true;
5857 /* Handle a "noclone" attribute; arguments as in
5858 struct attribute_spec.handler. */
5861 handle_noclone_attribute (tree *node, tree name,
5862 tree ARG_UNUSED (args),
5863 int ARG_UNUSED (flags), bool *no_add_attrs)
5865 if (TREE_CODE (*node) != FUNCTION_DECL)
5867 warning (OPT_Wattributes, "%qE attribute ignored", name);
5868 *no_add_attrs = true;
5874 /* Handle a "always_inline" attribute; arguments as in
5875 struct attribute_spec.handler. */
5878 handle_always_inline_attribute (tree *node, tree name,
5879 tree ARG_UNUSED (args),
5880 int ARG_UNUSED (flags),
5883 if (TREE_CODE (*node) == FUNCTION_DECL)
5885 /* Set the attribute and mark it for disregarding inline
5887 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
5891 warning (OPT_Wattributes, "%qE attribute ignored", name);
5892 *no_add_attrs = true;
5898 /* Handle a "gnu_inline" attribute; arguments as in
5899 struct attribute_spec.handler. */
5902 handle_gnu_inline_attribute (tree *node, tree name,
5903 tree ARG_UNUSED (args),
5904 int ARG_UNUSED (flags),
5907 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5909 /* Do nothing else, just set the attribute. We'll get at
5910 it later with lookup_attribute. */
5914 warning (OPT_Wattributes, "%qE attribute ignored", name);
5915 *no_add_attrs = true;
5921 /* Handle a "leaf" attribute; arguments as in
5922 struct attribute_spec.handler. */
5925 handle_leaf_attribute (tree *node, tree name,
5926 tree ARG_UNUSED (args),
5927 int ARG_UNUSED (flags), bool *no_add_attrs)
5929 if (TREE_CODE (*node) != FUNCTION_DECL)
5931 warning (OPT_Wattributes, "%qE attribute ignored", name);
5932 *no_add_attrs = true;
5934 if (!TREE_PUBLIC (*node))
5936 warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
5937 *no_add_attrs = true;
5943 /* Handle an "artificial" attribute; arguments as in
5944 struct attribute_spec.handler. */
5947 handle_artificial_attribute (tree *node, tree name,
5948 tree ARG_UNUSED (args),
5949 int ARG_UNUSED (flags),
5952 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5954 /* Do nothing else, just set the attribute. We'll get at
5955 it later with lookup_attribute. */
5959 warning (OPT_Wattributes, "%qE attribute ignored", name);
5960 *no_add_attrs = true;
5966 /* Handle a "flatten" attribute; arguments as in
5967 struct attribute_spec.handler. */
5970 handle_flatten_attribute (tree *node, tree name,
5971 tree args ATTRIBUTE_UNUSED,
5972 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5974 if (TREE_CODE (*node) == FUNCTION_DECL)
5975 /* Do nothing else, just set the attribute. We'll get at
5976 it later with lookup_attribute. */
5980 warning (OPT_Wattributes, "%qE attribute ignored", name);
5981 *no_add_attrs = true;
5987 /* Handle a "warning" or "error" attribute; arguments as in
5988 struct attribute_spec.handler. */
5991 handle_error_attribute (tree *node, tree name, tree args,
5992 int ARG_UNUSED (flags), bool *no_add_attrs)
5994 if (TREE_CODE (*node) == FUNCTION_DECL
5995 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5996 /* Do nothing else, just set the attribute. We'll get at
5997 it later with lookup_attribute. */
6001 warning (OPT_Wattributes, "%qE attribute ignored", name);
6002 *no_add_attrs = true;
6008 /* Handle a "used" attribute; arguments as in
6009 struct attribute_spec.handler. */
6012 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6013 int ARG_UNUSED (flags), bool *no_add_attrs)
6017 if (TREE_CODE (node) == FUNCTION_DECL
6018 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
6020 TREE_USED (node) = 1;
6021 DECL_PRESERVE_P (node) = 1;
6022 if (TREE_CODE (node) == VAR_DECL)
6023 DECL_READ_P (node) = 1;
6027 warning (OPT_Wattributes, "%qE attribute ignored", name);
6028 *no_add_attrs = true;
6034 /* Handle a "unused" attribute; arguments as in
6035 struct attribute_spec.handler. */
6038 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6039 int flags, bool *no_add_attrs)
6045 if (TREE_CODE (decl) == PARM_DECL
6046 || TREE_CODE (decl) == VAR_DECL
6047 || TREE_CODE (decl) == FUNCTION_DECL
6048 || TREE_CODE (decl) == LABEL_DECL
6049 || TREE_CODE (decl) == TYPE_DECL)
6051 TREE_USED (decl) = 1;
6052 if (TREE_CODE (decl) == VAR_DECL
6053 || TREE_CODE (decl) == PARM_DECL)
6054 DECL_READ_P (decl) = 1;
6058 warning (OPT_Wattributes, "%qE attribute ignored", name);
6059 *no_add_attrs = true;
6064 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6065 *node = build_variant_type_copy (*node);
6066 TREE_USED (*node) = 1;
6072 /* Handle a "externally_visible" attribute; arguments as in
6073 struct attribute_spec.handler. */
6076 handle_externally_visible_attribute (tree *pnode, tree name,
6077 tree ARG_UNUSED (args),
6078 int ARG_UNUSED (flags),
6083 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
6085 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6086 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6088 warning (OPT_Wattributes,
6089 "%qE attribute have effect only on public objects", name);
6090 *no_add_attrs = true;
6095 warning (OPT_Wattributes, "%qE attribute ignored", name);
6096 *no_add_attrs = true;
6102 /* Handle a "const" attribute; arguments as in
6103 struct attribute_spec.handler. */
6106 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6107 int ARG_UNUSED (flags), bool *no_add_attrs)
6109 tree type = TREE_TYPE (*node);
6111 /* See FIXME comment on noreturn in c_common_attribute_table. */
6112 if (TREE_CODE (*node) == FUNCTION_DECL)
6113 TREE_READONLY (*node) = 1;
6114 else if (TREE_CODE (type) == POINTER_TYPE
6115 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6117 = build_pointer_type
6118 (build_type_variant (TREE_TYPE (type), 1,
6119 TREE_THIS_VOLATILE (TREE_TYPE (type))));
6122 warning (OPT_Wattributes, "%qE attribute ignored", name);
6123 *no_add_attrs = true;
6129 /* Handle a "transparent_union" attribute; arguments as in
6130 struct attribute_spec.handler. */
6133 handle_transparent_union_attribute (tree *node, tree name,
6134 tree ARG_UNUSED (args), int flags,
6139 *no_add_attrs = true;
6141 if (TREE_CODE (*node) == TYPE_DECL)
6142 node = &TREE_TYPE (*node);
6145 if (TREE_CODE (type) == UNION_TYPE)
6147 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6148 the code in finish_struct. */
6149 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6151 if (TYPE_FIELDS (type) == NULL_TREE
6152 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6155 /* A type variant isn't good enough, since we don't a cast
6156 to such a type removed as a no-op. */
6157 *node = type = build_duplicate_type (type);
6160 TYPE_TRANSPARENT_AGGR (type) = 1;
6165 warning (OPT_Wattributes, "%qE attribute ignored", name);
6169 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6170 get the requested priority for a constructor or destructor,
6171 possibly issuing diagnostics for invalid or reserved
6174 static priority_type
6175 get_priority (tree args, bool is_destructor)
6181 return DEFAULT_INIT_PRIORITY;
6183 if (!SUPPORTS_INIT_PRIORITY)
6186 error ("destructor priorities are not supported");
6188 error ("constructor priorities are not supported");
6189 return DEFAULT_INIT_PRIORITY;
6192 arg = TREE_VALUE (args);
6193 if (!host_integerp (arg, /*pos=*/0)
6194 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
6197 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6198 if (pri < 0 || pri > MAX_INIT_PRIORITY)
6201 if (pri <= MAX_RESERVED_INIT_PRIORITY)
6205 "destructor priorities from 0 to %d are reserved "
6206 "for the implementation",
6207 MAX_RESERVED_INIT_PRIORITY);
6210 "constructor priorities from 0 to %d are reserved "
6211 "for the implementation",
6212 MAX_RESERVED_INIT_PRIORITY);
6218 error ("destructor priorities must be integers from 0 to %d inclusive",
6221 error ("constructor priorities must be integers from 0 to %d inclusive",
6223 return DEFAULT_INIT_PRIORITY;
6226 /* Handle a "constructor" attribute; arguments as in
6227 struct attribute_spec.handler. */
6230 handle_constructor_attribute (tree *node, tree name, tree args,
6231 int ARG_UNUSED (flags),
6235 tree type = TREE_TYPE (decl);
6237 if (TREE_CODE (decl) == FUNCTION_DECL
6238 && TREE_CODE (type) == FUNCTION_TYPE
6239 && decl_function_context (decl) == 0)
6241 priority_type priority;
6242 DECL_STATIC_CONSTRUCTOR (decl) = 1;
6243 priority = get_priority (args, /*is_destructor=*/false);
6244 SET_DECL_INIT_PRIORITY (decl, priority);
6245 TREE_USED (decl) = 1;
6249 warning (OPT_Wattributes, "%qE attribute ignored", name);
6250 *no_add_attrs = true;
6256 /* Handle a "destructor" attribute; arguments as in
6257 struct attribute_spec.handler. */
6260 handle_destructor_attribute (tree *node, tree name, tree args,
6261 int ARG_UNUSED (flags),
6265 tree type = TREE_TYPE (decl);
6267 if (TREE_CODE (decl) == FUNCTION_DECL
6268 && TREE_CODE (type) == FUNCTION_TYPE
6269 && decl_function_context (decl) == 0)
6271 priority_type priority;
6272 DECL_STATIC_DESTRUCTOR (decl) = 1;
6273 priority = get_priority (args, /*is_destructor=*/true);
6274 SET_DECL_FINI_PRIORITY (decl, priority);
6275 TREE_USED (decl) = 1;
6279 warning (OPT_Wattributes, "%qE attribute ignored", name);
6280 *no_add_attrs = true;
6286 /* Nonzero if the mode is a valid vector mode for this architecture.
6287 This returns nonzero even if there is no hardware support for the
6288 vector mode, but we can emulate with narrower modes. */
6291 vector_mode_valid_p (enum machine_mode mode)
6293 enum mode_class mclass = GET_MODE_CLASS (mode);
6294 enum machine_mode innermode;
6296 /* Doh! What's going on? */
6297 if (mclass != MODE_VECTOR_INT
6298 && mclass != MODE_VECTOR_FLOAT
6299 && mclass != MODE_VECTOR_FRACT
6300 && mclass != MODE_VECTOR_UFRACT
6301 && mclass != MODE_VECTOR_ACCUM
6302 && mclass != MODE_VECTOR_UACCUM)
6305 /* Hardware support. Woo hoo! */
6306 if (targetm.vector_mode_supported_p (mode))
6309 innermode = GET_MODE_INNER (mode);
6311 /* We should probably return 1 if requesting V4DI and we have no DI,
6312 but we have V2DI, but this is probably very unlikely. */
6314 /* If we have support for the inner mode, we can safely emulate it.
6315 We may not have V2DI, but me can emulate with a pair of DIs. */
6316 return targetm.scalar_mode_supported_p (innermode);
6320 /* Handle a "mode" attribute; arguments as in
6321 struct attribute_spec.handler. */
6324 handle_mode_attribute (tree *node, tree name, tree args,
6325 int ARG_UNUSED (flags), bool *no_add_attrs)
6328 tree ident = TREE_VALUE (args);
6330 *no_add_attrs = true;
6332 if (TREE_CODE (ident) != IDENTIFIER_NODE)
6333 warning (OPT_Wattributes, "%qE attribute ignored", name);
6337 const char *p = IDENTIFIER_POINTER (ident);
6338 int len = strlen (p);
6339 enum machine_mode mode = VOIDmode;
6343 if (len > 4 && p[0] == '_' && p[1] == '_'
6344 && p[len - 1] == '_' && p[len - 2] == '_')
6346 char *newp = (char *) alloca (len - 1);
6348 strcpy (newp, &p[2]);
6349 newp[len - 4] = '\0';
6353 /* Change this type to have a type with the specified mode.
6354 First check for the special modes. */
6355 if (!strcmp (p, "byte"))
6357 else if (!strcmp (p, "word"))
6359 else if (!strcmp (p, "pointer"))
6361 else if (!strcmp (p, "libgcc_cmp_return"))
6362 mode = targetm.libgcc_cmp_return_mode ();
6363 else if (!strcmp (p, "libgcc_shift_count"))
6364 mode = targetm.libgcc_shift_count_mode ();
6365 else if (!strcmp (p, "unwind_word"))
6366 mode = targetm.unwind_word_mode ();
6368 for (j = 0; j < NUM_MACHINE_MODES; j++)
6369 if (!strcmp (p, GET_MODE_NAME (j)))
6371 mode = (enum machine_mode) j;
6375 if (mode == VOIDmode)
6377 error ("unknown machine mode %qE", ident);
6382 switch (GET_MODE_CLASS (mode))
6385 case MODE_PARTIAL_INT:
6387 case MODE_DECIMAL_FLOAT:
6392 valid_mode = targetm.scalar_mode_supported_p (mode);
6395 case MODE_COMPLEX_INT:
6396 case MODE_COMPLEX_FLOAT:
6397 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6400 case MODE_VECTOR_INT:
6401 case MODE_VECTOR_FLOAT:
6402 case MODE_VECTOR_FRACT:
6403 case MODE_VECTOR_UFRACT:
6404 case MODE_VECTOR_ACCUM:
6405 case MODE_VECTOR_UACCUM:
6406 warning (OPT_Wattributes, "specifying vector types with "
6407 "__attribute__ ((mode)) is deprecated");
6408 warning (OPT_Wattributes,
6409 "use __attribute__ ((vector_size)) instead");
6410 valid_mode = vector_mode_valid_p (mode);
6418 error ("unable to emulate %qs", p);
6422 if (POINTER_TYPE_P (type))
6424 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
6425 tree (*fn)(tree, enum machine_mode, bool);
6427 if (!targetm.addr_space.valid_pointer_mode (mode, as))
6429 error ("invalid pointer mode %qs", p);
6433 if (TREE_CODE (type) == POINTER_TYPE)
6434 fn = build_pointer_type_for_mode;
6436 fn = build_reference_type_for_mode;
6437 typefm = fn (TREE_TYPE (type), mode, false);
6441 /* For fixed-point modes, we need to test if the signness of type
6442 and the machine mode are consistent. */
6443 if (ALL_FIXED_POINT_MODE_P (mode)
6444 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6446 error ("signedness of type and machine mode %qs don%'t match", p);
6449 /* For fixed-point modes, we need to pass saturating info. */
6450 typefm = lang_hooks.types.type_for_mode (mode,
6451 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6452 : TYPE_UNSIGNED (type));
6455 if (typefm == NULL_TREE)
6457 error ("no data type for mode %qs", p);
6460 else if (TREE_CODE (type) == ENUMERAL_TYPE)
6462 /* For enumeral types, copy the precision from the integer
6463 type returned above. If not an INTEGER_TYPE, we can't use
6464 this mode for this type. */
6465 if (TREE_CODE (typefm) != INTEGER_TYPE)
6467 error ("cannot use mode %qs for enumeral types", p);
6471 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6473 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6478 /* We cannot build a type variant, as there's code that assumes
6479 that TYPE_MAIN_VARIANT has the same mode. This includes the
6480 debug generators. Instead, create a subrange type. This
6481 results in all of the enumeral values being emitted only once
6482 in the original, and the subtype gets them by reference. */
6483 if (TYPE_UNSIGNED (type))
6484 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6486 typefm = make_signed_type (TYPE_PRECISION (typefm));
6487 TREE_TYPE (typefm) = type;
6490 else if (VECTOR_MODE_P (mode)
6491 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6492 : TREE_CODE (type) != TREE_CODE (typefm))
6494 error ("mode %qs applied to inappropriate type", p);
6504 /* Handle a "section" attribute; arguments as in
6505 struct attribute_spec.handler. */
6508 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6509 int ARG_UNUSED (flags), bool *no_add_attrs)
6513 if (targetm.have_named_sections)
6515 user_defined_section_attribute = true;
6517 if ((TREE_CODE (decl) == FUNCTION_DECL
6518 || TREE_CODE (decl) == VAR_DECL)
6519 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6521 if (TREE_CODE (decl) == VAR_DECL
6522 && current_function_decl != NULL_TREE
6523 && !TREE_STATIC (decl))
6525 error_at (DECL_SOURCE_LOCATION (decl),
6526 "section attribute cannot be specified for "
6528 *no_add_attrs = true;
6531 /* The decl may have already been given a section attribute
6532 from a previous declaration. Ensure they match. */
6533 else if (DECL_SECTION_NAME (decl) != NULL_TREE
6534 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6535 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6537 error ("section of %q+D conflicts with previous declaration",
6539 *no_add_attrs = true;
6541 else if (TREE_CODE (decl) == VAR_DECL
6542 && !targetm.have_tls && targetm.emutls.tmpl_section
6543 && DECL_THREAD_LOCAL_P (decl))
6545 error ("section of %q+D cannot be overridden", *node);
6546 *no_add_attrs = true;
6549 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6553 error ("section attribute not allowed for %q+D", *node);
6554 *no_add_attrs = true;
6559 error_at (DECL_SOURCE_LOCATION (*node),
6560 "section attributes are not supported for this target");
6561 *no_add_attrs = true;
6567 /* Handle a "aligned" attribute; arguments as in
6568 struct attribute_spec.handler. */
6571 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6572 int flags, bool *no_add_attrs)
6574 tree decl = NULL_TREE;
6577 tree align_expr = (args ? TREE_VALUE (args)
6578 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
6584 type = &TREE_TYPE (decl);
6585 is_type = TREE_CODE (*node) == TYPE_DECL;
6587 else if (TYPE_P (*node))
6588 type = node, is_type = 1;
6590 if (TREE_CODE (align_expr) != INTEGER_CST)
6592 error ("requested alignment is not a constant");
6593 *no_add_attrs = true;
6595 else if ((i = tree_log2 (align_expr)) == -1)
6597 error ("requested alignment is not a power of 2");
6598 *no_add_attrs = true;
6600 else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
6602 error ("requested alignment is too large");
6603 *no_add_attrs = true;
6607 if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6608 /* OK, modify the type in place. */;
6609 /* If we have a TYPE_DECL, then copy the type, so that we
6610 don't accidentally modify a builtin type. See pushdecl. */
6611 else if (decl && TREE_TYPE (decl) != error_mark_node
6612 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6614 tree tt = TREE_TYPE (decl);
6615 *type = build_variant_type_copy (*type);
6616 DECL_ORIGINAL_TYPE (decl) = tt;
6617 TYPE_NAME (*type) = decl;
6618 TREE_USED (*type) = TREE_USED (decl);
6619 TREE_TYPE (decl) = *type;
6622 *type = build_variant_type_copy (*type);
6624 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
6625 TYPE_USER_ALIGN (*type) = 1;
6627 else if (! VAR_OR_FUNCTION_DECL_P (decl)
6628 && TREE_CODE (decl) != FIELD_DECL)
6630 error ("alignment may not be specified for %q+D", decl);
6631 *no_add_attrs = true;
6633 else if (TREE_CODE (decl) == FUNCTION_DECL
6634 && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
6636 if (DECL_USER_ALIGN (decl))
6637 error ("alignment for %q+D was previously specified as %d "
6638 "and may not be decreased", decl,
6639 DECL_ALIGN (decl) / BITS_PER_UNIT);
6641 error ("alignment for %q+D must be at least %d", decl,
6642 DECL_ALIGN (decl) / BITS_PER_UNIT);
6643 *no_add_attrs = true;
6647 DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
6648 DECL_USER_ALIGN (decl) = 1;
6654 /* Handle a "weak" attribute; arguments as in
6655 struct attribute_spec.handler. */
6658 handle_weak_attribute (tree *node, tree name,
6659 tree ARG_UNUSED (args),
6660 int ARG_UNUSED (flags),
6661 bool * ARG_UNUSED (no_add_attrs))
6663 if (TREE_CODE (*node) == FUNCTION_DECL
6664 && DECL_DECLARED_INLINE_P (*node))
6666 warning (OPT_Wattributes, "inline function %q+D declared weak", *node);
6667 *no_add_attrs = true;
6669 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6671 error ("indirect function %q+D cannot be declared weak", *node);
6672 *no_add_attrs = true;
6675 else if (TREE_CODE (*node) == FUNCTION_DECL
6676 || TREE_CODE (*node) == VAR_DECL)
6677 declare_weak (*node);
6679 warning (OPT_Wattributes, "%qE attribute ignored", name);
6684 /* Handle an "alias" or "ifunc" attribute; arguments as in
6685 struct attribute_spec.handler, except that IS_ALIAS tells us
6686 whether this is an alias as opposed to ifunc attribute. */
6689 handle_alias_ifunc_attribute (bool is_alias, tree *node, tree name, tree args,
6694 if (TREE_CODE (decl) != FUNCTION_DECL
6695 && (!is_alias || TREE_CODE (decl) != VAR_DECL))
6697 warning (OPT_Wattributes, "%qE attribute ignored", name);
6698 *no_add_attrs = true;
6700 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6701 || (TREE_CODE (decl) != FUNCTION_DECL
6702 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6703 /* A static variable declaration is always a tentative definition,
6704 but the alias is a non-tentative definition which overrides. */
6705 || (TREE_CODE (decl) != FUNCTION_DECL
6706 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6708 error ("%q+D defined both normally and as %qE attribute", decl, name);
6709 *no_add_attrs = true;
6713 && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
6714 || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))))
6716 error ("weak %q+D cannot be defined %qE", decl, name);
6717 *no_add_attrs = true;
6721 /* Note that the very first time we process a nested declaration,
6722 decl_function_context will not be set. Indeed, *would* never
6723 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6724 we do below. After such frobbery, pushdecl would set the context.
6725 In any case, this is never what we want. */
6726 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6730 id = TREE_VALUE (args);
6731 if (TREE_CODE (id) != STRING_CST)
6733 error ("attribute %qE argument not a string", name);
6734 *no_add_attrs = true;
6737 id = get_identifier (TREE_STRING_POINTER (id));
6738 /* This counts as a use of the object pointed to. */
6741 if (TREE_CODE (decl) == FUNCTION_DECL)
6742 DECL_INITIAL (decl) = error_mark_node;
6745 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6746 DECL_EXTERNAL (decl) = 1;
6748 DECL_EXTERNAL (decl) = 0;
6749 TREE_STATIC (decl) = 1;
6753 /* ifuncs are also aliases, so set that attribute too. */
6754 DECL_ATTRIBUTES (decl)
6755 = tree_cons (get_identifier ("alias"), args, DECL_ATTRIBUTES (decl));
6759 warning (OPT_Wattributes, "%qE attribute ignored", name);
6760 *no_add_attrs = true;
6766 /* Handle an "alias" or "ifunc" attribute; arguments as in
6767 struct attribute_spec.handler. */
6770 handle_ifunc_attribute (tree *node, tree name, tree args,
6771 int ARG_UNUSED (flags), bool *no_add_attrs)
6773 return handle_alias_ifunc_attribute (false, node, name, args, no_add_attrs);
6776 /* Handle an "alias" or "ifunc" attribute; arguments as in
6777 struct attribute_spec.handler. */
6780 handle_alias_attribute (tree *node, tree name, tree args,
6781 int ARG_UNUSED (flags), bool *no_add_attrs)
6783 return handle_alias_ifunc_attribute (true, node, name, args, no_add_attrs);
6786 /* Handle a "weakref" attribute; arguments as in struct
6787 attribute_spec.handler. */
6790 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6791 int flags, bool *no_add_attrs)
6793 tree attr = NULL_TREE;
6795 /* We must ignore the attribute when it is associated with
6796 local-scoped decls, since attribute alias is ignored and many
6797 such symbols do not even have a DECL_WEAK field. */
6798 if (decl_function_context (*node)
6799 || current_function_decl
6800 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6802 warning (OPT_Wattributes, "%qE attribute ignored", name);
6803 *no_add_attrs = true;
6807 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6809 error ("indirect function %q+D cannot be declared weakref", *node);
6810 *no_add_attrs = true;
6814 /* The idea here is that `weakref("name")' mutates into `weakref,
6815 alias("name")', and weakref without arguments, in turn,
6816 implicitly adds weak. */
6820 attr = tree_cons (get_identifier ("alias"), args, attr);
6821 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6823 *no_add_attrs = true;
6825 decl_attributes (node, attr, flags);
6829 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6830 error_at (DECL_SOURCE_LOCATION (*node),
6831 "weakref attribute must appear before alias attribute");
6833 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6834 and that isn't supported; and because it wants to add it to
6835 the list of weak decls, which isn't helpful. */
6836 DECL_WEAK (*node) = 1;
6842 /* Handle an "visibility" attribute; arguments as in
6843 struct attribute_spec.handler. */
6846 handle_visibility_attribute (tree *node, tree name, tree args,
6847 int ARG_UNUSED (flags),
6848 bool *ARG_UNUSED (no_add_attrs))
6851 tree id = TREE_VALUE (args);
6852 enum symbol_visibility vis;
6856 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6858 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6860 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6864 else if (TYPE_FIELDS (*node))
6866 error ("%qE attribute ignored because %qT is already defined",
6871 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6873 warning (OPT_Wattributes, "%qE attribute ignored", name);
6877 if (TREE_CODE (id) != STRING_CST)
6879 error ("visibility argument not a string");
6883 /* If this is a type, set the visibility on the type decl. */
6886 decl = TYPE_NAME (decl);
6889 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6891 warning (OPT_Wattributes, "%qE attribute ignored on types",
6897 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6898 vis = VISIBILITY_DEFAULT;
6899 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6900 vis = VISIBILITY_INTERNAL;
6901 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6902 vis = VISIBILITY_HIDDEN;
6903 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6904 vis = VISIBILITY_PROTECTED;
6907 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6908 vis = VISIBILITY_DEFAULT;
6911 if (DECL_VISIBILITY_SPECIFIED (decl)
6912 && vis != DECL_VISIBILITY (decl))
6914 tree attributes = (TYPE_P (*node)
6915 ? TYPE_ATTRIBUTES (*node)
6916 : DECL_ATTRIBUTES (decl));
6917 if (lookup_attribute ("visibility", attributes))
6918 error ("%qD redeclared with different visibility", decl);
6919 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6920 && lookup_attribute ("dllimport", attributes))
6921 error ("%qD was declared %qs which implies default visibility",
6923 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6924 && lookup_attribute ("dllexport", attributes))
6925 error ("%qD was declared %qs which implies default visibility",
6929 DECL_VISIBILITY (decl) = vis;
6930 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6932 /* Go ahead and attach the attribute to the node as well. This is needed
6933 so we can determine whether we have VISIBILITY_DEFAULT because the
6934 visibility was not specified, or because it was explicitly overridden
6935 from the containing scope. */
6940 /* Determine the ELF symbol visibility for DECL, which is either a
6941 variable or a function. It is an error to use this function if a
6942 definition of DECL is not available in this translation unit.
6943 Returns true if the final visibility has been determined by this
6944 function; false if the caller is free to make additional
6948 c_determine_visibility (tree decl)
6950 gcc_assert (TREE_CODE (decl) == VAR_DECL
6951 || TREE_CODE (decl) == FUNCTION_DECL);
6953 /* If the user explicitly specified the visibility with an
6954 attribute, honor that. DECL_VISIBILITY will have been set during
6955 the processing of the attribute. We check for an explicit
6956 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6957 to distinguish the use of an attribute from the use of a "#pragma
6958 GCC visibility push(...)"; in the latter case we still want other
6959 considerations to be able to overrule the #pragma. */
6960 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6961 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6962 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6963 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6966 /* Set default visibility to whatever the user supplied with
6967 visibility_specified depending on #pragma GCC visibility. */
6968 if (!DECL_VISIBILITY_SPECIFIED (decl))
6970 if (visibility_options.inpragma
6971 || DECL_VISIBILITY (decl) != default_visibility)
6973 DECL_VISIBILITY (decl) = default_visibility;
6974 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6975 /* If visibility changed and DECL already has DECL_RTL, ensure
6976 symbol flags are updated. */
6977 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6978 || TREE_CODE (decl) == FUNCTION_DECL)
6979 && DECL_RTL_SET_P (decl))
6980 make_decl_rtl (decl);
6986 /* Handle an "tls_model" attribute; arguments as in
6987 struct attribute_spec.handler. */
6990 handle_tls_model_attribute (tree *node, tree name, tree args,
6991 int ARG_UNUSED (flags), bool *no_add_attrs)
6995 enum tls_model kind;
6997 *no_add_attrs = true;
6999 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
7001 warning (OPT_Wattributes, "%qE attribute ignored", name);
7005 kind = DECL_TLS_MODEL (decl);
7006 id = TREE_VALUE (args);
7007 if (TREE_CODE (id) != STRING_CST)
7009 error ("tls_model argument not a string");
7013 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7014 kind = TLS_MODEL_LOCAL_EXEC;
7015 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7016 kind = TLS_MODEL_INITIAL_EXEC;
7017 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7018 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7019 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7020 kind = TLS_MODEL_GLOBAL_DYNAMIC;
7022 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7024 DECL_TLS_MODEL (decl) = kind;
7028 /* Handle a "no_instrument_function" attribute; arguments as in
7029 struct attribute_spec.handler. */
7032 handle_no_instrument_function_attribute (tree *node, tree name,
7033 tree ARG_UNUSED (args),
7034 int ARG_UNUSED (flags),
7039 if (TREE_CODE (decl) != FUNCTION_DECL)
7041 error_at (DECL_SOURCE_LOCATION (decl),
7042 "%qE attribute applies only to functions", name);
7043 *no_add_attrs = true;
7045 else if (DECL_INITIAL (decl))
7047 error_at (DECL_SOURCE_LOCATION (decl),
7048 "can%'t set %qE attribute after definition", name);
7049 *no_add_attrs = true;
7052 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7057 /* Handle a "malloc" attribute; arguments as in
7058 struct attribute_spec.handler. */
7061 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7062 int ARG_UNUSED (flags), bool *no_add_attrs)
7064 if (TREE_CODE (*node) == FUNCTION_DECL
7065 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
7066 DECL_IS_MALLOC (*node) = 1;
7069 warning (OPT_Wattributes, "%qE attribute ignored", name);
7070 *no_add_attrs = true;
7076 /* Handle a "alloc_size" attribute; arguments as in
7077 struct attribute_spec.handler. */
7080 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7081 int ARG_UNUSED (flags), bool *no_add_attrs)
7083 unsigned arg_count = type_num_arguments (*node);
7084 for (; args; args = TREE_CHAIN (args))
7086 tree position = TREE_VALUE (args);
7088 if (TREE_CODE (position) != INTEGER_CST
7089 || TREE_INT_CST_HIGH (position)
7090 || TREE_INT_CST_LOW (position) < 1
7091 || TREE_INT_CST_LOW (position) > arg_count )
7093 warning (OPT_Wattributes,
7094 "alloc_size parameter outside range");
7095 *no_add_attrs = true;
7102 /* Handle a "fn spec" attribute; arguments as in
7103 struct attribute_spec.handler. */
7106 handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
7107 tree args, int ARG_UNUSED (flags),
7108 bool *no_add_attrs ATTRIBUTE_UNUSED)
7111 && TREE_CODE (TREE_VALUE (args)) == STRING_CST
7112 && !TREE_CHAIN (args));
7116 /* Handle a "returns_twice" attribute; arguments as in
7117 struct attribute_spec.handler. */
7120 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7121 int ARG_UNUSED (flags), bool *no_add_attrs)
7123 if (TREE_CODE (*node) == FUNCTION_DECL)
7124 DECL_IS_RETURNS_TWICE (*node) = 1;
7127 warning (OPT_Wattributes, "%qE attribute ignored", name);
7128 *no_add_attrs = true;
7134 /* Handle a "no_limit_stack" attribute; arguments as in
7135 struct attribute_spec.handler. */
7138 handle_no_limit_stack_attribute (tree *node, tree name,
7139 tree ARG_UNUSED (args),
7140 int ARG_UNUSED (flags),
7145 if (TREE_CODE (decl) != FUNCTION_DECL)
7147 error_at (DECL_SOURCE_LOCATION (decl),
7148 "%qE attribute applies only to functions", name);
7149 *no_add_attrs = true;
7151 else if (DECL_INITIAL (decl))
7153 error_at (DECL_SOURCE_LOCATION (decl),
7154 "can%'t set %qE attribute after definition", name);
7155 *no_add_attrs = true;
7158 DECL_NO_LIMIT_STACK (decl) = 1;
7163 /* Handle a "pure" attribute; arguments as in
7164 struct attribute_spec.handler. */
7167 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7168 int ARG_UNUSED (flags), bool *no_add_attrs)
7170 if (TREE_CODE (*node) == FUNCTION_DECL)
7171 DECL_PURE_P (*node) = 1;
7172 /* ??? TODO: Support types. */
7175 warning (OPT_Wattributes, "%qE attribute ignored", name);
7176 *no_add_attrs = true;
7182 /* Handle a "no vops" attribute; arguments as in
7183 struct attribute_spec.handler. */
7186 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7187 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7188 bool *ARG_UNUSED (no_add_attrs))
7190 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7191 DECL_IS_NOVOPS (*node) = 1;
7195 /* Handle a "deprecated" attribute; arguments as in
7196 struct attribute_spec.handler. */
7199 handle_deprecated_attribute (tree *node, tree name,
7200 tree args, int flags,
7203 tree type = NULL_TREE;
7205 tree what = NULL_TREE;
7208 *no_add_attrs = true;
7209 else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
7211 error ("deprecated message is not a string");
7212 *no_add_attrs = true;
7218 type = TREE_TYPE (decl);
7220 if (TREE_CODE (decl) == TYPE_DECL
7221 || TREE_CODE (decl) == PARM_DECL
7222 || TREE_CODE (decl) == VAR_DECL
7223 || TREE_CODE (decl) == FUNCTION_DECL
7224 || TREE_CODE (decl) == FIELD_DECL
7225 || objc_method_decl (TREE_CODE (decl)))
7226 TREE_DEPRECATED (decl) = 1;
7230 else if (TYPE_P (*node))
7232 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
7233 *node = build_variant_type_copy (*node);
7234 TREE_DEPRECATED (*node) = 1;
7242 *no_add_attrs = true;
7243 if (type && TYPE_NAME (type))
7245 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7246 what = TYPE_NAME (*node);
7247 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7248 && DECL_NAME (TYPE_NAME (type)))
7249 what = DECL_NAME (TYPE_NAME (type));
7252 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
7254 warning (OPT_Wattributes, "%qE attribute ignored", name);
7260 /* Handle a "vector_size" attribute; arguments as in
7261 struct attribute_spec.handler. */
7264 handle_vector_size_attribute (tree *node, tree name, tree args,
7265 int ARG_UNUSED (flags),
7268 unsigned HOST_WIDE_INT vecsize, nunits;
7269 enum machine_mode orig_mode;
7270 tree type = *node, new_type, size;
7272 *no_add_attrs = true;
7274 size = TREE_VALUE (args);
7276 if (!host_integerp (size, 1))
7278 warning (OPT_Wattributes, "%qE attribute ignored", name);
7282 /* Get the vector size (in bytes). */
7283 vecsize = tree_low_cst (size, 1);
7285 /* We need to provide for vector pointers, vector arrays, and
7286 functions returning vectors. For example:
7288 __attribute__((vector_size(16))) short *foo;
7290 In this case, the mode is SI, but the type being modified is
7291 HI, so we need to look further. */
7293 while (POINTER_TYPE_P (type)
7294 || TREE_CODE (type) == FUNCTION_TYPE
7295 || TREE_CODE (type) == METHOD_TYPE
7296 || TREE_CODE (type) == ARRAY_TYPE
7297 || TREE_CODE (type) == OFFSET_TYPE)
7298 type = TREE_TYPE (type);
7300 /* Get the mode of the type being modified. */
7301 orig_mode = TYPE_MODE (type);
7303 if ((!INTEGRAL_TYPE_P (type)
7304 && !SCALAR_FLOAT_TYPE_P (type)
7305 && !FIXED_POINT_TYPE_P (type))
7306 || (!SCALAR_FLOAT_MODE_P (orig_mode)
7307 && GET_MODE_CLASS (orig_mode) != MODE_INT
7308 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7309 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7310 || TREE_CODE (type) == BOOLEAN_TYPE)
7312 error ("invalid vector type for attribute %qE", name);
7316 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7318 error ("vector size not an integral multiple of component size");
7324 error ("zero vector size");
7328 /* Calculate how many units fit in the vector. */
7329 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7330 if (nunits & (nunits - 1))
7332 error ("number of components of the vector not a power of two");
7336 new_type = build_vector_type (type, nunits);
7338 /* Build back pointers if needed. */
7339 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
7344 /* Handle the "nonnull" attribute. */
7346 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7347 tree args, int ARG_UNUSED (flags),
7351 unsigned HOST_WIDE_INT attr_arg_num;
7353 /* If no arguments are specified, all pointer arguments should be
7354 non-null. Verify a full prototype is given so that the arguments
7355 will have the correct types when we actually check them later. */
7358 if (!prototype_p (type))
7360 error ("nonnull attribute without arguments on a non-prototype");
7361 *no_add_attrs = true;
7366 /* Argument list specified. Verify that each argument number references
7367 a pointer argument. */
7368 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7371 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
7373 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
7375 error ("nonnull argument has invalid operand number (argument %lu)",
7376 (unsigned long) attr_arg_num);
7377 *no_add_attrs = true;
7381 argument = TYPE_ARG_TYPES (type);
7384 for (ck_num = 1; ; ck_num++)
7386 if (!argument || ck_num == arg_num)
7388 argument = TREE_CHAIN (argument);
7392 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7394 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7395 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7396 *no_add_attrs = true;
7400 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
7402 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7403 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7404 *no_add_attrs = true;
7413 /* Check the argument list of a function call for null in argument slots
7414 that are marked as requiring a non-null pointer argument. The NARGS
7415 arguments are passed in the array ARGARRAY.
7419 check_function_nonnull (tree attrs, int nargs, tree *argarray)
7424 for (a = attrs; a; a = TREE_CHAIN (a))
7426 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7428 args = TREE_VALUE (a);
7430 /* Walk the argument list. If we encounter an argument number we
7431 should check for non-null, do it. If the attribute has no args,
7432 then every pointer argument is checked (in which case the check
7433 for pointer type is done in check_nonnull_arg). */
7434 for (i = 0; i < nargs; i++)
7436 if (!args || nonnull_check_p (args, i + 1))
7437 check_function_arguments_recurse (check_nonnull_arg, NULL,
7445 /* Check that the Nth argument of a function call (counting backwards
7446 from the end) is a (pointer)0. The NARGS arguments are passed in the
7450 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
7452 tree attr = lookup_attribute ("sentinel", attrs);
7460 /* Skip over the named arguments. */
7461 while (typelist && len < nargs)
7463 typelist = TREE_CHAIN (typelist);
7467 if (TREE_VALUE (attr))
7469 tree p = TREE_VALUE (TREE_VALUE (attr));
7470 pos = TREE_INT_CST_LOW (p);
7473 /* The sentinel must be one of the varargs, i.e.
7474 in position >= the number of fixed arguments. */
7475 if ((nargs - 1 - pos) < len)
7477 warning (OPT_Wformat,
7478 "not enough variable arguments to fit a sentinel");
7482 /* Validate the sentinel. */
7483 sentinel = argarray[nargs - 1 - pos];
7484 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7485 || !integer_zerop (sentinel))
7486 /* Although __null (in C++) is only an integer we allow it
7487 nevertheless, as we are guaranteed that it's exactly
7488 as wide as a pointer, and we don't want to force
7489 users to cast the NULL they have written there.
7490 We warn with -Wstrict-null-sentinel, though. */
7491 && (warn_strict_null_sentinel || null_node != sentinel))
7492 warning (OPT_Wformat, "missing sentinel in function call");
7496 /* Helper for check_function_nonnull; given a list of operands which
7497 must be non-null in ARGS, determine if operand PARAM_NUM should be
7501 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
7503 unsigned HOST_WIDE_INT arg_num = 0;
7505 for (; args; args = TREE_CHAIN (args))
7507 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7511 if (arg_num == param_num)
7517 /* Check that the function argument PARAM (which is operand number
7518 PARAM_NUM) is non-null. This is called by check_function_nonnull
7519 via check_function_arguments_recurse. */
7522 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
7523 unsigned HOST_WIDE_INT param_num)
7525 /* Just skip checking the argument if it's not a pointer. This can
7526 happen if the "nonnull" attribute was given without an operand
7527 list (which means to check every pointer argument). */
7529 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7532 if (integer_zerop (param))
7533 warning (OPT_Wnonnull, "null argument where non-null required "
7534 "(argument %lu)", (unsigned long) param_num);
7537 /* Helper for nonnull attribute handling; fetch the operand number
7538 from the attribute argument list. */
7541 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
7543 /* Verify the arg number is a constant. */
7544 if (TREE_CODE (arg_num_expr) != INTEGER_CST
7545 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7548 *valp = TREE_INT_CST_LOW (arg_num_expr);
7552 /* Handle a "nothrow" attribute; arguments as in
7553 struct attribute_spec.handler. */
7556 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7557 int ARG_UNUSED (flags), bool *no_add_attrs)
7559 if (TREE_CODE (*node) == FUNCTION_DECL)
7560 TREE_NOTHROW (*node) = 1;
7561 /* ??? TODO: Support types. */
7564 warning (OPT_Wattributes, "%qE attribute ignored", name);
7565 *no_add_attrs = true;
7571 /* Handle a "cleanup" attribute; arguments as in
7572 struct attribute_spec.handler. */
7575 handle_cleanup_attribute (tree *node, tree name, tree args,
7576 int ARG_UNUSED (flags), bool *no_add_attrs)
7579 tree cleanup_id, cleanup_decl;
7581 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7582 for global destructors in C++. This requires infrastructure that
7583 we don't have generically at the moment. It's also not a feature
7584 we'd be missing too much, since we do have attribute constructor. */
7585 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7587 warning (OPT_Wattributes, "%qE attribute ignored", name);
7588 *no_add_attrs = true;
7592 /* Verify that the argument is a function in scope. */
7593 /* ??? We could support pointers to functions here as well, if
7594 that was considered desirable. */
7595 cleanup_id = TREE_VALUE (args);
7596 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7598 error ("cleanup argument not an identifier");
7599 *no_add_attrs = true;
7602 cleanup_decl = lookup_name (cleanup_id);
7603 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7605 error ("cleanup argument not a function");
7606 *no_add_attrs = true;
7610 /* That the function has proper type is checked with the
7611 eventual call to build_function_call. */
7616 /* Handle a "warn_unused_result" attribute. No special handling. */
7619 handle_warn_unused_result_attribute (tree *node, tree name,
7620 tree ARG_UNUSED (args),
7621 int ARG_UNUSED (flags), bool *no_add_attrs)
7623 /* Ignore the attribute for functions not returning any value. */
7624 if (VOID_TYPE_P (TREE_TYPE (*node)))
7626 warning (OPT_Wattributes, "%qE attribute ignored", name);
7627 *no_add_attrs = true;
7633 /* Handle a "sentinel" attribute. */
7636 handle_sentinel_attribute (tree *node, tree name, tree args,
7637 int ARG_UNUSED (flags), bool *no_add_attrs)
7639 tree params = TYPE_ARG_TYPES (*node);
7641 if (!prototype_p (*node))
7643 warning (OPT_Wattributes,
7644 "%qE attribute requires prototypes with named arguments", name);
7645 *no_add_attrs = true;
7649 while (TREE_CHAIN (params))
7650 params = TREE_CHAIN (params);
7652 if (VOID_TYPE_P (TREE_VALUE (params)))
7654 warning (OPT_Wattributes,
7655 "%qE attribute only applies to variadic functions", name);
7656 *no_add_attrs = true;
7662 tree position = TREE_VALUE (args);
7664 if (TREE_CODE (position) != INTEGER_CST)
7666 warning (OPT_Wattributes,
7667 "requested position is not an integer constant");
7668 *no_add_attrs = true;
7672 if (tree_int_cst_lt (position, integer_zero_node))
7674 warning (OPT_Wattributes,
7675 "requested position is less than zero");
7676 *no_add_attrs = true;
7684 /* Handle a "type_generic" attribute. */
7687 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7688 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7689 bool * ARG_UNUSED (no_add_attrs))
7693 /* Ensure we have a function type. */
7694 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
7696 params = TYPE_ARG_TYPES (*node);
7697 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7698 params = TREE_CHAIN (params);
7700 /* Ensure we have a variadic function. */
7701 gcc_assert (!params);
7706 /* Handle a "target" attribute. */
7709 handle_target_attribute (tree *node, tree name, tree args, int flags,
7712 /* Ensure we have a function type. */
7713 if (TREE_CODE (*node) != FUNCTION_DECL)
7715 warning (OPT_Wattributes, "%qE attribute ignored", name);
7716 *no_add_attrs = true;
7718 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7720 *no_add_attrs = true;
7725 /* Arguments being collected for optimization. */
7726 typedef const char *const_char_p; /* For DEF_VEC_P. */
7727 DEF_VEC_P(const_char_p);
7728 DEF_VEC_ALLOC_P(const_char_p, gc);
7729 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7732 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7733 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7734 false for #pragma GCC optimize. */
7737 parse_optimize_options (tree args, bool attr_p)
7742 int saved_flag_strict_aliasing;
7743 const char **opt_argv;
7744 struct cl_decoded_option *decoded_options;
7745 unsigned int decoded_options_count;
7748 /* Build up argv vector. Just in case the string is stored away, use garbage
7749 collected strings. */
7750 VEC_truncate (const_char_p, optimize_args, 0);
7751 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7753 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7755 tree value = TREE_VALUE (ap);
7757 if (TREE_CODE (value) == INTEGER_CST)
7760 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7761 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7764 else if (TREE_CODE (value) == STRING_CST)
7766 /* Split string into multiple substrings. */
7767 size_t len = TREE_STRING_LENGTH (value);
7768 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7769 char *end = p + len;
7773 while (next_p != NULL)
7779 comma = strchr (p, ',');
7792 r = q = (char *) ggc_alloc_atomic (len2 + 3);
7794 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7796 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7800 warning (OPT_Wattributes,
7801 "bad option %s to optimize attribute", p);
7803 warning (OPT_Wpragmas,
7804 "bad option %s to pragma attribute", p);
7812 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7813 itself is -Os, and any other switch begins with a -f. */
7814 if ((*p >= '0' && *p <= '9')
7815 || (p[0] == 's' && p[1] == '\0'))
7821 memcpy (r, p, len2);
7823 VEC_safe_push (const_char_p, gc, optimize_args, q);
7829 opt_argc = VEC_length (const_char_p, optimize_args);
7830 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7832 for (i = 1; i < opt_argc; i++)
7833 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7835 saved_flag_strict_aliasing = flag_strict_aliasing;
7837 /* Now parse the options. */
7838 decode_cmdline_options_to_array_default_mask (opt_argc, opt_argv,
7840 &decoded_options_count);
7841 decode_options (&global_options, &global_options_set,
7842 decoded_options, decoded_options_count,
7843 input_location, global_dc);
7845 targetm.override_options_after_change();
7847 /* Don't allow changing -fstrict-aliasing. */
7848 flag_strict_aliasing = saved_flag_strict_aliasing;
7850 VEC_truncate (const_char_p, optimize_args, 0);
7854 /* For handling "optimize" attribute. arguments as in
7855 struct attribute_spec.handler. */
7858 handle_optimize_attribute (tree *node, tree name, tree args,
7859 int ARG_UNUSED (flags), bool *no_add_attrs)
7861 /* Ensure we have a function type. */
7862 if (TREE_CODE (*node) != FUNCTION_DECL)
7864 warning (OPT_Wattributes, "%qE attribute ignored", name);
7865 *no_add_attrs = true;
7869 struct cl_optimization cur_opts;
7870 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7872 /* Save current options. */
7873 cl_optimization_save (&cur_opts, &global_options);
7875 /* If we previously had some optimization options, use them as the
7878 cl_optimization_restore (&global_options,
7879 TREE_OPTIMIZATION (old_opts));
7881 /* Parse options, and update the vector. */
7882 parse_optimize_options (args, true);
7883 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7884 = build_optimization_node ();
7886 /* Restore current options. */
7887 cl_optimization_restore (&global_options, &cur_opts);
7893 /* Handle a "no_split_stack" attribute. */
7896 handle_no_split_stack_attribute (tree *node, tree name,
7897 tree ARG_UNUSED (args),
7898 int ARG_UNUSED (flags),
7903 if (TREE_CODE (decl) != FUNCTION_DECL)
7905 error_at (DECL_SOURCE_LOCATION (decl),
7906 "%qE attribute applies only to functions", name);
7907 *no_add_attrs = true;
7909 else if (DECL_INITIAL (decl))
7911 error_at (DECL_SOURCE_LOCATION (decl),
7912 "can%'t set %qE attribute after definition", name);
7913 *no_add_attrs = true;
7919 /* Check for valid arguments being passed to a function.
7920 ATTRS is a list of attributes. There are NARGS arguments in the array
7921 ARGARRAY. TYPELIST is the list of argument types for the function.
7924 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7926 /* Check for null being passed in a pointer argument that must be
7927 non-null. We also need to do this if format checking is enabled. */
7930 check_function_nonnull (attrs, nargs, argarray);
7932 /* Check for errors in format strings. */
7934 if (warn_format || warn_missing_format_attribute)
7935 check_function_format (attrs, nargs, argarray);
7938 check_function_sentinel (attrs, nargs, argarray, typelist);
7941 /* Generic argument checking recursion routine. PARAM is the argument to
7942 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7943 once the argument is resolved. CTX is context for the callback. */
7945 check_function_arguments_recurse (void (*callback)
7946 (void *, tree, unsigned HOST_WIDE_INT),
7947 void *ctx, tree param,
7948 unsigned HOST_WIDE_INT param_num)
7950 if (CONVERT_EXPR_P (param)
7951 && (TYPE_PRECISION (TREE_TYPE (param))
7952 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7954 /* Strip coercion. */
7955 check_function_arguments_recurse (callback, ctx,
7956 TREE_OPERAND (param, 0), param_num);
7960 if (TREE_CODE (param) == CALL_EXPR)
7962 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7964 bool found_format_arg = false;
7966 /* See if this is a call to a known internationalization function
7967 that modifies a format arg. Such a function may have multiple
7968 format_arg attributes (for example, ngettext). */
7970 for (attrs = TYPE_ATTRIBUTES (type);
7972 attrs = TREE_CHAIN (attrs))
7973 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7976 tree format_num_expr;
7979 call_expr_arg_iterator iter;
7981 /* Extract the argument number, which was previously checked
7983 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7985 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7986 && !TREE_INT_CST_HIGH (format_num_expr));
7988 format_num = TREE_INT_CST_LOW (format_num_expr);
7990 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7992 inner_arg = next_call_expr_arg (&iter), i++)
7993 if (i == format_num)
7995 check_function_arguments_recurse (callback, ctx,
7996 inner_arg, param_num);
7997 found_format_arg = true;
8002 /* If we found a format_arg attribute and did a recursive check,
8003 we are done with checking this argument. Otherwise, we continue
8004 and this will be considered a non-literal. */
8005 if (found_format_arg)
8009 if (TREE_CODE (param) == COND_EXPR)
8011 /* Check both halves of the conditional expression. */
8012 check_function_arguments_recurse (callback, ctx,
8013 TREE_OPERAND (param, 1), param_num);
8014 check_function_arguments_recurse (callback, ctx,
8015 TREE_OPERAND (param, 2), param_num);
8019 (*callback) (ctx, param, param_num);
8022 /* Checks for a builtin function FNDECL that the number of arguments
8023 NARGS against the required number REQUIRED and issues an error if
8024 there is a mismatch. Returns true if the number of arguments is
8025 correct, otherwise false. */
8028 builtin_function_validate_nargs (tree fndecl, int nargs, int required)
8030 if (nargs < required)
8032 error_at (input_location,
8033 "not enough arguments to function %qE", fndecl);
8036 else if (nargs > required)
8038 error_at (input_location,
8039 "too many arguments to function %qE", fndecl);
8045 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
8046 Returns false if there was an error, otherwise true. */
8049 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
8051 if (!DECL_BUILT_IN (fndecl)
8052 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
8055 switch (DECL_FUNCTION_CODE (fndecl))
8057 case BUILT_IN_CONSTANT_P:
8058 return builtin_function_validate_nargs (fndecl, nargs, 1);
8060 case BUILT_IN_ISFINITE:
8061 case BUILT_IN_ISINF:
8062 case BUILT_IN_ISINF_SIGN:
8063 case BUILT_IN_ISNAN:
8064 case BUILT_IN_ISNORMAL:
8065 if (builtin_function_validate_nargs (fndecl, nargs, 1))
8067 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8069 error ("non-floating-point argument in call to "
8070 "function %qE", fndecl);
8077 case BUILT_IN_ISGREATER:
8078 case BUILT_IN_ISGREATEREQUAL:
8079 case BUILT_IN_ISLESS:
8080 case BUILT_IN_ISLESSEQUAL:
8081 case BUILT_IN_ISLESSGREATER:
8082 case BUILT_IN_ISUNORDERED:
8083 if (builtin_function_validate_nargs (fndecl, nargs, 2))
8085 enum tree_code code0, code1;
8086 code0 = TREE_CODE (TREE_TYPE (args[0]));
8087 code1 = TREE_CODE (TREE_TYPE (args[1]));
8088 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8089 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8090 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8092 error ("non-floating-point arguments in call to "
8093 "function %qE", fndecl);
8100 case BUILT_IN_FPCLASSIFY:
8101 if (builtin_function_validate_nargs (fndecl, nargs, 6))
8106 if (TREE_CODE (args[i]) != INTEGER_CST)
8108 error ("non-const integer argument %u in call to function %qE",
8113 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8115 error ("non-floating-point argument in call to function %qE",
8128 /* Function to help qsort sort FIELD_DECLs by name order. */
8131 field_decl_cmp (const void *x_p, const void *y_p)
8133 const tree *const x = (const tree *const) x_p;
8134 const tree *const y = (const tree *const) y_p;
8136 if (DECL_NAME (*x) == DECL_NAME (*y))
8137 /* A nontype is "greater" than a type. */
8138 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8139 if (DECL_NAME (*x) == NULL_TREE)
8141 if (DECL_NAME (*y) == NULL_TREE)
8143 if (DECL_NAME (*x) < DECL_NAME (*y))
8149 gt_pointer_operator new_value;
8153 /* This routine compares two fields like field_decl_cmp but using the
8154 pointer operator in resort_data. */
8157 resort_field_decl_cmp (const void *x_p, const void *y_p)
8159 const tree *const x = (const tree *const) x_p;
8160 const tree *const y = (const tree *const) y_p;
8162 if (DECL_NAME (*x) == DECL_NAME (*y))
8163 /* A nontype is "greater" than a type. */
8164 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8165 if (DECL_NAME (*x) == NULL_TREE)
8167 if (DECL_NAME (*y) == NULL_TREE)
8170 tree d1 = DECL_NAME (*x);
8171 tree d2 = DECL_NAME (*y);
8172 resort_data.new_value (&d1, resort_data.cookie);
8173 resort_data.new_value (&d2, resort_data.cookie);
8180 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8183 resort_sorted_fields (void *obj,
8184 void * ARG_UNUSED (orig_obj),
8185 gt_pointer_operator new_value,
8188 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
8189 resort_data.new_value = new_value;
8190 resort_data.cookie = cookie;
8191 qsort (&sf->elts[0], sf->len, sizeof (tree),
8192 resort_field_decl_cmp);
8195 /* Subroutine of c_parse_error.
8196 Return the result of concatenating LHS and RHS. RHS is really
8197 a string literal, its first character is indicated by RHS_START and
8198 RHS_SIZE is its length (including the terminating NUL character).
8200 The caller is responsible for deleting the returned pointer. */
8203 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8205 const int lhs_size = strlen (lhs);
8206 char *result = XNEWVEC (char, lhs_size + rhs_size);
8207 strncpy (result, lhs, lhs_size);
8208 strncpy (result + lhs_size, rhs_start, rhs_size);
8212 /* Issue the error given by GMSGID, indicating that it occurred before
8213 TOKEN, which had the associated VALUE. */
8216 c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
8217 tree value, unsigned char token_flags)
8219 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8221 char *message = NULL;
8223 if (token_type == CPP_EOF)
8224 message = catenate_messages (gmsgid, " at end of input");
8225 else if (token_type == CPP_CHAR
8226 || token_type == CPP_WCHAR
8227 || token_type == CPP_CHAR16
8228 || token_type == CPP_CHAR32)
8230 unsigned int val = TREE_INT_CST_LOW (value);
8249 if (val <= UCHAR_MAX && ISGRAPH (val))
8250 message = catenate_messages (gmsgid, " before %s'%c'");
8252 message = catenate_messages (gmsgid, " before %s'\\x%x'");
8254 error (message, prefix, val);
8258 else if (token_type == CPP_STRING
8259 || token_type == CPP_WSTRING
8260 || token_type == CPP_STRING16
8261 || token_type == CPP_STRING32
8262 || token_type == CPP_UTF8STRING)
8263 message = catenate_messages (gmsgid, " before string constant");
8264 else if (token_type == CPP_NUMBER)
8265 message = catenate_messages (gmsgid, " before numeric constant");
8266 else if (token_type == CPP_NAME)
8268 message = catenate_messages (gmsgid, " before %qE");
8269 error (message, value);
8273 else if (token_type == CPP_PRAGMA)
8274 message = catenate_messages (gmsgid, " before %<#pragma%>");
8275 else if (token_type == CPP_PRAGMA_EOL)
8276 message = catenate_messages (gmsgid, " before end of line");
8277 else if (token_type < N_TTYPES)
8279 message = catenate_messages (gmsgid, " before %qs token");
8280 error (message, cpp_type2name (token_type, token_flags));
8292 #undef catenate_messages
8295 /* Mapping for cpp message reasons to the options that enable them. */
8297 struct reason_option_codes_t
8299 const int reason; /* cpplib message reason. */
8300 const int option_code; /* gcc option that controls this message. */
8303 static const struct reason_option_codes_t option_codes[] = {
8304 {CPP_W_DEPRECATED, OPT_Wdeprecated},
8305 {CPP_W_COMMENTS, OPT_Wcomment},
8306 {CPP_W_TRIGRAPHS, OPT_Wtrigraphs},
8307 {CPP_W_MULTICHAR, OPT_Wmultichar},
8308 {CPP_W_TRADITIONAL, OPT_Wtraditional},
8309 {CPP_W_LONG_LONG, OPT_Wlong_long},
8310 {CPP_W_ENDIF_LABELS, OPT_Wendif_labels},
8311 {CPP_W_VARIADIC_MACROS, OPT_Wvariadic_macros},
8312 {CPP_W_BUILTIN_MACRO_REDEFINED, OPT_Wbuiltin_macro_redefined},
8313 {CPP_W_UNDEF, OPT_Wundef},
8314 {CPP_W_UNUSED_MACROS, OPT_Wunused_macros},
8315 {CPP_W_CXX_OPERATOR_NAMES, OPT_Wc___compat},
8316 {CPP_W_NORMALIZE, OPT_Wnormalized_},
8317 {CPP_W_INVALID_PCH, OPT_Winvalid_pch},
8318 {CPP_W_WARNING_DIRECTIVE, OPT_Wcpp},
8322 /* Return the gcc option code associated with the reason for a cpp
8323 message, or 0 if none. */
8326 c_option_controlling_cpp_error (int reason)
8328 const struct reason_option_codes_t *entry;
8330 for (entry = option_codes; entry->reason != CPP_W_NONE; entry++)
8332 if (entry->reason == reason)
8333 return entry->option_code;
8338 /* Callback from cpp_error for PFILE to print diagnostics from the
8339 preprocessor. The diagnostic is of type LEVEL, with REASON set
8340 to the reason code if LEVEL is represents a warning, at location
8341 LOCATION unless this is after lexing and the compiler's location
8342 should be used instead, with column number possibly overridden by
8343 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8344 the arguments. Returns true if a diagnostic was emitted, false
8348 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
8349 location_t location, unsigned int column_override,
8350 const char *msg, va_list *ap)
8352 diagnostic_info diagnostic;
8353 diagnostic_t dlevel;
8354 bool save_warn_system_headers = global_dc->dc_warn_system_headers;
8359 case CPP_DL_WARNING_SYSHDR:
8362 global_dc->dc_warn_system_headers = 1;
8364 case CPP_DL_WARNING:
8367 dlevel = DK_WARNING;
8369 case CPP_DL_PEDWARN:
8370 if (flag_no_output && !flag_pedantic_errors)
8372 dlevel = DK_PEDWARN;
8390 location = input_location;
8391 diagnostic_set_info_translated (&diagnostic, msg, ap,
8393 if (column_override)
8394 diagnostic_override_column (&diagnostic, column_override);
8395 diagnostic_override_option_index (&diagnostic,
8396 c_option_controlling_cpp_error (reason));
8397 ret = report_diagnostic (&diagnostic);
8398 if (level == CPP_DL_WARNING_SYSHDR)
8399 global_dc->dc_warn_system_headers = save_warn_system_headers;
8403 /* Convert a character from the host to the target execution character
8404 set. cpplib handles this, mostly. */
8407 c_common_to_target_charset (HOST_WIDE_INT c)
8409 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8410 zero-extended under -fno-signed-char. cpplib insists that characters
8411 and character constants are always unsigned. Hence we must convert
8413 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8415 uc = cpp_host_to_exec_charset (parse_in, uc);
8417 if (flag_signed_char)
8418 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8419 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8424 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8425 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8426 NULL, at the bottom; much like the traditional rendering of offsetof as a
8427 macro. Returns the folded and properly cast result. */
8430 fold_offsetof_1 (tree expr, tree stop_ref)
8432 enum tree_code code = PLUS_EXPR;
8435 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8436 return size_zero_node;
8438 switch (TREE_CODE (expr))
8444 error ("cannot apply %<offsetof%> to static data member %qD", expr);
8445 return error_mark_node;
8449 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8450 return error_mark_node;
8454 if (!integer_zerop (TREE_OPERAND (expr, 0)))
8456 error ("cannot apply %<offsetof%> to a non constant address");
8457 return error_mark_node;
8459 return size_zero_node;
8462 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8463 if (base == error_mark_node)
8466 t = TREE_OPERAND (expr, 1);
8467 if (DECL_C_BIT_FIELD (t))
8469 error ("attempt to take address of bit-field structure "
8471 return error_mark_node;
8473 off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t),
8474 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t),
8480 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8481 if (base == error_mark_node)
8484 t = TREE_OPERAND (expr, 1);
8485 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8488 t = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (t), t);
8490 t = convert (sizetype, t);
8491 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8493 /* Check if the offset goes beyond the upper bound of the array. */
8494 if (code == PLUS_EXPR && TREE_CODE (t) == INTEGER_CST)
8496 tree upbound = array_ref_up_bound (expr);
8497 if (upbound != NULL_TREE
8498 && TREE_CODE (upbound) == INTEGER_CST
8499 && !tree_int_cst_equal (upbound,
8500 TYPE_MAX_VALUE (TREE_TYPE (upbound))))
8502 upbound = size_binop (PLUS_EXPR, upbound,
8503 build_int_cst (TREE_TYPE (upbound), 1));
8504 if (tree_int_cst_lt (upbound, t))
8508 for (v = TREE_OPERAND (expr, 0);
8509 TREE_CODE (v) == COMPONENT_REF;
8510 v = TREE_OPERAND (v, 0))
8511 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
8514 tree fld_chain = DECL_CHAIN (TREE_OPERAND (v, 1));
8515 for (; fld_chain; fld_chain = DECL_CHAIN (fld_chain))
8516 if (TREE_CODE (fld_chain) == FIELD_DECL)
8522 /* Don't warn if the array might be considered a poor
8523 man's flexible array member with a very permissive
8524 definition thereof. */
8525 if (TREE_CODE (v) == ARRAY_REF
8526 || TREE_CODE (v) == COMPONENT_REF)
8527 warning (OPT_Warray_bounds,
8528 "index %E denotes an offset "
8529 "greater than size of %qT",
8530 t, TREE_TYPE (TREE_OPERAND (expr, 0)));
8537 /* Handle static members of volatile structs. */
8538 t = TREE_OPERAND (expr, 1);
8539 gcc_assert (TREE_CODE (t) == VAR_DECL);
8540 return fold_offsetof_1 (t, stop_ref);
8546 return size_binop (code, base, off);
8550 fold_offsetof (tree expr, tree stop_ref)
8552 /* Convert back from the internal sizetype to size_t. */
8553 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
8556 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
8557 expression, because B will always be true. */
8560 warn_for_omitted_condop (location_t location, tree cond)
8562 if (truth_value_p (TREE_CODE (cond)))
8563 warning_at (location, OPT_Wparentheses,
8564 "the omitted middle operand in ?: will always be %<true%>, "
8565 "suggest explicit middle operand");
8568 /* Give an error for storing into ARG, which is 'const'. USE indicates
8569 how ARG was being used. */
8572 readonly_error (tree arg, enum lvalue_use use)
8574 gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement
8576 /* Using this macro rather than (for example) arrays of messages
8577 ensures that all the format strings are checked at compile
8579 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
8580 : (use == lv_increment ? (I) \
8581 : (use == lv_decrement ? (D) : (AS))))
8582 if (TREE_CODE (arg) == COMPONENT_REF)
8584 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
8585 error (READONLY_MSG (G_("assignment of member "
8586 "%qD in read-only object"),
8587 G_("increment of member "
8588 "%qD in read-only object"),
8589 G_("decrement of member "
8590 "%qD in read-only object"),
8591 G_("member %qD in read-only object "
8592 "used as %<asm%> output")),
8593 TREE_OPERAND (arg, 1));
8595 error (READONLY_MSG (G_("assignment of read-only member %qD"),
8596 G_("increment of read-only member %qD"),
8597 G_("decrement of read-only member %qD"),
8598 G_("read-only member %qD used as %<asm%> output")),
8599 TREE_OPERAND (arg, 1));
8601 else if (TREE_CODE (arg) == VAR_DECL)
8602 error (READONLY_MSG (G_("assignment of read-only variable %qD"),
8603 G_("increment of read-only variable %qD"),
8604 G_("decrement of read-only variable %qD"),
8605 G_("read-only variable %qD used as %<asm%> output")),
8607 else if (TREE_CODE (arg) == PARM_DECL)
8608 error (READONLY_MSG (G_("assignment of read-only parameter %qD"),
8609 G_("increment of read-only parameter %qD"),
8610 G_("decrement of read-only parameter %qD"),
8611 G_("read-only parameter %qD use as %<asm%> output")),
8613 else if (TREE_CODE (arg) == RESULT_DECL)
8615 gcc_assert (c_dialect_cxx ());
8616 error (READONLY_MSG (G_("assignment of "
8617 "read-only named return value %qD"),
8619 "read-only named return value %qD"),
8621 "read-only named return value %qD"),
8622 G_("read-only named return value %qD "
8623 "used as %<asm%>output")),
8626 else if (TREE_CODE (arg) == FUNCTION_DECL)
8627 error (READONLY_MSG (G_("assignment of function %qD"),
8628 G_("increment of function %qD"),
8629 G_("decrement of function %qD"),
8630 G_("function %qD used as %<asm%> output")),
8633 error (READONLY_MSG (G_("assignment of read-only location %qE"),
8634 G_("increment of read-only location %qE"),
8635 G_("decrement of read-only location %qE"),
8636 G_("read-only location %qE used as %<asm%> output")),
8640 /* Print an error message for an invalid lvalue. USE says
8641 how the lvalue is being used and so selects the error message. LOC
8642 is the location for the error. */
8645 lvalue_error (location_t loc, enum lvalue_use use)
8650 error_at (loc, "lvalue required as left operand of assignment");
8653 error_at (loc, "lvalue required as increment operand");
8656 error_at (loc, "lvalue required as decrement operand");
8659 error_at (loc, "lvalue required as unary %<&%> operand");
8662 error_at (loc, "lvalue required in asm statement");
8669 /* Print an error message for an invalid indirection of type TYPE.
8670 ERRSTRING is the name of the operator for the indirection. */
8673 invalid_indirection_error (location_t loc, tree type, ref_operator errstring)
8678 gcc_assert (c_dialect_cxx ());
8679 error_at (loc, "invalid type argument (have %qT)", type);
8681 case RO_ARRAY_INDEXING:
8683 "invalid type argument of array indexing (have %qT)",
8688 "invalid type argument of unary %<*%> (have %qT)",
8693 "invalid type argument of %<->%> (have %qT)",
8696 case RO_IMPLICIT_CONVERSION:
8698 "invalid type argument of implicit conversion (have %qT)",
8706 /* *PTYPE is an incomplete array. Complete it with a domain based on
8707 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8708 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8709 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8712 complete_array_type (tree *ptype, tree initial_value, bool do_default)
8714 tree maxindex, type, main_type, elt, unqual_elt;
8715 int failure = 0, quals;
8716 hashval_t hashcode = 0;
8718 maxindex = size_zero_node;
8721 if (TREE_CODE (initial_value) == STRING_CST)
8724 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8725 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8727 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8729 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
8731 if (VEC_empty (constructor_elt, v))
8735 maxindex = integer_minus_one_node;
8740 unsigned HOST_WIDE_INT cnt;
8741 constructor_elt *ce;
8742 bool fold_p = false;
8744 if (VEC_index (constructor_elt, v, 0)->index)
8745 maxindex = fold_convert_loc (input_location, sizetype,
8746 VEC_index (constructor_elt,
8748 curindex = maxindex;
8751 VEC_iterate (constructor_elt, v, cnt, ce);
8754 bool curfold_p = false;
8756 curindex = ce->index, curfold_p = true;
8760 curindex = fold_convert (sizetype, curindex);
8761 curindex = size_binop (PLUS_EXPR, curindex,
8764 if (tree_int_cst_lt (maxindex, curindex))
8765 maxindex = curindex, fold_p = curfold_p;
8768 maxindex = fold_convert (sizetype, maxindex);
8773 /* Make an error message unless that happened already. */
8774 if (initial_value != error_mark_node)
8786 elt = TREE_TYPE (type);
8787 quals = TYPE_QUALS (strip_array_types (elt));
8791 unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals));
8793 /* Using build_distinct_type_copy and modifying things afterward instead
8794 of using build_array_type to create a new type preserves all of the
8795 TYPE_LANG_FLAG_? bits that the front end may have set. */
8796 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8797 TREE_TYPE (main_type) = unqual_elt;
8798 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8799 layout_type (main_type);
8801 /* Make sure we have the canonical MAIN_TYPE. */
8802 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
8803 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
8805 main_type = type_hash_canon (hashcode, main_type);
8807 /* Fix the canonical type. */
8808 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8809 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8810 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8811 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8812 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8813 != TYPE_DOMAIN (main_type)))
8814 TYPE_CANONICAL (main_type)
8815 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8816 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8818 TYPE_CANONICAL (main_type) = main_type;
8823 type = c_build_qualified_type (main_type, quals);
8825 if (COMPLETE_TYPE_P (type)
8826 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8827 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8829 error ("size of array is too large");
8830 /* If we proceed with the array type as it is, we'll eventually
8831 crash in tree_low_cst(). */
8832 type = error_mark_node;
8839 /* Like c_mark_addressable but don't check register qualifier. */
8841 c_common_mark_addressable_vec (tree t)
8843 while (handled_component_p (t))
8844 t = TREE_OPERAND (t, 0);
8845 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
8847 TREE_ADDRESSABLE (t) = 1;
8852 /* Used to help initialize the builtin-types.def table. When a type of
8853 the correct size doesn't exist, use error_mark_node instead of NULL.
8854 The later results in segfaults even when a decl using the type doesn't
8858 builtin_type_for_size (int size, bool unsignedp)
8860 tree type = lang_hooks.types.type_for_size (size, unsignedp);
8861 return type ? type : error_mark_node;
8864 /* A helper function for resolve_overloaded_builtin in resolving the
8865 overloaded __sync_ builtins. Returns a positive power of 2 if the
8866 first operand of PARAMS is a pointer to a supported data type.
8867 Returns 0 if an error is encountered. */
8870 sync_resolve_size (tree function, VEC(tree,gc) *params)
8875 if (VEC_empty (tree, params))
8877 error ("too few arguments to function %qE", function);
8881 type = TREE_TYPE (VEC_index (tree, params, 0));
8882 if (TREE_CODE (type) != POINTER_TYPE)
8885 type = TREE_TYPE (type);
8886 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8889 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
8890 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
8894 error ("incompatible type for argument %d of %qE", 1, function);
8898 /* A helper function for resolve_overloaded_builtin. Adds casts to
8899 PARAMS to make arguments match up with those of FUNCTION. Drops
8900 the variadic arguments at the end. Returns false if some error
8901 was encountered; true on success. */
8904 sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
8906 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8908 unsigned int parmnum;
8910 /* We've declared the implementation functions to use "volatile void *"
8911 as the pointer parameter, so we shouldn't get any complaints from the
8912 call to check_function_arguments what ever type the user used. */
8913 arg_types = TREE_CHAIN (arg_types);
8914 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
8916 /* For the rest of the values, we need to cast these to FTYPE, so that we
8917 don't get warnings for passing pointer types, etc. */
8919 while (arg_types != void_list_node)
8924 if (VEC_length (tree, params) <= parmnum)
8926 error ("too few arguments to function %qE", orig_function);
8930 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8931 so that we get warnings for anything that doesn't match the pointer
8932 type. This isn't portable across the C and C++ front ends atm. */
8933 val = VEC_index (tree, params, parmnum);
8934 val = convert (ptype, val);
8935 val = convert (TREE_VALUE (arg_types), val);
8936 VEC_replace (tree, params, parmnum, val);
8938 arg_types = TREE_CHAIN (arg_types);
8941 /* The definition of these primitives is variadic, with the remaining
8942 being "an optional list of variables protected by the memory barrier".
8943 No clue what that's supposed to mean, precisely, but we consider all
8944 call-clobbered variables to be protected so we're safe. */
8945 VEC_truncate (tree, params, parmnum + 1);
8950 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8951 RESULT to make it match the type of the first pointer argument in
8955 sync_resolve_return (tree first_param, tree result)
8957 tree ptype = TREE_TYPE (TREE_TYPE (first_param));
8958 ptype = TYPE_MAIN_VARIANT (ptype);
8959 return convert (ptype, result);
8962 /* Some builtin functions are placeholders for other expressions. This
8963 function should be called immediately after parsing the call expression
8964 before surrounding code has committed to the type of the expression.
8966 LOC is the location of the builtin call.
8968 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8969 PARAMS is the argument list for the call. The return value is non-null
8970 when expansion is complete, and null if normal processing should
8974 resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
8976 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8977 switch (DECL_BUILT_IN_CLASS (function))
8979 case BUILT_IN_NORMAL:
8982 if (targetm.resolve_overloaded_builtin)
8983 return targetm.resolve_overloaded_builtin (loc, function, params);
8990 /* Handle BUILT_IN_NORMAL here. */
8993 case BUILT_IN_FETCH_AND_ADD_N:
8994 case BUILT_IN_FETCH_AND_SUB_N:
8995 case BUILT_IN_FETCH_AND_OR_N:
8996 case BUILT_IN_FETCH_AND_AND_N:
8997 case BUILT_IN_FETCH_AND_XOR_N:
8998 case BUILT_IN_FETCH_AND_NAND_N:
8999 case BUILT_IN_ADD_AND_FETCH_N:
9000 case BUILT_IN_SUB_AND_FETCH_N:
9001 case BUILT_IN_OR_AND_FETCH_N:
9002 case BUILT_IN_AND_AND_FETCH_N:
9003 case BUILT_IN_XOR_AND_FETCH_N:
9004 case BUILT_IN_NAND_AND_FETCH_N:
9005 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
9006 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
9007 case BUILT_IN_LOCK_TEST_AND_SET_N:
9008 case BUILT_IN_LOCK_RELEASE_N:
9010 int n = sync_resolve_size (function, params);
9011 tree new_function, first_param, result;
9014 return error_mark_node;
9016 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
9017 if (!sync_resolve_params (function, new_function, params))
9018 return error_mark_node;
9020 first_param = VEC_index (tree, params, 0);
9021 result = build_function_call_vec (loc, new_function, params, NULL);
9022 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
9023 && orig_code != BUILT_IN_LOCK_RELEASE_N)
9024 result = sync_resolve_return (first_param, result);
9034 /* Ignoring their sign, return true if two scalar types are the same. */
9036 same_scalar_type_ignoring_signedness (tree t1, tree t2)
9038 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
9040 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
9041 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
9042 || c2 == FIXED_POINT_TYPE));
9044 /* Equality works here because c_common_signed_type uses
9045 TYPE_MAIN_VARIANT. */
9046 return c_common_signed_type (t1)
9047 == c_common_signed_type (t2);
9050 /* Check for missing format attributes on function pointers. LTYPE is
9051 the new type or left-hand side type. RTYPE is the old type or
9052 right-hand side type. Returns TRUE if LTYPE is missing the desired
9056 check_missing_format_attribute (tree ltype, tree rtype)
9058 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
9061 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
9062 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
9067 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
9068 if (is_attribute_p ("format", TREE_PURPOSE (la)))
9076 /* Subscripting with type char is likely to lose on a machine where
9077 chars are signed. So warn on any machine, but optionally. Don't
9078 warn for unsigned char since that type is safe. Don't warn for
9079 signed char because anyone who uses that must have done so
9080 deliberately. Furthermore, we reduce the false positive load by
9081 warning only for non-constant value of type char. */
9084 warn_array_subscript_with_type_char (tree index)
9086 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
9087 && TREE_CODE (index) != INTEGER_CST)
9088 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
9091 /* Implement -Wparentheses for the unexpected C precedence rules, to
9092 cover cases like x + y << z which readers are likely to
9093 misinterpret. We have seen an expression in which CODE is a binary
9094 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
9095 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
9096 CODE_RIGHT may be ERROR_MARK, which means that that side of the
9097 expression was not formed using a binary or unary operator, or it
9098 was enclosed in parentheses. */
9101 warn_about_parentheses (enum tree_code code,
9102 enum tree_code code_left, tree arg_left,
9103 enum tree_code code_right, tree arg_right)
9105 if (!warn_parentheses)
9108 /* This macro tests that the expression ARG with original tree code
9109 CODE appears to be a boolean expression. or the result of folding a
9110 boolean expression. */
9111 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
9112 (truth_value_p (TREE_CODE (ARG)) \
9113 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
9114 /* Folding may create 0 or 1 integers from other expressions. */ \
9115 || ((CODE) != INTEGER_CST \
9116 && (integer_onep (ARG) || integer_zerop (ARG))))
9121 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9122 warning (OPT_Wparentheses,
9123 "suggest parentheses around %<+%> inside %<<<%>");
9124 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9125 warning (OPT_Wparentheses,
9126 "suggest parentheses around %<-%> inside %<<<%>");
9130 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9131 warning (OPT_Wparentheses,
9132 "suggest parentheses around %<+%> inside %<>>%>");
9133 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9134 warning (OPT_Wparentheses,
9135 "suggest parentheses around %<-%> inside %<>>%>");
9138 case TRUTH_ORIF_EXPR:
9139 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
9140 warning (OPT_Wparentheses,
9141 "suggest parentheses around %<&&%> within %<||%>");
9145 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
9146 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9147 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
9148 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9149 warning (OPT_Wparentheses,
9150 "suggest parentheses around arithmetic in operand of %<|%>");
9151 /* Check cases like x|y==z */
9152 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9153 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9154 warning (OPT_Wparentheses,
9155 "suggest parentheses around comparison in operand of %<|%>");
9156 /* Check cases like !x | y */
9157 else if (code_left == TRUTH_NOT_EXPR
9158 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
9159 warning (OPT_Wparentheses, "suggest parentheses around operand of "
9160 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
9164 if (code_left == BIT_AND_EXPR
9165 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9166 || code_right == BIT_AND_EXPR
9167 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9168 warning (OPT_Wparentheses,
9169 "suggest parentheses around arithmetic in operand of %<^%>");
9170 /* Check cases like x^y==z */
9171 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9172 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9173 warning (OPT_Wparentheses,
9174 "suggest parentheses around comparison in operand of %<^%>");
9178 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9179 warning (OPT_Wparentheses,
9180 "suggest parentheses around %<+%> in operand of %<&%>");
9181 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9182 warning (OPT_Wparentheses,
9183 "suggest parentheses around %<-%> in operand of %<&%>");
9184 /* Check cases like x&y==z */
9185 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9186 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9187 warning (OPT_Wparentheses,
9188 "suggest parentheses around comparison in operand of %<&%>");
9189 /* Check cases like !x & y */
9190 else if (code_left == TRUTH_NOT_EXPR
9191 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
9192 warning (OPT_Wparentheses, "suggest parentheses around operand of "
9193 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
9197 if (TREE_CODE_CLASS (code_left) == tcc_comparison
9198 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9199 warning (OPT_Wparentheses,
9200 "suggest parentheses around comparison in operand of %<==%>");
9203 if (TREE_CODE_CLASS (code_left) == tcc_comparison
9204 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9205 warning (OPT_Wparentheses,
9206 "suggest parentheses around comparison in operand of %<!=%>");
9210 if (TREE_CODE_CLASS (code) == tcc_comparison
9211 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
9212 && code_left != NE_EXPR && code_left != EQ_EXPR
9213 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
9214 || (TREE_CODE_CLASS (code_right) == tcc_comparison
9215 && code_right != NE_EXPR && code_right != EQ_EXPR
9216 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
9217 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
9218 "have their mathematical meaning");
9221 #undef NOT_A_BOOLEAN_EXPR_P
9224 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
9227 warn_for_unused_label (tree label)
9229 if (!TREE_USED (label))
9231 if (DECL_INITIAL (label))
9232 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9234 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9238 #ifndef TARGET_HAS_TARGETCM
9239 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
9242 /* Warn for division by zero according to the value of DIVISOR. LOC
9243 is the location of the division operator. */
9246 warn_for_div_by_zero (location_t loc, tree divisor)
9248 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9249 about division by zero. Do not issue a warning if DIVISOR has a
9250 floating-point type, since we consider 0.0/0.0 a valid way of
9251 generating a NaN. */
9252 if (c_inhibit_evaluation_warnings == 0
9253 && (integer_zerop (divisor) || fixed_zerop (divisor)))
9254 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
9257 /* Subroutine of build_binary_op. Give warnings for comparisons
9258 between signed and unsigned quantities that may fail. Do the
9259 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9260 so that casts will be considered, but default promotions won't
9263 LOCATION is the location of the comparison operator.
9265 The arguments of this function map directly to local variables
9266 of build_binary_op. */
9269 warn_for_sign_compare (location_t location,
9270 tree orig_op0, tree orig_op1,
9272 tree result_type, enum tree_code resultcode)
9274 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9275 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9276 int unsignedp0, unsignedp1;
9278 /* In C++, check for comparison of different enum types. */
9280 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9281 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9282 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
9283 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
9285 warning_at (location,
9286 OPT_Wsign_compare, "comparison between types %qT and %qT",
9287 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
9290 /* Do not warn if the comparison is being done in a signed type,
9291 since the signed type will only be chosen if it can represent
9292 all the values of the unsigned type. */
9293 if (!TYPE_UNSIGNED (result_type))
9295 /* Do not warn if both operands are unsigned. */
9296 else if (op0_signed == op1_signed)
9300 tree sop, uop, base_type;
9304 sop = orig_op0, uop = orig_op1;
9306 sop = orig_op1, uop = orig_op0;
9308 STRIP_TYPE_NOPS (sop);
9309 STRIP_TYPE_NOPS (uop);
9310 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9311 ? TREE_TYPE (result_type) : result_type);
9313 /* Do not warn if the signed quantity is an unsuffixed integer
9314 literal (or some static constant expression involving such
9315 literals or a conditional expression involving such literals)
9316 and it is non-negative. */
9317 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9319 /* Do not warn if the comparison is an equality operation, the
9320 unsigned quantity is an integral constant, and it would fit
9321 in the result if the result were signed. */
9322 else if (TREE_CODE (uop) == INTEGER_CST
9323 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
9324 && int_fits_type_p (uop, c_common_signed_type (base_type)))
9326 /* In C, do not warn if the unsigned quantity is an enumeration
9327 constant and its maximum value would fit in the result if the
9328 result were signed. */
9329 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9330 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9331 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
9332 c_common_signed_type (base_type)))
9335 warning_at (location,
9337 "comparison between signed and unsigned integer expressions");
9340 /* Warn if two unsigned values are being compared in a size larger
9341 than their original size, and one (and only one) is the result of
9342 a `~' operator. This comparison will always fail.
9344 Also warn if one operand is a constant, and the constant does not
9345 have all bits set that are set in the ~ operand when it is
9348 op0 = get_narrower (op0, &unsignedp0);
9349 op1 = get_narrower (op1, &unsignedp1);
9351 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9352 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9354 if (TREE_CODE (op0) == BIT_NOT_EXPR)
9355 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9356 if (TREE_CODE (op1) == BIT_NOT_EXPR)
9357 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9359 if (host_integerp (op0, 0) || host_integerp (op1, 0))
9362 HOST_WIDE_INT constant, mask;
9366 if (host_integerp (op0, 0))
9369 unsignedp = unsignedp1;
9370 constant = tree_low_cst (op0, 0);
9375 unsignedp = unsignedp0;
9376 constant = tree_low_cst (op1, 0);
9379 bits = TYPE_PRECISION (TREE_TYPE (primop));
9380 if (bits < TYPE_PRECISION (result_type)
9381 && bits < HOST_BITS_PER_LONG && unsignedp)
9383 mask = (~ (HOST_WIDE_INT) 0) << bits;
9384 if ((mask & constant) != mask)
9387 warning (OPT_Wsign_compare,
9388 "promoted ~unsigned is always non-zero");
9390 warning_at (location, OPT_Wsign_compare,
9391 "comparison of promoted ~unsigned with constant");
9395 else if (unsignedp0 && unsignedp1
9396 && (TYPE_PRECISION (TREE_TYPE (op0))
9397 < TYPE_PRECISION (result_type))
9398 && (TYPE_PRECISION (TREE_TYPE (op1))
9399 < TYPE_PRECISION (result_type)))
9400 warning_at (location, OPT_Wsign_compare,
9401 "comparison of promoted ~unsigned with unsigned");
9405 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
9406 type via c_common_type. If -Wdouble-promotion is in use, and the
9407 conditions for warning have been met, issue a warning. GMSGID is
9408 the warning message. It must have two %T specifiers for the type
9409 that was converted (generally "float") and the type to which it was
9410 converted (generally "double), respectively. LOC is the location
9411 to which the awrning should refer. */
9414 do_warn_double_promotion (tree result_type, tree type1, tree type2,
9415 const char *gmsgid, location_t loc)
9419 if (!warn_double_promotion)
9421 /* If the conversion will not occur at run-time, there is no need to
9423 if (c_inhibit_evaluation_warnings)
9425 if (TYPE_MAIN_VARIANT (result_type) != double_type_node
9426 && TYPE_MAIN_VARIANT (result_type) != complex_double_type_node)
9428 if (TYPE_MAIN_VARIANT (type1) == float_type_node
9429 || TYPE_MAIN_VARIANT (type1) == complex_float_type_node)
9430 source_type = type1;
9431 else if (TYPE_MAIN_VARIANT (type2) == float_type_node
9432 || TYPE_MAIN_VARIANT (type2) == complex_float_type_node)
9433 source_type = type2;
9436 warning_at (loc, OPT_Wdouble_promotion, gmsgid, source_type, result_type);
9439 /* Setup a TYPE_DECL node as a typedef representation.
9441 X is a TYPE_DECL for a typedef statement. Create a brand new
9442 ..._TYPE node (which will be just a variant of the existing
9443 ..._TYPE node with identical properties) and then install X
9444 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9446 The whole point here is to end up with a situation where each
9447 and every ..._TYPE node the compiler creates will be uniquely
9448 associated with AT MOST one node representing a typedef name.
9449 This way, even though the compiler substitutes corresponding
9450 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9451 early on, later parts of the compiler can always do the reverse
9452 translation and get back the corresponding typedef name. For
9455 typedef struct S MY_TYPE;
9458 Later parts of the compiler might only know that `object' was of
9459 type `struct S' if it were not for code just below. With this
9460 code however, later parts of the compiler see something like:
9462 struct S' == struct S
9463 typedef struct S' MY_TYPE;
9466 And they can then deduce (from the node for type struct S') that
9467 the original object declaration was:
9471 Being able to do this is important for proper support of protoize,
9472 and also for generating precise symbolic debugging information
9473 which takes full account of the programmer's (typedef) vocabulary.
9475 Obviously, we don't want to generate a duplicate ..._TYPE node if
9476 the TYPE_DECL node that we are now processing really represents a
9477 standard built-in type. */
9480 set_underlying_type (tree x)
9482 if (x == error_mark_node)
9484 if (DECL_IS_BUILTIN (x))
9486 if (TYPE_NAME (TREE_TYPE (x)) == 0)
9487 TYPE_NAME (TREE_TYPE (x)) = x;
9489 else if (TREE_TYPE (x) != error_mark_node
9490 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9492 tree tt = TREE_TYPE (x);
9493 DECL_ORIGINAL_TYPE (x) = tt;
9494 tt = build_variant_type_copy (tt);
9495 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9497 TREE_USED (tt) = TREE_USED (x);
9502 /* Record the types used by the current global variable declaration
9503 being parsed, so that we can decide later to emit their debug info.
9504 Those types are in types_used_by_cur_var_decl, and we are going to
9505 store them in the types_used_by_vars_hash hash table.
9506 DECL is the declaration of the global variable that has been parsed. */
9509 record_types_used_by_current_var_decl (tree decl)
9511 gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
9513 while (!VEC_empty (tree, types_used_by_cur_var_decl))
9515 tree type = VEC_pop (tree, types_used_by_cur_var_decl);
9516 types_used_by_var_decl_insert (type, decl);
9520 /* The C and C++ parsers both use vectors to hold function arguments.
9521 For efficiency, we keep a cache of unused vectors. This is the
9524 typedef VEC(tree,gc)* tree_gc_vec;
9525 DEF_VEC_P(tree_gc_vec);
9526 DEF_VEC_ALLOC_P(tree_gc_vec,gc);
9527 static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
9529 /* Return a new vector from the cache. If the cache is empty,
9530 allocate a new vector. These vectors are GC'ed, so it is OK if the
9531 pointer is not released.. */
9534 make_tree_vector (void)
9536 if (!VEC_empty (tree_gc_vec, tree_vector_cache))
9537 return VEC_pop (tree_gc_vec, tree_vector_cache);
9540 /* Passing 0 to VEC_alloc returns NULL, and our callers require
9541 that we always return a non-NULL value. The vector code uses
9542 4 when growing a NULL vector, so we do too. */
9543 return VEC_alloc (tree, gc, 4);
9547 /* Release a vector of trees back to the cache. */
9550 release_tree_vector (VEC(tree,gc) *vec)
9554 VEC_truncate (tree, vec, 0);
9555 VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
9559 /* Get a new tree vector holding a single tree. */
9562 make_tree_vector_single (tree t)
9564 VEC(tree,gc) *ret = make_tree_vector ();
9565 VEC_quick_push (tree, ret, t);
9569 /* Get a new tree vector which is a copy of an existing one. */
9572 make_tree_vector_copy (const VEC(tree,gc) *orig)
9578 ret = make_tree_vector ();
9579 VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
9580 FOR_EACH_VEC_ELT (tree, orig, ix, t)
9581 VEC_quick_push (tree, ret, t);
9585 /* Return true if KEYWORD starts a type specifier. */
9588 keyword_begins_type_specifier (enum rid keyword)
9624 /* Return true if KEYWORD names a type qualifier. */
9627 keyword_is_type_qualifier (enum rid keyword)
9640 /* Return true if KEYWORD names a storage class specifier.
9642 RID_TYPEDEF is not included in this list despite `typedef' being
9643 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
9644 such for syntactic convenience only. */
9647 keyword_is_storage_class_specifier (enum rid keyword)
9663 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
9666 keyword_is_function_specifier (enum rid keyword)
9679 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
9680 declaration-specifier (C99 6.7). */
9683 keyword_is_decl_specifier (enum rid keyword)
9685 if (keyword_is_storage_class_specifier (keyword)
9686 || keyword_is_type_qualifier (keyword)
9687 || keyword_is_function_specifier (keyword))
9701 #include "gt-c-family-c-common.h"