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
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"
37 #include "langhooks.h"
38 #include "tree-inline.h"
40 #include "diagnostic.h"
41 #include "tree-iterator.h"
43 #include "tree-mudflap.h"
46 #include "target-def.h"
49 cpp_reader *parse_in; /* Declared in c-pragma.h. */
51 /* The following symbols are subsumed in the c_global_trees array, and
52 listed here individually for documentation purposes.
54 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
56 tree short_integer_type_node;
57 tree long_integer_type_node;
58 tree long_long_integer_type_node;
59 tree int128_integer_type_node;
61 tree short_unsigned_type_node;
62 tree long_unsigned_type_node;
63 tree long_long_unsigned_type_node;
64 tree int128_unsigned_type_node;
66 tree truthvalue_type_node;
67 tree truthvalue_false_node;
68 tree truthvalue_true_node;
70 tree ptrdiff_type_node;
72 tree unsigned_char_type_node;
73 tree signed_char_type_node;
76 tree char16_type_node;
77 tree char32_type_node;
80 tree double_type_node;
81 tree long_double_type_node;
83 tree complex_integer_type_node;
84 tree complex_float_type_node;
85 tree complex_double_type_node;
86 tree complex_long_double_type_node;
88 tree dfloat32_type_node;
89 tree dfloat64_type_node;
90 tree_dfloat128_type_node;
98 tree unsigned_intQI_type_node;
99 tree unsigned_intHI_type_node;
100 tree unsigned_intSI_type_node;
101 tree unsigned_intDI_type_node;
102 tree unsigned_intTI_type_node;
104 tree widest_integer_literal_type_node;
105 tree widest_unsigned_literal_type_node;
107 Nodes for types `void *' and `const void *'.
109 tree ptr_type_node, const_ptr_type_node;
111 Nodes for types `char *' and `const char *'.
113 tree string_type_node, const_string_type_node;
115 Type `char[SOMENUMBER]'.
116 Used when an array of char is needed and the size is irrelevant.
118 tree char_array_type_node;
120 Type `int[SOMENUMBER]' or something like it.
121 Used when an array of int needed and the size is irrelevant.
123 tree int_array_type_node;
125 Type `wchar_t[SOMENUMBER]' or something like it.
126 Used when a wide string literal is created.
128 tree wchar_array_type_node;
130 Type `char16_t[SOMENUMBER]' or something like it.
131 Used when a UTF-16 string literal is created.
133 tree char16_array_type_node;
135 Type `char32_t[SOMENUMBER]' or something like it.
136 Used when a UTF-32 string literal is created.
138 tree char32_array_type_node;
140 Type `int ()' -- used for implicit declaration of functions.
142 tree default_function_type;
144 A VOID_TYPE node, packaged in a TREE_LIST.
148 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
149 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
150 VAR_DECLS, but C++ does.)
152 tree function_name_decl_node;
153 tree pretty_function_name_decl_node;
154 tree c99_function_name_decl_node;
156 Stack of nested function name VAR_DECLs.
158 tree saved_function_name_decls;
162 tree c_global_trees[CTI_MAX];
164 /* Switches common to the C front ends. */
166 /* Nonzero means don't output line number information. */
168 char flag_no_line_commands;
170 /* Nonzero causes -E output not to be done, but directives such as
171 #define that have side effects are still obeyed. */
175 /* Nonzero means dump macros in some fashion. */
177 char flag_dump_macros;
179 /* Nonzero means pass #include lines through to the output. */
181 char flag_dump_includes;
183 /* Nonzero means process PCH files while preprocessing. */
185 bool flag_pch_preprocess;
187 /* The file name to which we should write a precompiled header, or
188 NULL if no header will be written in this compile. */
190 const char *pch_file;
192 /* Nonzero if an ISO standard was selected. It rejects macros in the
196 /* Warn about #pragma directives that are not recognized. */
198 int warn_unknown_pragmas; /* Tri state variable. */
200 /* Warn about format/argument anomalies in calls to formatted I/O functions
201 (*printf, *scanf, strftime, strfmon, etc.). */
205 /* C/ObjC language option variables. */
208 /* Nonzero means allow type mismatches in conditional expressions;
209 just make their values `void'. */
211 int flag_cond_mismatch;
213 /* Nonzero means enable C89 Amendment 1 features. */
217 /* Nonzero means use the ISO C99 (or C1X) dialect of C. */
221 /* Nonzero means use the ISO C1X dialect of C. */
225 /* Nonzero means that we have builtin functions, and main is an int. */
230 /* ObjC language option variables. */
233 /* Tells the compiler that this is a special run. Do not perform any
234 compiling, instead we are to test some platform dependent features
235 and output a C header file with appropriate definitions. */
237 int print_struct_values;
239 /* Tells the compiler what is the constant string class for ObjC. */
241 const char *constant_string_class_name;
244 /* C++ language option variables. */
247 /* Nonzero means generate separate instantiation control files and
248 juggle them at link time. */
250 int flag_use_repository;
252 /* The C++ dialect being used. C++98 is the default. */
254 enum cxx_dialect cxx_dialect = cxx98;
256 /* Maximum template instantiation depth. This limit exists to limit the
257 time it takes to notice infinite template instantiations; the default
258 value of 1024 is likely to be in the next C++ standard. */
260 int max_tinst_depth = 1024;
264 /* The elements of `ridpointers' are identifier nodes for the reserved
265 type names and storage classes. It is indexed by a RID_... value. */
268 tree (*make_fname_decl) (location_t, tree, int);
270 /* Nonzero means don't warn about problems that occur when the code is
272 int c_inhibit_evaluation_warnings;
274 /* Whether lexing has been completed, so subsequent preprocessor
275 errors should use the compiler's input_location. */
276 bool done_lexing = false;
278 /* Information about how a function name is generated. */
281 tree *const decl; /* pointer to the VAR_DECL. */
282 const unsigned rid; /* RID number for the identifier. */
283 const int pretty; /* How pretty is it? */
286 /* The three ways of getting then name of the current function. */
288 const struct fname_var_t fname_vars[] =
290 /* C99 compliant __func__, must be first. */
291 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
292 /* GCC __FUNCTION__ compliant. */
293 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
294 /* GCC __PRETTY_FUNCTION__ compliant. */
295 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
299 static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
300 static tree check_case_value (tree);
301 static bool check_case_bounds (tree, tree, tree *, tree *);
303 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
304 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
305 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
306 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
307 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
308 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
309 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
310 static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
311 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
312 static tree handle_always_inline_attribute (tree *, tree, tree, int,
314 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
315 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
316 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
317 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
318 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
319 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
320 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
322 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
323 static tree handle_transparent_union_attribute (tree *, tree, tree,
325 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
326 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
327 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
328 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
329 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
330 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
331 static tree handle_alias_ifunc_attribute (bool, tree *, tree, tree, bool *);
332 static tree handle_ifunc_attribute (tree *, tree, tree, int, bool *);
333 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
334 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
335 static tree handle_visibility_attribute (tree *, tree, tree, int,
337 static tree handle_tls_model_attribute (tree *, tree, tree, int,
339 static tree handle_no_instrument_function_attribute (tree *, tree,
341 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
342 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
343 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
345 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
346 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
347 static tree handle_deprecated_attribute (tree *, tree, tree, int,
349 static tree handle_vector_size_attribute (tree *, tree, tree, int,
351 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
352 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
353 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
354 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
356 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
357 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
358 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
359 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
360 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
361 static tree handle_no_split_stack_attribute (tree *, tree, tree, int, bool *);
362 static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
364 static void check_function_nonnull (tree, int, tree *);
365 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
366 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
367 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
368 static int resort_field_decl_cmp (const void *, const void *);
370 /* Reserved words. The third field is a mask: keywords are disabled
371 if they match the mask.
374 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
375 C --std=c99: D_CXXONLY | D_OBJC
376 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
377 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
378 C++ --std=c0x: D_CONLY | D_OBJC
379 ObjC++ is like C++ except that D_OBJC is not set
381 If -fno-asm is used, D_ASM is added to the mask. If
382 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
383 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
384 In C with -Wc++-compat, we warn if D_CXXWARN is set.
386 Note the complication of the D_CXX_OBJC keywords. These are
387 reserved words such as 'class'. In C++, 'class' is a reserved
388 word. In Objective-C++ it is too. In Objective-C, it is a
389 reserved word too, but only if it follows an '@' sign.
391 const struct c_common_resword c_common_reswords[] =
393 { "_Bool", RID_BOOL, D_CONLY },
394 { "_Complex", RID_COMPLEX, 0 },
395 { "_Imaginary", RID_IMAGINARY, D_CONLY },
396 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
397 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
398 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
399 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
400 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
401 { "_Sat", RID_SAT, D_CONLY | D_EXT },
402 { "_Static_assert", RID_STATIC_ASSERT, D_CONLY },
403 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
404 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
405 { "__alignof", RID_ALIGNOF, 0 },
406 { "__alignof__", RID_ALIGNOF, 0 },
407 { "__asm", RID_ASM, 0 },
408 { "__asm__", RID_ASM, 0 },
409 { "__attribute", RID_ATTRIBUTE, 0 },
410 { "__attribute__", RID_ATTRIBUTE, 0 },
411 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
412 { "__builtin_offsetof", RID_OFFSETOF, 0 },
413 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
414 { "__builtin_va_arg", RID_VA_ARG, 0 },
415 { "__complex", RID_COMPLEX, 0 },
416 { "__complex__", RID_COMPLEX, 0 },
417 { "__const", RID_CONST, 0 },
418 { "__const__", RID_CONST, 0 },
419 { "__decltype", RID_DECLTYPE, D_CXXONLY },
420 { "__extension__", RID_EXTENSION, 0 },
421 { "__func__", RID_C99_FUNCTION_NAME, 0 },
422 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
423 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
424 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
425 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
426 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
427 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
428 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
429 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
430 { "__int128", RID_INT128, 0 },
431 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
432 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
433 { "__is_class", RID_IS_CLASS, D_CXXONLY },
434 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
435 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
436 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
437 { "__is_pod", RID_IS_POD, D_CXXONLY },
438 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
439 { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY },
440 { "__is_trivial", RID_IS_TRIVIAL, D_CXXONLY },
441 { "__is_union", RID_IS_UNION, D_CXXONLY },
442 { "__is_literal_type", RID_IS_LITERAL_TYPE, D_CXXONLY },
443 { "__imag", RID_IMAGPART, 0 },
444 { "__imag__", RID_IMAGPART, 0 },
445 { "__inline", RID_INLINE, 0 },
446 { "__inline__", RID_INLINE, 0 },
447 { "__label__", RID_LABEL, 0 },
448 { "__null", RID_NULL, 0 },
449 { "__real", RID_REALPART, 0 },
450 { "__real__", RID_REALPART, 0 },
451 { "__restrict", RID_RESTRICT, 0 },
452 { "__restrict__", RID_RESTRICT, 0 },
453 { "__signed", RID_SIGNED, 0 },
454 { "__signed__", RID_SIGNED, 0 },
455 { "__thread", RID_THREAD, 0 },
456 { "__typeof", RID_TYPEOF, 0 },
457 { "__typeof__", RID_TYPEOF, 0 },
458 { "__volatile", RID_VOLATILE, 0 },
459 { "__volatile__", RID_VOLATILE, 0 },
460 { "alignof", RID_ALIGNOF, D_CXXONLY | D_CXX0X | D_CXXWARN },
461 { "asm", RID_ASM, D_ASM },
462 { "auto", RID_AUTO, 0 },
463 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
464 { "break", RID_BREAK, 0 },
465 { "case", RID_CASE, 0 },
466 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
467 { "char", RID_CHAR, 0 },
468 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
469 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
470 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
471 { "const", RID_CONST, 0 },
472 { "constexpr", RID_CONSTEXPR, D_CXXONLY | D_CXX0X | D_CXXWARN },
473 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
474 { "continue", RID_CONTINUE, 0 },
475 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
476 { "default", RID_DEFAULT, 0 },
477 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
479 { "double", RID_DOUBLE, 0 },
480 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
481 { "else", RID_ELSE, 0 },
482 { "enum", RID_ENUM, 0 },
483 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
484 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
485 { "extern", RID_EXTERN, 0 },
486 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
487 { "float", RID_FLOAT, 0 },
488 { "for", RID_FOR, 0 },
489 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
490 { "goto", RID_GOTO, 0 },
492 { "inline", RID_INLINE, D_EXT89 },
493 { "int", RID_INT, 0 },
494 { "long", RID_LONG, 0 },
495 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
496 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
497 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
498 { "noexcept", RID_NOEXCEPT, D_CXXONLY | D_CXX0X | D_CXXWARN },
499 { "nullptr", RID_NULLPTR, D_CXXONLY | D_CXX0X | D_CXXWARN },
500 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
501 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
502 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
503 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
504 { "register", RID_REGISTER, 0 },
505 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
506 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
507 { "return", RID_RETURN, 0 },
508 { "short", RID_SHORT, 0 },
509 { "signed", RID_SIGNED, 0 },
510 { "sizeof", RID_SIZEOF, 0 },
511 { "static", RID_STATIC, 0 },
512 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
513 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
514 { "struct", RID_STRUCT, 0 },
515 { "switch", RID_SWITCH, 0 },
516 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
517 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
518 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
519 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
520 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
521 { "typedef", RID_TYPEDEF, 0 },
522 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
523 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
524 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
525 { "union", RID_UNION, 0 },
526 { "unsigned", RID_UNSIGNED, 0 },
527 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
528 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
529 { "void", RID_VOID, 0 },
530 { "volatile", RID_VOLATILE, 0 },
531 { "wchar_t", RID_WCHAR, D_CXXONLY },
532 { "while", RID_WHILE, 0 },
533 /* These Objective-C keywords are recognized only immediately after
535 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
536 { "defs", RID_AT_DEFS, D_OBJC },
537 { "encode", RID_AT_ENCODE, D_OBJC },
538 { "end", RID_AT_END, D_OBJC },
539 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
540 { "interface", RID_AT_INTERFACE, D_OBJC },
541 { "protocol", RID_AT_PROTOCOL, D_OBJC },
542 { "selector", RID_AT_SELECTOR, D_OBJC },
543 { "finally", RID_AT_FINALLY, D_OBJC },
544 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
545 { "optional", RID_AT_OPTIONAL, D_OBJC },
546 { "required", RID_AT_REQUIRED, D_OBJC },
547 { "property", RID_AT_PROPERTY, D_OBJC },
548 { "package", RID_AT_PACKAGE, D_OBJC },
549 { "synthesize", RID_AT_SYNTHESIZE, D_OBJC },
550 { "dynamic", RID_AT_DYNAMIC, D_OBJC },
551 /* These are recognized only in protocol-qualifier context
553 { "bycopy", RID_BYCOPY, D_OBJC },
554 { "byref", RID_BYREF, D_OBJC },
555 { "in", RID_IN, D_OBJC },
556 { "inout", RID_INOUT, D_OBJC },
557 { "oneway", RID_ONEWAY, D_OBJC },
558 { "out", RID_OUT, D_OBJC },
559 /* These are recognized inside a property attribute list */
560 { "assign", RID_ASSIGN, D_OBJC },
561 { "copy", RID_COPY, D_OBJC },
562 { "getter", RID_GETTER, D_OBJC },
563 { "nonatomic", RID_NONATOMIC, D_OBJC },
564 { "readonly", RID_READONLY, D_OBJC },
565 { "readwrite", RID_READWRITE, D_OBJC },
566 { "retain", RID_RETAIN, D_OBJC },
567 { "setter", RID_SETTER, D_OBJC },
570 const unsigned int num_c_common_reswords =
571 sizeof c_common_reswords / sizeof (struct c_common_resword);
573 /* Table of machine-independent attributes common to all C-like languages. */
574 const struct attribute_spec c_common_attribute_table[] =
576 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
577 { "packed", 0, 0, false, false, false,
578 handle_packed_attribute },
579 { "nocommon", 0, 0, true, false, false,
580 handle_nocommon_attribute },
581 { "common", 0, 0, true, false, false,
582 handle_common_attribute },
583 /* FIXME: logically, noreturn attributes should be listed as
584 "false, true, true" and apply to function types. But implementing this
585 would require all the places in the compiler that use TREE_THIS_VOLATILE
586 on a decl to identify non-returning functions to be located and fixed
587 to check the function type instead. */
588 { "noreturn", 0, 0, true, false, false,
589 handle_noreturn_attribute },
590 { "volatile", 0, 0, true, false, false,
591 handle_noreturn_attribute },
592 { "noinline", 0, 0, true, false, false,
593 handle_noinline_attribute },
594 { "noclone", 0, 0, true, false, false,
595 handle_noclone_attribute },
596 { "leaf", 0, 0, true, false, false,
597 handle_leaf_attribute },
598 { "always_inline", 0, 0, true, false, false,
599 handle_always_inline_attribute },
600 { "gnu_inline", 0, 0, true, false, false,
601 handle_gnu_inline_attribute },
602 { "artificial", 0, 0, true, false, false,
603 handle_artificial_attribute },
604 { "flatten", 0, 0, true, false, false,
605 handle_flatten_attribute },
606 { "used", 0, 0, true, false, false,
607 handle_used_attribute },
608 { "unused", 0, 0, false, false, false,
609 handle_unused_attribute },
610 { "externally_visible", 0, 0, true, false, false,
611 handle_externally_visible_attribute },
612 /* The same comments as for noreturn attributes apply to const ones. */
613 { "const", 0, 0, true, false, false,
614 handle_const_attribute },
615 { "transparent_union", 0, 0, false, false, false,
616 handle_transparent_union_attribute },
617 { "constructor", 0, 1, true, false, false,
618 handle_constructor_attribute },
619 { "destructor", 0, 1, true, false, false,
620 handle_destructor_attribute },
621 { "mode", 1, 1, false, true, false,
622 handle_mode_attribute },
623 { "section", 1, 1, true, false, false,
624 handle_section_attribute },
625 { "aligned", 0, 1, false, false, false,
626 handle_aligned_attribute },
627 { "weak", 0, 0, true, false, false,
628 handle_weak_attribute },
629 { "ifunc", 1, 1, true, false, false,
630 handle_ifunc_attribute },
631 { "alias", 1, 1, true, false, false,
632 handle_alias_attribute },
633 { "weakref", 0, 1, true, false, false,
634 handle_weakref_attribute },
635 { "no_instrument_function", 0, 0, true, false, false,
636 handle_no_instrument_function_attribute },
637 { "malloc", 0, 0, true, false, false,
638 handle_malloc_attribute },
639 { "returns_twice", 0, 0, true, false, false,
640 handle_returns_twice_attribute },
641 { "no_stack_limit", 0, 0, true, false, false,
642 handle_no_limit_stack_attribute },
643 { "pure", 0, 0, true, false, false,
644 handle_pure_attribute },
645 /* For internal use (marking of builtins) only. The name contains space
646 to prevent its usage in source code. */
647 { "no vops", 0, 0, true, false, false,
648 handle_novops_attribute },
649 { "deprecated", 0, 1, false, false, false,
650 handle_deprecated_attribute },
651 { "vector_size", 1, 1, false, true, false,
652 handle_vector_size_attribute },
653 { "visibility", 1, 1, false, false, false,
654 handle_visibility_attribute },
655 { "tls_model", 1, 1, true, false, false,
656 handle_tls_model_attribute },
657 { "nonnull", 0, -1, false, true, true,
658 handle_nonnull_attribute },
659 { "nothrow", 0, 0, true, false, false,
660 handle_nothrow_attribute },
661 { "may_alias", 0, 0, false, true, false, NULL },
662 { "cleanup", 1, 1, true, false, false,
663 handle_cleanup_attribute },
664 { "warn_unused_result", 0, 0, false, true, true,
665 handle_warn_unused_result_attribute },
666 { "sentinel", 0, 1, false, true, true,
667 handle_sentinel_attribute },
668 /* For internal use (marking of builtins) only. The name contains space
669 to prevent its usage in source code. */
670 { "type generic", 0, 0, false, true, true,
671 handle_type_generic_attribute },
672 { "alloc_size", 1, 2, false, true, true,
673 handle_alloc_size_attribute },
674 { "cold", 0, 0, true, false, false,
675 handle_cold_attribute },
676 { "hot", 0, 0, true, false, false,
677 handle_hot_attribute },
678 { "warning", 1, 1, true, false, false,
679 handle_error_attribute },
680 { "error", 1, 1, true, false, false,
681 handle_error_attribute },
682 { "target", 1, -1, true, false, false,
683 handle_target_attribute },
684 { "optimize", 1, -1, true, false, false,
685 handle_optimize_attribute },
686 { "no_split_stack", 0, 0, true, false, false,
687 handle_no_split_stack_attribute },
688 /* For internal use (marking of builtins and runtime functions) only.
689 The name contains space to prevent its usage in source code. */
690 { "fn spec", 1, 1, false, true, true,
691 handle_fnspec_attribute },
692 { NULL, 0, 0, false, false, false, NULL }
695 /* Give the specifications for the format attributes, used by C and all
698 const struct attribute_spec c_common_format_attribute_table[] =
700 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
701 { "format", 3, 3, false, true, true,
702 handle_format_attribute },
703 { "format_arg", 1, 1, false, true, true,
704 handle_format_arg_attribute },
705 { NULL, 0, 0, false, false, false, NULL }
708 /* Return identifier for address space AS. */
711 c_addr_space_name (addr_space_t as)
713 int rid = RID_FIRST_ADDR_SPACE + as;
714 gcc_assert (ridpointers [rid]);
715 return IDENTIFIER_POINTER (ridpointers [rid]);
718 /* Push current bindings for the function name VAR_DECLS. */
721 start_fname_decls (void)
724 tree saved = NULL_TREE;
726 for (ix = 0; fname_vars[ix].decl; ix++)
728 tree decl = *fname_vars[ix].decl;
732 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
733 *fname_vars[ix].decl = NULL_TREE;
736 if (saved || saved_function_name_decls)
737 /* Normally they'll have been NULL, so only push if we've got a
738 stack, or they are non-NULL. */
739 saved_function_name_decls = tree_cons (saved, NULL_TREE,
740 saved_function_name_decls);
743 /* Finish up the current bindings, adding them into the current function's
744 statement tree. This must be done _before_ finish_stmt_tree is called.
745 If there is no current function, we must be at file scope and no statements
746 are involved. Pop the previous bindings. */
749 finish_fname_decls (void)
752 tree stmts = NULL_TREE;
753 tree stack = saved_function_name_decls;
755 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
756 append_to_statement_list (TREE_VALUE (stack), &stmts);
760 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
762 if (TREE_CODE (*bodyp) == BIND_EXPR)
763 bodyp = &BIND_EXPR_BODY (*bodyp);
765 append_to_statement_list_force (*bodyp, &stmts);
769 for (ix = 0; fname_vars[ix].decl; ix++)
770 *fname_vars[ix].decl = NULL_TREE;
774 /* We had saved values, restore them. */
777 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
779 tree decl = TREE_PURPOSE (saved);
780 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
782 *fname_vars[ix].decl = decl;
784 stack = TREE_CHAIN (stack);
786 saved_function_name_decls = stack;
789 /* Return the text name of the current function, suitably prettified
790 by PRETTY_P. Return string must be freed by caller. */
793 fname_as_string (int pretty_p)
795 const char *name = "top level";
798 cpp_string cstr = { 0, 0 }, strname;
806 if (current_function_decl)
807 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
809 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
811 namep = XNEWVEC (char, len);
812 snprintf (namep, len, "\"%s\"", name);
813 strname.text = (unsigned char *) namep;
814 strname.len = len - 1;
816 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
819 return (const char *) cstr.text;
825 /* Return the VAR_DECL for a const char array naming the current
826 function. If the VAR_DECL has not yet been created, create it
827 now. RID indicates how it should be formatted and IDENTIFIER_NODE
828 ID is its name (unfortunately C and C++ hold the RID values of
829 keywords in different places, so we can't derive RID from ID in
830 this language independent code. LOC is the location of the
834 fname_decl (location_t loc, unsigned int rid, tree id)
837 tree decl = NULL_TREE;
839 for (ix = 0; fname_vars[ix].decl; ix++)
840 if (fname_vars[ix].rid == rid)
843 decl = *fname_vars[ix].decl;
846 /* If a tree is built here, it would normally have the lineno of
847 the current statement. Later this tree will be moved to the
848 beginning of the function and this line number will be wrong.
849 To avoid this problem set the lineno to 0 here; that prevents
850 it from appearing in the RTL. */
852 location_t saved_location = input_location;
853 input_location = UNKNOWN_LOCATION;
855 stmts = push_stmt_list ();
856 decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty);
857 stmts = pop_stmt_list (stmts);
858 if (!IS_EMPTY_STMT (stmts))
859 saved_function_name_decls
860 = tree_cons (decl, stmts, saved_function_name_decls);
861 *fname_vars[ix].decl = decl;
862 input_location = saved_location;
864 if (!ix && !current_function_decl)
865 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
870 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
873 fix_string_type (tree value)
875 int length = TREE_STRING_LENGTH (value);
877 tree e_type, i_type, a_type;
879 /* Compute the number of elements, for the array type. */
880 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
883 e_type = char_type_node;
885 else if (TREE_TYPE (value) == char16_array_type_node)
887 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
888 e_type = char16_type_node;
890 else if (TREE_TYPE (value) == char32_array_type_node)
892 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
893 e_type = char32_type_node;
897 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
898 e_type = wchar_type_node;
901 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
902 limit in C++98 Annex B is very large (65536) and is not normative,
903 so we do not diagnose it (warn_overlength_strings is forced off
904 in c_common_post_options). */
905 if (warn_overlength_strings)
907 const int nchars_max = flag_isoc99 ? 4095 : 509;
908 const int relevant_std = flag_isoc99 ? 99 : 90;
909 if (nchars - 1 > nchars_max)
910 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
911 separate the %d from the 'C'. 'ISO' should not be
912 translated, but it may be moved after 'C%d' in languages
913 where modifiers follow nouns. */
914 pedwarn (input_location, OPT_Woverlength_strings,
915 "string length %qd is greater than the length %qd "
916 "ISO C%d compilers are required to support",
917 nchars - 1, nchars_max, relevant_std);
920 /* Create the array type for the string constant. The ISO C++
921 standard says that a string literal has type `const char[N]' or
922 `const wchar_t[N]'. We use the same logic when invoked as a C
923 front-end with -Wwrite-strings.
924 ??? We should change the type of an expression depending on the
925 state of a warning flag. We should just be warning -- see how
926 this is handled in the C++ front-end for the deprecated implicit
927 conversion from string literals to `char*' or `wchar_t*'.
929 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
930 array type being the unqualified version of that type.
931 Therefore, if we are constructing an array of const char, we must
932 construct the matching unqualified array type first. The C front
933 end does not require this, but it does no harm, so we do it
935 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
936 a_type = build_array_type (e_type, i_type);
937 if (c_dialect_cxx() || warn_write_strings)
938 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
940 TREE_TYPE (value) = a_type;
941 TREE_CONSTANT (value) = 1;
942 TREE_READONLY (value) = 1;
943 TREE_STATIC (value) = 1;
947 /* Fully fold EXPR, an expression that was not folded (beyond integer
948 constant expressions and null pointer constants) when being built
949 up. If IN_INIT, this is in a static initializer and certain
950 changes are made to the folding done. Clear *MAYBE_CONST if
951 MAYBE_CONST is not NULL and EXPR is definitely not a constant
952 expression because it contains an evaluated operator (in C99) or an
953 operator outside of sizeof returning an integer constant (in C90)
954 not permitted in constant expressions, or because it contains an
955 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
956 set to true by callers before calling this function.) Return the
957 folded expression. Function arguments have already been folded
958 before calling this function, as have the contents of SAVE_EXPR,
959 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
960 C_MAYBE_CONST_EXPR. */
963 c_fully_fold (tree expr, bool in_init, bool *maybe_const)
966 tree eptype = NULL_TREE;
968 bool maybe_const_itself = true;
969 location_t loc = EXPR_LOCATION (expr);
971 /* This function is not relevant to C++ because C++ folds while
972 parsing, and may need changes to be correct for C++ when C++
973 stops folding while parsing. */
974 if (c_dialect_cxx ())
978 maybe_const = &dummy;
979 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
981 eptype = TREE_TYPE (expr);
982 expr = TREE_OPERAND (expr, 0);
984 ret = c_fully_fold_internal (expr, in_init, maybe_const,
985 &maybe_const_itself);
987 ret = fold_convert_loc (loc, eptype, ret);
988 *maybe_const &= maybe_const_itself;
992 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
993 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
994 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
995 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
996 both evaluated and unevaluated subexpressions while
997 *MAYBE_CONST_ITSELF is carried from only evaluated
1001 c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1002 bool *maybe_const_itself)
1005 enum tree_code code = TREE_CODE (expr);
1006 enum tree_code_class kind = TREE_CODE_CLASS (code);
1007 location_t loc = EXPR_LOCATION (expr);
1008 tree op0, op1, op2, op3;
1009 tree orig_op0, orig_op1, orig_op2;
1010 bool op0_const = true, op1_const = true, op2_const = true;
1011 bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1012 bool nowarning = TREE_NO_WARNING (expr);
1015 /* This function is not relevant to C++ because C++ folds while
1016 parsing, and may need changes to be correct for C++ when C++
1017 stops folding while parsing. */
1018 if (c_dialect_cxx ())
1021 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1022 anything else not counted as an expression cannot usefully be
1023 folded further at this point. */
1024 if (!IS_EXPR_CODE_CLASS (kind)
1025 || kind == tcc_statement
1026 || code == SAVE_EXPR)
1029 /* Operands of variable-length expressions (function calls) have
1030 already been folded, as have __builtin_* function calls, and such
1031 expressions cannot occur in constant expressions. */
1032 if (kind == tcc_vl_exp)
1034 *maybe_const_operands = false;
1039 if (code == C_MAYBE_CONST_EXPR)
1041 tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1042 tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1043 if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1044 *maybe_const_operands = false;
1045 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1046 *maybe_const_itself = false;
1047 if (pre && !in_init)
1048 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1054 /* Assignment, increment, decrement, function call and comma
1055 operators, and statement expressions, cannot occur in constant
1056 expressions if evaluated / outside of sizeof. (Function calls
1057 were handled above, though VA_ARG_EXPR is treated like a function
1058 call here, and statement expressions are handled through
1059 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1063 case PREDECREMENT_EXPR:
1064 case PREINCREMENT_EXPR:
1065 case POSTDECREMENT_EXPR:
1066 case POSTINCREMENT_EXPR:
1068 *maybe_const_operands = false;
1075 *maybe_const_operands = false;
1083 /* Fold individual tree codes as appropriate. */
1086 case COMPOUND_LITERAL_EXPR:
1087 /* Any non-constancy will have been marked in a containing
1088 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1092 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1093 op1 = TREE_OPERAND (expr, 1);
1094 op2 = TREE_OPERAND (expr, 2);
1095 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1096 maybe_const_itself);
1097 STRIP_TYPE_NOPS (op0);
1098 if (op0 != orig_op0)
1099 ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1102 TREE_READONLY (ret) = TREE_READONLY (expr);
1103 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1108 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1109 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1110 op2 = TREE_OPERAND (expr, 2);
1111 op3 = TREE_OPERAND (expr, 3);
1112 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1113 maybe_const_itself);
1114 STRIP_TYPE_NOPS (op0);
1115 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1116 maybe_const_itself);
1117 STRIP_TYPE_NOPS (op1);
1118 op1 = decl_constant_value_for_optimization (op1);
1119 if (op0 != orig_op0 || op1 != orig_op1)
1120 ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1123 TREE_READONLY (ret) = TREE_READONLY (expr);
1124 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1125 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1132 case PREDECREMENT_EXPR:
1133 case PREINCREMENT_EXPR:
1134 case POSTDECREMENT_EXPR:
1135 case POSTINCREMENT_EXPR:
1139 case POINTER_PLUS_EXPR:
1140 case TRUNC_DIV_EXPR:
1142 case FLOOR_DIV_EXPR:
1143 case TRUNC_MOD_EXPR:
1145 case EXACT_DIV_EXPR:
1158 case TRUTH_AND_EXPR:
1160 case TRUTH_XOR_EXPR:
1161 case UNORDERED_EXPR:
1168 /* Binary operations evaluating both arguments (increment and
1169 decrement are binary internally in GCC). */
1170 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1171 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1172 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1173 maybe_const_itself);
1174 STRIP_TYPE_NOPS (op0);
1175 if (code != MODIFY_EXPR
1176 && code != PREDECREMENT_EXPR
1177 && code != PREINCREMENT_EXPR
1178 && code != POSTDECREMENT_EXPR
1179 && code != POSTINCREMENT_EXPR)
1180 op0 = decl_constant_value_for_optimization (op0);
1181 /* The RHS of a MODIFY_EXPR was fully folded when building that
1182 expression for the sake of conversion warnings. */
1183 if (code != MODIFY_EXPR)
1184 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1185 maybe_const_itself);
1186 STRIP_TYPE_NOPS (op1);
1187 op1 = decl_constant_value_for_optimization (op1);
1188 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1190 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1191 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1194 if (TREE_OVERFLOW_P (ret)
1195 && !TREE_OVERFLOW_P (op0)
1196 && !TREE_OVERFLOW_P (op1))
1197 overflow_warning (EXPR_LOCATION (expr), ret);
1201 case FIX_TRUNC_EXPR:
1204 case NON_LVALUE_EXPR:
1207 case TRUTH_NOT_EXPR:
1212 /* Unary operations. */
1213 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1214 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1215 maybe_const_itself);
1216 STRIP_TYPE_NOPS (op0);
1217 if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1218 op0 = decl_constant_value_for_optimization (op0);
1219 if (op0 != orig_op0 || in_init)
1221 ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)
1222 : fold_build1_loc (loc, code, TREE_TYPE (expr), op0);
1225 if (code == INDIRECT_REF
1227 && TREE_CODE (ret) == INDIRECT_REF)
1229 TREE_READONLY (ret) = TREE_READONLY (expr);
1230 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1231 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1235 case FIX_TRUNC_EXPR:
1238 /* Don't warn about explicit conversions. We will already
1239 have warned about suspect implicit conversions. */
1243 if (TREE_OVERFLOW_P (ret) && !TREE_OVERFLOW_P (op0))
1244 overflow_warning (EXPR_LOCATION (expr), ret);
1249 case TRUTH_ANDIF_EXPR:
1250 case TRUTH_ORIF_EXPR:
1251 /* Binary operations not necessarily evaluating both
1253 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1254 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1255 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1256 STRIP_TYPE_NOPS (op0);
1258 unused_p = (op0 == (code == TRUTH_ANDIF_EXPR
1259 ? truthvalue_false_node
1260 : truthvalue_true_node));
1261 c_inhibit_evaluation_warnings += unused_p;
1262 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1263 STRIP_TYPE_NOPS (op1);
1264 c_inhibit_evaluation_warnings -= unused_p;
1266 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1268 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1269 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1272 *maybe_const_operands &= op0_const;
1273 *maybe_const_itself &= op0_const_self;
1277 && (code == TRUTH_ANDIF_EXPR
1278 ? op0 == truthvalue_false_node
1279 : op0 == truthvalue_true_node)))
1280 *maybe_const_operands &= op1_const;
1283 && (code == TRUTH_ANDIF_EXPR
1284 ? op0 == truthvalue_false_node
1285 : op0 == truthvalue_true_node)))
1286 *maybe_const_itself &= op1_const_self;
1290 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1291 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1292 orig_op2 = op2 = TREE_OPERAND (expr, 2);
1293 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1295 STRIP_TYPE_NOPS (op0);
1296 c_inhibit_evaluation_warnings += (op0 == truthvalue_false_node);
1297 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1298 STRIP_TYPE_NOPS (op1);
1299 c_inhibit_evaluation_warnings -= (op0 == truthvalue_false_node);
1301 c_inhibit_evaluation_warnings += (op0 == truthvalue_true_node);
1302 op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
1303 STRIP_TYPE_NOPS (op2);
1304 c_inhibit_evaluation_warnings -= (op0 == truthvalue_true_node);
1306 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
1307 ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
1310 *maybe_const_operands &= op0_const;
1311 *maybe_const_itself &= op0_const_self;
1315 && op0 == truthvalue_false_node))
1316 *maybe_const_operands &= op1_const;
1319 && op0 == truthvalue_false_node))
1320 *maybe_const_itself &= op1_const_self;
1324 && op0 == truthvalue_true_node))
1325 *maybe_const_operands &= op2_const;
1328 && op0 == truthvalue_true_node))
1329 *maybe_const_itself &= op2_const_self;
1332 case EXCESS_PRECISION_EXPR:
1333 /* Each case where an operand with excess precision may be
1334 encountered must remove the EXCESS_PRECISION_EXPR around
1335 inner operands and possibly put one around the whole
1336 expression or possibly convert to the semantic type (which
1337 c_fully_fold does); we cannot tell at this stage which is
1338 appropriate in any particular case. */
1342 /* Various codes may appear through folding built-in functions
1343 and their arguments. */
1348 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1349 have been done by this point, so remove them again. */
1350 nowarning |= TREE_NO_WARNING (ret);
1351 STRIP_TYPE_NOPS (ret);
1352 if (nowarning && !TREE_NO_WARNING (ret))
1354 if (!CAN_HAVE_LOCATION_P (ret))
1355 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1356 TREE_NO_WARNING (ret) = 1;
1359 protected_set_expr_location (ret, loc);
1363 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1364 return EXP. Otherwise, return either EXP or its known constant
1365 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1366 Is the BLKmode test appropriate? */
1369 decl_constant_value_for_optimization (tree exp)
1373 /* This function is only used by C, for c_fully_fold and other
1374 optimization, and may not be correct for C++. */
1375 if (c_dialect_cxx ())
1379 || TREE_CODE (exp) != VAR_DECL
1380 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1381 || DECL_MODE (exp) == BLKmode)
1384 ret = decl_constant_value (exp);
1385 /* Avoid unwanted tree sharing between the initializer and current
1386 function's body where the tree can be modified e.g. by the
1388 if (ret != exp && TREE_STATIC (exp))
1389 ret = unshare_expr (ret);
1393 /* Print a warning if a constant expression had overflow in folding.
1394 Invoke this function on every expression that the language
1395 requires to be a constant expression.
1396 Note the ANSI C standard says it is erroneous for a
1397 constant expression to overflow. */
1400 constant_expression_warning (tree value)
1402 if (warn_overflow && pedantic
1403 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1404 || TREE_CODE (value) == FIXED_CST
1405 || TREE_CODE (value) == VECTOR_CST
1406 || TREE_CODE (value) == COMPLEX_CST)
1407 && TREE_OVERFLOW (value))
1408 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1411 /* The same as above but print an unconditional error. */
1413 constant_expression_error (tree value)
1415 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1416 || TREE_CODE (value) == FIXED_CST
1417 || TREE_CODE (value) == VECTOR_CST
1418 || TREE_CODE (value) == COMPLEX_CST)
1419 && TREE_OVERFLOW (value))
1420 error ("overflow in constant expression");
1423 /* Print a warning if an expression had overflow in folding and its
1426 Invoke this function on every expression that
1427 (1) appears in the source code, and
1428 (2) is a constant expression that overflowed, and
1429 (3) is not already checked by convert_and_check;
1430 however, do not invoke this function on operands of explicit casts
1431 or when the expression is the result of an operator and any operand
1432 already overflowed. */
1435 overflow_warning (location_t loc, tree value)
1437 if (c_inhibit_evaluation_warnings != 0)
1440 switch (TREE_CODE (value))
1443 warning_at (loc, OPT_Woverflow, "integer overflow in expression");
1447 warning_at (loc, OPT_Woverflow,
1448 "floating point overflow in expression");
1452 warning_at (loc, OPT_Woverflow, "fixed-point overflow in expression");
1456 warning_at (loc, OPT_Woverflow, "vector overflow in expression");
1460 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1461 warning_at (loc, OPT_Woverflow,
1462 "complex integer overflow in expression");
1463 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1464 warning_at (loc, OPT_Woverflow,
1465 "complex floating point overflow in expression");
1473 /* Warn about uses of logical || / && operator in a context where it
1474 is likely that the bitwise equivalent was intended by the
1475 programmer. We have seen an expression in which CODE is a binary
1476 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1477 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1479 warn_logical_operator (location_t location, enum tree_code code, tree type,
1480 enum tree_code code_left, tree op_left,
1481 enum tree_code ARG_UNUSED (code_right), tree op_right)
1483 int or_op = (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR);
1484 int in0_p, in1_p, in_p;
1485 tree low0, low1, low, high0, high1, high, lhs, rhs, tem;
1486 bool strict_overflow_p = false;
1488 if (code != TRUTH_ANDIF_EXPR
1489 && code != TRUTH_AND_EXPR
1490 && code != TRUTH_ORIF_EXPR
1491 && code != TRUTH_OR_EXPR)
1494 /* Warn if &&/|| are being used in a context where it is
1495 likely that the bitwise equivalent was intended by the
1496 programmer. That is, an expression such as op && MASK
1497 where op should not be any boolean expression, nor a
1498 constant, and mask seems to be a non-boolean integer constant. */
1499 if (!truth_value_p (code_left)
1500 && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1501 && !CONSTANT_CLASS_P (op_left)
1502 && !TREE_NO_WARNING (op_left)
1503 && TREE_CODE (op_right) == INTEGER_CST
1504 && !integer_zerop (op_right)
1505 && !integer_onep (op_right))
1508 warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1509 " applied to non-boolean constant");
1511 warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1512 " applied to non-boolean constant");
1513 TREE_NO_WARNING (op_left) = true;
1517 /* We do not warn for constants because they are typical of macro
1518 expansions that test for features. */
1519 if (CONSTANT_CLASS_P (op_left) || CONSTANT_CLASS_P (op_right))
1522 /* This warning only makes sense with logical operands. */
1523 if (!(truth_value_p (TREE_CODE (op_left))
1524 || INTEGRAL_TYPE_P (TREE_TYPE (op_left)))
1525 || !(truth_value_p (TREE_CODE (op_right))
1526 || INTEGRAL_TYPE_P (TREE_TYPE (op_right))))
1529 lhs = make_range (op_left, &in0_p, &low0, &high0, &strict_overflow_p);
1530 rhs = make_range (op_right, &in1_p, &low1, &high1, &strict_overflow_p);
1532 if (lhs && TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
1533 lhs = C_MAYBE_CONST_EXPR_EXPR (lhs);
1535 if (rhs && TREE_CODE (rhs) == C_MAYBE_CONST_EXPR)
1536 rhs = C_MAYBE_CONST_EXPR_EXPR (rhs);
1538 /* If this is an OR operation, invert both sides; we will invert
1539 again at the end. */
1541 in0_p = !in0_p, in1_p = !in1_p;
1543 /* If both expressions are the same, if we can merge the ranges, and we
1544 can build the range test, return it or it inverted. */
1545 if (lhs && rhs && operand_equal_p (lhs, rhs, 0)
1546 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
1548 && 0 != (tem = build_range_check (UNKNOWN_LOCATION,
1549 type, lhs, in_p, low, high)))
1551 if (TREE_CODE (tem) != INTEGER_CST)
1555 warning_at (location, OPT_Wlogical_op,
1557 "of collectively exhaustive tests is always true");
1559 warning_at (location, OPT_Wlogical_op,
1561 "of mutually exclusive tests is always false");
1566 /* Print a warning about casts that might indicate violation
1567 of strict aliasing rules if -Wstrict-aliasing is used and
1568 strict aliasing mode is in effect. OTYPE is the original
1569 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1572 strict_aliasing_warning (tree otype, tree type, tree expr)
1574 /* Strip pointer conversion chains and get to the correct original type. */
1576 otype = TREE_TYPE (expr);
1578 if (!(flag_strict_aliasing
1579 && POINTER_TYPE_P (type)
1580 && POINTER_TYPE_P (otype)
1581 && !VOID_TYPE_P (TREE_TYPE (type)))
1582 /* If the type we are casting to is a ref-all pointer
1583 dereferencing it is always valid. */
1584 || TYPE_REF_CAN_ALIAS_ALL (type))
1587 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1588 && (DECL_P (TREE_OPERAND (expr, 0))
1589 || handled_component_p (TREE_OPERAND (expr, 0))))
1591 /* Casting the address of an object to non void pointer. Warn
1592 if the cast breaks type based aliasing. */
1593 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1595 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1596 "might break strict-aliasing rules");
1601 /* warn_strict_aliasing >= 3. This includes the default (3).
1602 Only warn if the cast is dereferenced immediately. */
1603 alias_set_type set1 =
1604 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1605 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1607 if (set1 != set2 && set2 != 0
1608 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1610 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1611 "pointer will break strict-aliasing rules");
1614 else if (warn_strict_aliasing == 2
1615 && !alias_sets_must_conflict_p (set1, set2))
1617 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1618 "pointer might break strict-aliasing rules");
1624 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1626 /* At this level, warn for any conversions, even if an address is
1627 not taken in the same statement. This will likely produce many
1628 false positives, but could be useful to pinpoint problems that
1629 are not revealed at higher levels. */
1630 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1631 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1632 if (!COMPLETE_TYPE_P (type)
1633 || !alias_sets_must_conflict_p (set1, set2))
1635 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1636 "pointer might break strict-aliasing rules");
1644 /* Warn for unlikely, improbable, or stupid DECL declarations
1648 check_main_parameter_types (tree decl)
1653 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1654 args = TREE_CHAIN (args))
1656 tree type = args ? TREE_VALUE (args) : 0;
1658 if (type == void_type_node || type == error_mark_node )
1665 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1666 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1671 if (TREE_CODE (type) != POINTER_TYPE
1672 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1673 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1675 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1680 if (TREE_CODE (type) != POINTER_TYPE
1681 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1682 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1684 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1685 "%<char **%>", decl);
1690 /* It is intentional that this message does not mention the third
1691 argument because it's only mentioned in an appendix of the
1693 if (argct > 0 && (argct < 2 || argct > 3))
1694 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1697 /* True if pointers to distinct types T1 and T2 can be converted to
1698 each other without an explicit cast. Only returns true for opaque
1701 vector_targets_convertible_p (const_tree t1, const_tree t2)
1703 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1704 && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1705 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1711 /* True if vector types T1 and T2 can be converted to each other
1712 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1713 can only be converted with -flax-vector-conversions yet that is not
1714 in effect, emit a note telling the user about that option if such
1715 a note has not previously been emitted. */
1717 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1719 static bool emitted_lax_note = false;
1720 bool convertible_lax;
1722 if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1723 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1727 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1728 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1729 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1730 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1731 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1733 if (!convertible_lax || flag_lax_vector_conversions)
1734 return convertible_lax;
1736 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1737 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1740 if (emit_lax_note && !emitted_lax_note)
1742 emitted_lax_note = true;
1743 inform (input_location, "use -flax-vector-conversions to permit "
1744 "conversions between vectors with differing "
1745 "element types or numbers of subparts");
1751 /* This is a helper function of build_binary_op.
1753 For certain operations if both args were extended from the same
1754 smaller type, do the arithmetic in that type and then extend.
1756 BITWISE indicates a bitwise operation.
1757 For them, this optimization is safe only if
1758 both args are zero-extended or both are sign-extended.
1759 Otherwise, we might change the result.
1760 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1761 but calculated in (unsigned short) it would be (unsigned short)-1.
1763 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1765 int unsigned0, unsigned1;
1770 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1771 excessive narrowing when we call get_narrower below. For
1772 example, suppose that OP0 is of unsigned int extended
1773 from signed char and that RESULT_TYPE is long long int.
1774 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1777 (long long int) (unsigned int) signed_char
1779 which get_narrower would narrow down to
1781 (unsigned int) signed char
1783 If we do not cast OP0 first, get_narrower would return
1784 signed_char, which is inconsistent with the case of the
1786 op0 = convert (result_type, op0);
1787 op1 = convert (result_type, op1);
1789 arg0 = get_narrower (op0, &unsigned0);
1790 arg1 = get_narrower (op1, &unsigned1);
1792 /* UNS is 1 if the operation to be done is an unsigned one. */
1793 uns = TYPE_UNSIGNED (result_type);
1795 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1796 but it *requires* conversion to FINAL_TYPE. */
1798 if ((TYPE_PRECISION (TREE_TYPE (op0))
1799 == TYPE_PRECISION (TREE_TYPE (arg0)))
1800 && TREE_TYPE (op0) != result_type)
1801 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1802 if ((TYPE_PRECISION (TREE_TYPE (op1))
1803 == TYPE_PRECISION (TREE_TYPE (arg1)))
1804 && TREE_TYPE (op1) != result_type)
1805 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1807 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1809 /* For bitwise operations, signedness of nominal type
1810 does not matter. Consider only how operands were extended. */
1814 /* Note that in all three cases below we refrain from optimizing
1815 an unsigned operation on sign-extended args.
1816 That would not be valid. */
1818 /* Both args variable: if both extended in same way
1819 from same width, do it in that width.
1820 Do it unsigned if args were zero-extended. */
1821 if ((TYPE_PRECISION (TREE_TYPE (arg0))
1822 < TYPE_PRECISION (result_type))
1823 && (TYPE_PRECISION (TREE_TYPE (arg1))
1824 == TYPE_PRECISION (TREE_TYPE (arg0)))
1825 && unsigned0 == unsigned1
1826 && (unsigned0 || !uns))
1827 return c_common_signed_or_unsigned_type
1828 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1830 else if (TREE_CODE (arg0) == INTEGER_CST
1831 && (unsigned1 || !uns)
1832 && (TYPE_PRECISION (TREE_TYPE (arg1))
1833 < TYPE_PRECISION (result_type))
1835 = c_common_signed_or_unsigned_type (unsigned1,
1837 && !POINTER_TYPE_P (type)
1838 && int_fits_type_p (arg0, type))
1841 else if (TREE_CODE (arg1) == INTEGER_CST
1842 && (unsigned0 || !uns)
1843 && (TYPE_PRECISION (TREE_TYPE (arg0))
1844 < TYPE_PRECISION (result_type))
1846 = c_common_signed_or_unsigned_type (unsigned0,
1848 && !POINTER_TYPE_P (type)
1849 && int_fits_type_p (arg1, type))
1855 /* Warns if the conversion of EXPR to TYPE may alter a value.
1856 This is a helper function for warnings_for_convert_and_check. */
1859 conversion_warning (tree type, tree expr)
1861 bool give_warning = false;
1864 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
1865 tree expr_type = TREE_TYPE (expr);
1866 location_t loc = EXPR_LOC_OR_HERE (expr);
1868 if (!warn_conversion && !warn_sign_conversion)
1871 /* If any operand is artificial, then this expression was generated
1872 by the compiler and we do not warn. */
1873 for (i = 0; i < expr_num_operands; i++)
1875 tree op = TREE_OPERAND (expr, i);
1876 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
1880 switch (TREE_CODE (expr))
1888 case TRUTH_ANDIF_EXPR:
1889 case TRUTH_ORIF_EXPR:
1890 case TRUTH_AND_EXPR:
1892 case TRUTH_XOR_EXPR:
1893 case TRUTH_NOT_EXPR:
1894 /* Conversion from boolean to a signed:1 bit-field (which only
1895 can hold the values 0 and -1) doesn't lose information - but
1896 it does change the value. */
1897 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
1898 warning_at (loc, OPT_Wconversion,
1899 "conversion to %qT from boolean expression", type);
1905 /* Warn for real constant that is not an exact integer converted
1907 if (TREE_CODE (expr_type) == REAL_TYPE
1908 && TREE_CODE (type) == INTEGER_TYPE)
1910 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
1911 give_warning = true;
1913 /* Warn for an integer constant that does not fit into integer type. */
1914 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1915 && TREE_CODE (type) == INTEGER_TYPE
1916 && !int_fits_type_p (expr, type))
1918 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
1919 && tree_int_cst_sgn (expr) < 0)
1920 warning_at (loc, OPT_Wsign_conversion, "negative integer"
1921 " implicitly converted to unsigned type");
1922 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
1923 warning_at (loc, OPT_Wsign_conversion, "conversion of unsigned"
1924 " constant value to negative integer");
1926 give_warning = true;
1928 else if (TREE_CODE (type) == REAL_TYPE)
1930 /* Warn for an integer constant that does not fit into real type. */
1931 if (TREE_CODE (expr_type) == INTEGER_TYPE)
1933 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1934 if (!exact_real_truncate (TYPE_MODE (type), &a))
1935 give_warning = true;
1937 /* Warn for a real constant that does not fit into a smaller
1939 else if (TREE_CODE (expr_type) == REAL_TYPE
1940 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1942 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1943 if (!exact_real_truncate (TYPE_MODE (type), &a))
1944 give_warning = true;
1949 warning_at (loc, OPT_Wconversion,
1950 "conversion to %qT alters %qT constant value",
1957 /* In case of COND_EXPR, if both operands are constants or
1958 COND_EXPR, then we do not care about the type of COND_EXPR,
1959 only about the conversion of each operand. */
1960 tree op1 = TREE_OPERAND (expr, 1);
1961 tree op2 = TREE_OPERAND (expr, 2);
1963 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
1964 || TREE_CODE (op1) == COND_EXPR)
1965 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
1966 || TREE_CODE (op2) == COND_EXPR))
1968 conversion_warning (type, op1);
1969 conversion_warning (type, op2);
1975 default: /* 'expr' is not a constant. */
1977 /* Warn for real types converted to integer types. */
1978 if (TREE_CODE (expr_type) == REAL_TYPE
1979 && TREE_CODE (type) == INTEGER_TYPE)
1980 give_warning = true;
1982 else if (TREE_CODE (expr_type) == INTEGER_TYPE
1983 && TREE_CODE (type) == INTEGER_TYPE)
1985 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1986 expr = get_unwidened (expr, 0);
1987 expr_type = TREE_TYPE (expr);
1989 /* Don't warn for short y; short x = ((int)y & 0xff); */
1990 if (TREE_CODE (expr) == BIT_AND_EXPR
1991 || TREE_CODE (expr) == BIT_IOR_EXPR
1992 || TREE_CODE (expr) == BIT_XOR_EXPR)
1994 /* If both args were extended from a shortest type,
1995 use that type if that is safe. */
1996 expr_type = shorten_binary_op (expr_type,
1997 TREE_OPERAND (expr, 0),
1998 TREE_OPERAND (expr, 1),
2001 if (TREE_CODE (expr) == BIT_AND_EXPR)
2003 tree op0 = TREE_OPERAND (expr, 0);
2004 tree op1 = TREE_OPERAND (expr, 1);
2005 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2006 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2008 /* If one of the operands is a non-negative constant
2009 that fits in the target type, then the type of the
2010 other operand does not matter. */
2011 if ((TREE_CODE (op0) == INTEGER_CST
2012 && int_fits_type_p (op0, c_common_signed_type (type))
2013 && int_fits_type_p (op0, c_common_unsigned_type (type)))
2014 || (TREE_CODE (op1) == INTEGER_CST
2015 && int_fits_type_p (op1, c_common_signed_type (type))
2016 && int_fits_type_p (op1,
2017 c_common_unsigned_type (type))))
2019 /* If constant is unsigned and fits in the target
2020 type, then the result will also fit. */
2021 else if ((TREE_CODE (op0) == INTEGER_CST
2023 && int_fits_type_p (op0, type))
2024 || (TREE_CODE (op1) == INTEGER_CST
2026 && int_fits_type_p (op1, type)))
2030 /* Warn for integer types converted to smaller integer types. */
2031 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2032 give_warning = true;
2034 /* When they are the same width but different signedness,
2035 then the value may change. */
2036 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2037 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
2038 /* Even when converted to a bigger type, if the type is
2039 unsigned but expr is signed, then negative values
2041 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
2042 warning_at (loc, OPT_Wsign_conversion, "conversion to %qT from %qT "
2043 "may change the sign of the result",
2047 /* Warn for integer types converted to real types if and only if
2048 all the range of values of the integer type cannot be
2049 represented by the real type. */
2050 else if (TREE_CODE (expr_type) == INTEGER_TYPE
2051 && TREE_CODE (type) == REAL_TYPE)
2053 tree type_low_bound, type_high_bound;
2054 REAL_VALUE_TYPE real_low_bound, real_high_bound;
2056 /* Don't warn about char y = 0xff; float x = (int) y; */
2057 expr = get_unwidened (expr, 0);
2058 expr_type = TREE_TYPE (expr);
2060 type_low_bound = TYPE_MIN_VALUE (expr_type);
2061 type_high_bound = TYPE_MAX_VALUE (expr_type);
2062 real_low_bound = real_value_from_int_cst (0, type_low_bound);
2063 real_high_bound = real_value_from_int_cst (0, type_high_bound);
2065 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2066 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2067 give_warning = true;
2070 /* Warn for real types converted to smaller real types. */
2071 else if (TREE_CODE (expr_type) == REAL_TYPE
2072 && TREE_CODE (type) == REAL_TYPE
2073 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2074 give_warning = true;
2078 warning_at (loc, OPT_Wconversion,
2079 "conversion to %qT from %qT may alter its value",
2084 /* Produce warnings after a conversion. RESULT is the result of
2085 converting EXPR to TYPE. This is a helper function for
2086 convert_and_check and cp_convert_and_check. */
2089 warnings_for_convert_and_check (tree type, tree expr, tree result)
2091 if (TREE_CODE (expr) == INTEGER_CST
2092 && (TREE_CODE (type) == INTEGER_TYPE
2093 || TREE_CODE (type) == ENUMERAL_TYPE)
2094 && !int_fits_type_p (expr, type))
2096 /* Do not diagnose overflow in a constant expression merely
2097 because a conversion overflowed. */
2098 if (TREE_OVERFLOW (result))
2099 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2101 if (TYPE_UNSIGNED (type))
2103 /* This detects cases like converting -129 or 256 to
2105 if (!int_fits_type_p (expr, c_common_signed_type (type)))
2106 warning (OPT_Woverflow,
2107 "large integer implicitly truncated to unsigned type");
2109 conversion_warning (type, expr);
2111 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
2112 warning (OPT_Woverflow,
2113 "overflow in implicit constant conversion");
2114 /* No warning for converting 0x80000000 to int. */
2116 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2117 || TYPE_PRECISION (TREE_TYPE (expr))
2118 != TYPE_PRECISION (type)))
2119 warning (OPT_Woverflow,
2120 "overflow in implicit constant conversion");
2123 conversion_warning (type, expr);
2125 else if ((TREE_CODE (result) == INTEGER_CST
2126 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
2127 warning (OPT_Woverflow,
2128 "overflow in implicit constant conversion");
2130 conversion_warning (type, expr);
2134 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2135 Invoke this function on every expression that is converted implicitly,
2136 i.e. because of language rules and not because of an explicit cast. */
2139 convert_and_check (tree type, tree expr)
2142 tree expr_for_warning;
2144 /* Convert from a value with possible excess precision rather than
2145 via the semantic type, but do not warn about values not fitting
2146 exactly in the semantic type. */
2147 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2149 tree orig_type = TREE_TYPE (expr);
2150 expr = TREE_OPERAND (expr, 0);
2151 expr_for_warning = convert (orig_type, expr);
2152 if (orig_type == type)
2153 return expr_for_warning;
2156 expr_for_warning = expr;
2158 if (TREE_TYPE (expr) == type)
2161 result = convert (type, expr);
2163 if (c_inhibit_evaluation_warnings == 0
2164 && !TREE_OVERFLOW_P (expr)
2165 && result != error_mark_node)
2166 warnings_for_convert_and_check (type, expr_for_warning, result);
2171 /* A node in a list that describes references to variables (EXPR), which are
2172 either read accesses if WRITER is zero, or write accesses, in which case
2173 WRITER is the parent of EXPR. */
2180 /* Used to implement a cache the results of a call to verify_tree. We only
2181 use this for SAVE_EXPRs. */
2184 struct tlist_cache *next;
2185 struct tlist *cache_before_sp;
2186 struct tlist *cache_after_sp;
2190 /* Obstack to use when allocating tlist structures, and corresponding
2192 static struct obstack tlist_obstack;
2193 static char *tlist_firstobj = 0;
2195 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2197 static struct tlist *warned_ids;
2198 /* SAVE_EXPRs need special treatment. We process them only once and then
2199 cache the results. */
2200 static struct tlist_cache *save_expr_cache;
2202 static void add_tlist (struct tlist **, struct tlist *, tree, int);
2203 static void merge_tlist (struct tlist **, struct tlist *, int);
2204 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2205 static int warning_candidate_p (tree);
2206 static bool candidate_equal_p (const_tree, const_tree);
2207 static void warn_for_collisions (struct tlist *);
2208 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2209 static struct tlist *new_tlist (struct tlist *, tree, tree);
2211 /* Create a new struct tlist and fill in its fields. */
2212 static struct tlist *
2213 new_tlist (struct tlist *next, tree t, tree writer)
2216 l = XOBNEW (&tlist_obstack, struct tlist);
2223 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2224 is nonnull, we ignore any node we find which has a writer equal to it. */
2227 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
2231 struct tlist *next = add->next;
2234 if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer))
2235 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2240 /* Merge the nodes of ADD into TO. This merging process is done so that for
2241 each variable that already exists in TO, no new node is added; however if
2242 there is a write access recorded in ADD, and an occurrence on TO is only
2243 a read access, then the occurrence in TO will be modified to record the
2247 merge_tlist (struct tlist **to, struct tlist *add, int copy)
2249 struct tlist **end = to;
2252 end = &(*end)->next;
2258 struct tlist *next = add->next;
2260 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
2261 if (candidate_equal_p (tmp2->expr, add->expr))
2265 tmp2->writer = add->writer;
2269 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2270 end = &(*end)->next;
2277 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2278 references in list LIST conflict with it, excluding reads if ONLY writers
2282 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2287 /* Avoid duplicate warnings. */
2288 for (tmp = warned_ids; tmp; tmp = tmp->next)
2289 if (candidate_equal_p (tmp->expr, written))
2294 if (candidate_equal_p (list->expr, written)
2295 && !candidate_equal_p (list->writer, writer)
2296 && (!only_writes || list->writer))
2298 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
2299 warning_at (EXPR_LOC_OR_HERE (writer),
2300 OPT_Wsequence_point, "operation on %qE may be undefined",
2307 /* Given a list LIST of references to variables, find whether any of these
2308 can cause conflicts due to missing sequence points. */
2311 warn_for_collisions (struct tlist *list)
2315 for (tmp = list; tmp; tmp = tmp->next)
2318 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2322 /* Return nonzero if X is a tree that can be verified by the sequence point
2325 warning_candidate_p (tree x)
2327 if (DECL_P (x) && DECL_ARTIFICIAL (x))
2330 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2331 (lvalue_p) crash on TRY/CATCH. */
2332 if (TREE_TYPE (x) == NULL_TREE || VOID_TYPE_P (TREE_TYPE (x)))
2338 /* No point to track non-const calls, they will never satisfy
2340 if (TREE_CODE (x) == CALL_EXPR && (call_expr_flags (x) & ECF_CONST) == 0)
2343 if (TREE_CODE (x) == STRING_CST)
2349 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2351 candidate_equal_p (const_tree x, const_tree y)
2353 return (x == y) || (x && y && operand_equal_p (x, y, 0));
2356 /* Walk the tree X, and record accesses to variables. If X is written by the
2357 parent tree, WRITER is the parent.
2358 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2359 expression or its only operand forces a sequence point, then everything up
2360 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2362 Once we return, we will have emitted warnings if any subexpression before
2363 such a sequence point could be undefined. On a higher level, however, the
2364 sequence point may not be relevant, and we'll merge the two lists.
2366 Example: (b++, a) + b;
2367 The call that processes the COMPOUND_EXPR will store the increment of B
2368 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2369 processes the PLUS_EXPR will need to merge the two lists so that
2370 eventually, all accesses end up on the same list (and we'll warn about the
2371 unordered subexpressions b++ and b.
2373 A note on merging. If we modify the former example so that our expression
2376 care must be taken not simply to add all three expressions into the final
2377 PNO_SP list. The function merge_tlist takes care of that by merging the
2378 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2379 way, so that no more than one access to B is recorded. */
2382 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2385 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2386 enum tree_code code;
2387 enum tree_code_class cl;
2389 /* X may be NULL if it is the operand of an empty statement expression
2395 code = TREE_CODE (x);
2396 cl = TREE_CODE_CLASS (code);
2398 if (warning_candidate_p (x))
2399 *pno_sp = new_tlist (*pno_sp, x, writer);
2407 case TRUTH_ANDIF_EXPR:
2408 case TRUTH_ORIF_EXPR:
2409 tmp_before = tmp_nosp = tmp_list3 = 0;
2410 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2411 warn_for_collisions (tmp_nosp);
2412 merge_tlist (pbefore_sp, tmp_before, 0);
2413 merge_tlist (pbefore_sp, tmp_nosp, 0);
2414 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2415 merge_tlist (pbefore_sp, tmp_list3, 0);
2419 tmp_before = tmp_list2 = 0;
2420 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2421 warn_for_collisions (tmp_list2);
2422 merge_tlist (pbefore_sp, tmp_before, 0);
2423 merge_tlist (pbefore_sp, tmp_list2, 1);
2425 tmp_list3 = tmp_nosp = 0;
2426 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2427 warn_for_collisions (tmp_nosp);
2428 merge_tlist (pbefore_sp, tmp_list3, 0);
2430 tmp_list3 = tmp_list2 = 0;
2431 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2432 warn_for_collisions (tmp_list2);
2433 merge_tlist (pbefore_sp, tmp_list3, 0);
2434 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2435 two first, to avoid warning for (a ? b++ : b++). */
2436 merge_tlist (&tmp_nosp, tmp_list2, 0);
2437 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2440 case PREDECREMENT_EXPR:
2441 case PREINCREMENT_EXPR:
2442 case POSTDECREMENT_EXPR:
2443 case POSTINCREMENT_EXPR:
2444 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2448 tmp_before = tmp_nosp = tmp_list3 = 0;
2449 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2450 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2451 /* Expressions inside the LHS are not ordered wrt. the sequence points
2452 in the RHS. Example:
2454 Despite the fact that the modification of "a" is in the before_sp
2455 list (tmp_before), it conflicts with the use of "a" in the LHS.
2456 We can handle this by adding the contents of tmp_list3
2457 to those of tmp_before, and redoing the collision warnings for that
2459 add_tlist (&tmp_before, tmp_list3, x, 1);
2460 warn_for_collisions (tmp_before);
2461 /* Exclude the LHS itself here; we first have to merge it into the
2462 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2463 didn't exclude the LHS, we'd get it twice, once as a read and once
2465 add_tlist (pno_sp, tmp_list3, x, 0);
2466 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2468 merge_tlist (pbefore_sp, tmp_before, 0);
2469 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2470 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2471 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2475 /* We need to warn about conflicts among arguments and conflicts between
2476 args and the function address. Side effects of the function address,
2477 however, are not ordered by the sequence point of the call. */
2479 call_expr_arg_iterator iter;
2481 tmp_before = tmp_nosp = 0;
2482 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2483 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2485 tmp_list2 = tmp_list3 = 0;
2486 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2487 merge_tlist (&tmp_list3, tmp_list2, 0);
2488 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2490 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2491 warn_for_collisions (tmp_before);
2492 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2497 /* Scan all the list, e.g. indices of multi dimensional array. */
2500 tmp_before = tmp_nosp = 0;
2501 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2502 merge_tlist (&tmp_nosp, tmp_before, 0);
2503 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2510 struct tlist_cache *t;
2511 for (t = save_expr_cache; t; t = t->next)
2512 if (candidate_equal_p (t->expr, x))
2517 t = XOBNEW (&tlist_obstack, struct tlist_cache);
2518 t->next = save_expr_cache;
2520 save_expr_cache = t;
2522 tmp_before = tmp_nosp = 0;
2523 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2524 warn_for_collisions (tmp_nosp);
2529 struct tlist *t = tmp_nosp;
2531 merge_tlist (&tmp_list3, t, 0);
2533 t->cache_before_sp = tmp_before;
2534 t->cache_after_sp = tmp_list3;
2536 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2537 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2542 x = TREE_OPERAND (x, 0);
2549 /* For other expressions, simply recurse on their operands.
2550 Manual tail recursion for unary expressions.
2551 Other non-expressions need not be processed. */
2552 if (cl == tcc_unary)
2554 x = TREE_OPERAND (x, 0);
2558 else if (IS_EXPR_CODE_CLASS (cl))
2561 int max = TREE_OPERAND_LENGTH (x);
2562 for (lp = 0; lp < max; lp++)
2564 tmp_before = tmp_nosp = 0;
2565 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2566 merge_tlist (&tmp_nosp, tmp_before, 0);
2567 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2574 /* Try to warn for undefined behavior in EXPR due to missing sequence
2578 verify_sequence_points (tree expr)
2580 struct tlist *before_sp = 0, *after_sp = 0;
2583 save_expr_cache = 0;
2584 if (tlist_firstobj == 0)
2586 gcc_obstack_init (&tlist_obstack);
2587 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2590 verify_tree (expr, &before_sp, &after_sp, 0);
2591 warn_for_collisions (after_sp);
2592 obstack_free (&tlist_obstack, tlist_firstobj);
2595 /* Validate the expression after `case' and apply default promotions. */
2598 check_case_value (tree value)
2600 if (value == NULL_TREE)
2603 if (TREE_CODE (value) == INTEGER_CST)
2604 /* Promote char or short to int. */
2605 value = perform_integral_promotions (value);
2606 else if (value != error_mark_node)
2608 error ("case label does not reduce to an integer constant");
2609 value = error_mark_node;
2612 constant_expression_warning (value);
2617 /* See if the case values LOW and HIGH are in the range of the original
2618 type (i.e. before the default conversion to int) of the switch testing
2620 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2621 the type before promoting it. CASE_LOW_P is a pointer to the lower
2622 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2623 if the case is not a case range.
2624 The caller has to make sure that we are not called with NULL for
2625 CASE_LOW_P (i.e. the default case).
2626 Returns true if the case label is in range of ORIG_TYPE (saturated or
2627 untouched) or false if the label is out of range. */
2630 check_case_bounds (tree type, tree orig_type,
2631 tree *case_low_p, tree *case_high_p)
2633 tree min_value, max_value;
2634 tree case_low = *case_low_p;
2635 tree case_high = case_high_p ? *case_high_p : case_low;
2637 /* If there was a problem with the original type, do nothing. */
2638 if (orig_type == error_mark_node)
2641 min_value = TYPE_MIN_VALUE (orig_type);
2642 max_value = TYPE_MAX_VALUE (orig_type);
2644 /* Case label is less than minimum for type. */
2645 if (tree_int_cst_compare (case_low, min_value) < 0
2646 && tree_int_cst_compare (case_high, min_value) < 0)
2648 warning (0, "case label value is less than minimum value for type");
2652 /* Case value is greater than maximum for type. */
2653 if (tree_int_cst_compare (case_low, max_value) > 0
2654 && tree_int_cst_compare (case_high, max_value) > 0)
2656 warning (0, "case label value exceeds maximum value for type");
2660 /* Saturate lower case label value to minimum. */
2661 if (tree_int_cst_compare (case_high, min_value) >= 0
2662 && tree_int_cst_compare (case_low, min_value) < 0)
2664 warning (0, "lower value in case label range"
2665 " less than minimum value for type");
2666 case_low = min_value;
2669 /* Saturate upper case label value to maximum. */
2670 if (tree_int_cst_compare (case_low, max_value) <= 0
2671 && tree_int_cst_compare (case_high, max_value) > 0)
2673 warning (0, "upper value in case label range"
2674 " exceeds maximum value for type");
2675 case_high = max_value;
2678 if (*case_low_p != case_low)
2679 *case_low_p = convert (type, case_low);
2680 if (case_high_p && *case_high_p != case_high)
2681 *case_high_p = convert (type, case_high);
2686 /* Return an integer type with BITS bits of precision,
2687 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2690 c_common_type_for_size (unsigned int bits, int unsignedp)
2692 if (bits == TYPE_PRECISION (integer_type_node))
2693 return unsignedp ? unsigned_type_node : integer_type_node;
2695 if (bits == TYPE_PRECISION (signed_char_type_node))
2696 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2698 if (bits == TYPE_PRECISION (short_integer_type_node))
2699 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2701 if (bits == TYPE_PRECISION (long_integer_type_node))
2702 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2704 if (bits == TYPE_PRECISION (long_long_integer_type_node))
2705 return (unsignedp ? long_long_unsigned_type_node
2706 : long_long_integer_type_node);
2708 if (int128_integer_type_node
2709 && bits == TYPE_PRECISION (int128_integer_type_node))
2710 return (unsignedp ? int128_unsigned_type_node
2711 : int128_integer_type_node);
2713 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2714 return (unsignedp ? widest_unsigned_literal_type_node
2715 : widest_integer_literal_type_node);
2717 if (bits <= TYPE_PRECISION (intQI_type_node))
2718 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2720 if (bits <= TYPE_PRECISION (intHI_type_node))
2721 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2723 if (bits <= TYPE_PRECISION (intSI_type_node))
2724 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2726 if (bits <= TYPE_PRECISION (intDI_type_node))
2727 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2732 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2733 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2734 and saturating if SATP is nonzero, otherwise not saturating. */
2737 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2738 int unsignedp, int satp)
2740 enum machine_mode mode;
2742 mode = unsignedp ? UQQmode : QQmode;
2744 mode = unsignedp ? UHAmode : HAmode;
2746 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2747 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2750 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2752 sorry ("GCC cannot support operators with integer types and "
2753 "fixed-point types that have too many integral and "
2754 "fractional bits together");
2758 return c_common_type_for_mode (mode, satp);
2761 /* Used for communication between c_common_type_for_mode and
2762 c_register_builtin_type. */
2763 static GTY(()) tree registered_builtin_types;
2765 /* Return a data type that has machine mode MODE.
2766 If the mode is an integer,
2767 then UNSIGNEDP selects between signed and unsigned types.
2768 If the mode is a fixed-point mode,
2769 then UNSIGNEDP selects between saturating and nonsaturating types. */
2772 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2776 if (mode == TYPE_MODE (integer_type_node))
2777 return unsignedp ? unsigned_type_node : integer_type_node;
2779 if (mode == TYPE_MODE (signed_char_type_node))
2780 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2782 if (mode == TYPE_MODE (short_integer_type_node))
2783 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2785 if (mode == TYPE_MODE (long_integer_type_node))
2786 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2788 if (mode == TYPE_MODE (long_long_integer_type_node))
2789 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2791 if (int128_integer_type_node
2792 && mode == TYPE_MODE (int128_integer_type_node))
2793 return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
2795 if (mode == TYPE_MODE (widest_integer_literal_type_node))
2796 return unsignedp ? widest_unsigned_literal_type_node
2797 : widest_integer_literal_type_node;
2800 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2803 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2806 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2809 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2811 #if HOST_BITS_PER_WIDE_INT >= 64
2812 if (mode == TYPE_MODE (intTI_type_node))
2813 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2816 if (mode == TYPE_MODE (float_type_node))
2817 return float_type_node;
2819 if (mode == TYPE_MODE (double_type_node))
2820 return double_type_node;
2822 if (mode == TYPE_MODE (long_double_type_node))
2823 return long_double_type_node;
2825 if (mode == TYPE_MODE (void_type_node))
2826 return void_type_node;
2828 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2830 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2831 : make_signed_type (GET_MODE_PRECISION (mode)));
2833 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2835 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2836 : make_signed_type (GET_MODE_PRECISION (mode)));
2838 if (COMPLEX_MODE_P (mode))
2840 enum machine_mode inner_mode;
2843 if (mode == TYPE_MODE (complex_float_type_node))
2844 return complex_float_type_node;
2845 if (mode == TYPE_MODE (complex_double_type_node))
2846 return complex_double_type_node;
2847 if (mode == TYPE_MODE (complex_long_double_type_node))
2848 return complex_long_double_type_node;
2850 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2851 return complex_integer_type_node;
2853 inner_mode = GET_MODE_INNER (mode);
2854 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2855 if (inner_type != NULL_TREE)
2856 return build_complex_type (inner_type);
2858 else if (VECTOR_MODE_P (mode))
2860 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2861 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2862 if (inner_type != NULL_TREE)
2863 return build_vector_type_for_mode (inner_type, mode);
2866 if (mode == TYPE_MODE (dfloat32_type_node))
2867 return dfloat32_type_node;
2868 if (mode == TYPE_MODE (dfloat64_type_node))
2869 return dfloat64_type_node;
2870 if (mode == TYPE_MODE (dfloat128_type_node))
2871 return dfloat128_type_node;
2873 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2875 if (mode == TYPE_MODE (short_fract_type_node))
2876 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2877 if (mode == TYPE_MODE (fract_type_node))
2878 return unsignedp ? sat_fract_type_node : fract_type_node;
2879 if (mode == TYPE_MODE (long_fract_type_node))
2880 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2881 if (mode == TYPE_MODE (long_long_fract_type_node))
2882 return unsignedp ? sat_long_long_fract_type_node
2883 : long_long_fract_type_node;
2885 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2886 return unsignedp ? sat_unsigned_short_fract_type_node
2887 : unsigned_short_fract_type_node;
2888 if (mode == TYPE_MODE (unsigned_fract_type_node))
2889 return unsignedp ? sat_unsigned_fract_type_node
2890 : unsigned_fract_type_node;
2891 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2892 return unsignedp ? sat_unsigned_long_fract_type_node
2893 : unsigned_long_fract_type_node;
2894 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2895 return unsignedp ? sat_unsigned_long_long_fract_type_node
2896 : unsigned_long_long_fract_type_node;
2898 if (mode == TYPE_MODE (short_accum_type_node))
2899 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2900 if (mode == TYPE_MODE (accum_type_node))
2901 return unsignedp ? sat_accum_type_node : accum_type_node;
2902 if (mode == TYPE_MODE (long_accum_type_node))
2903 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2904 if (mode == TYPE_MODE (long_long_accum_type_node))
2905 return unsignedp ? sat_long_long_accum_type_node
2906 : long_long_accum_type_node;
2908 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2909 return unsignedp ? sat_unsigned_short_accum_type_node
2910 : unsigned_short_accum_type_node;
2911 if (mode == TYPE_MODE (unsigned_accum_type_node))
2912 return unsignedp ? sat_unsigned_accum_type_node
2913 : unsigned_accum_type_node;
2914 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2915 return unsignedp ? sat_unsigned_long_accum_type_node
2916 : unsigned_long_accum_type_node;
2917 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2918 return unsignedp ? sat_unsigned_long_long_accum_type_node
2919 : unsigned_long_long_accum_type_node;
2922 return unsignedp ? sat_qq_type_node : qq_type_node;
2924 return unsignedp ? sat_hq_type_node : hq_type_node;
2926 return unsignedp ? sat_sq_type_node : sq_type_node;
2928 return unsignedp ? sat_dq_type_node : dq_type_node;
2930 return unsignedp ? sat_tq_type_node : tq_type_node;
2932 if (mode == UQQmode)
2933 return unsignedp ? sat_uqq_type_node : uqq_type_node;
2934 if (mode == UHQmode)
2935 return unsignedp ? sat_uhq_type_node : uhq_type_node;
2936 if (mode == USQmode)
2937 return unsignedp ? sat_usq_type_node : usq_type_node;
2938 if (mode == UDQmode)
2939 return unsignedp ? sat_udq_type_node : udq_type_node;
2940 if (mode == UTQmode)
2941 return unsignedp ? sat_utq_type_node : utq_type_node;
2944 return unsignedp ? sat_ha_type_node : ha_type_node;
2946 return unsignedp ? sat_sa_type_node : sa_type_node;
2948 return unsignedp ? sat_da_type_node : da_type_node;
2950 return unsignedp ? sat_ta_type_node : ta_type_node;
2952 if (mode == UHAmode)
2953 return unsignedp ? sat_uha_type_node : uha_type_node;
2954 if (mode == USAmode)
2955 return unsignedp ? sat_usa_type_node : usa_type_node;
2956 if (mode == UDAmode)
2957 return unsignedp ? sat_uda_type_node : uda_type_node;
2958 if (mode == UTAmode)
2959 return unsignedp ? sat_uta_type_node : uta_type_node;
2962 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2963 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2964 return TREE_VALUE (t);
2970 c_common_unsigned_type (tree type)
2972 return c_common_signed_or_unsigned_type (1, type);
2975 /* Return a signed type the same as TYPE in other respects. */
2978 c_common_signed_type (tree type)
2980 return c_common_signed_or_unsigned_type (0, type);
2983 /* Return a type the same as TYPE except unsigned or
2984 signed according to UNSIGNEDP. */
2987 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2991 /* This block of code emulates the behavior of the old
2992 c_common_unsigned_type. In particular, it returns
2993 long_unsigned_type_node if passed a long, even when a int would
2994 have the same size. This is necessary for warnings to work
2995 correctly in archs where sizeof(int) == sizeof(long) */
2997 type1 = TYPE_MAIN_VARIANT (type);
2998 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2999 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3000 if (type1 == integer_type_node || type1 == unsigned_type_node)
3001 return unsignedp ? unsigned_type_node : integer_type_node;
3002 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3003 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3004 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3005 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3006 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3007 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3008 if (int128_integer_type_node
3009 && (type1 == int128_integer_type_node
3010 || type1 == int128_unsigned_type_node))
3011 return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
3012 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3013 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3014 #if HOST_BITS_PER_WIDE_INT >= 64
3015 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3016 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3018 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3019 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3020 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3021 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3022 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3023 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3024 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3025 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3027 #define C_COMMON_FIXED_TYPES(NAME) \
3028 if (type1 == short_ ## NAME ## _type_node \
3029 || type1 == unsigned_short_ ## NAME ## _type_node) \
3030 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3031 : short_ ## NAME ## _type_node; \
3032 if (type1 == NAME ## _type_node \
3033 || type1 == unsigned_ ## NAME ## _type_node) \
3034 return unsignedp ? unsigned_ ## NAME ## _type_node \
3035 : NAME ## _type_node; \
3036 if (type1 == long_ ## NAME ## _type_node \
3037 || type1 == unsigned_long_ ## NAME ## _type_node) \
3038 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3039 : long_ ## NAME ## _type_node; \
3040 if (type1 == long_long_ ## NAME ## _type_node \
3041 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3042 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3043 : long_long_ ## NAME ## _type_node;
3045 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3046 if (type1 == NAME ## _type_node \
3047 || type1 == u ## NAME ## _type_node) \
3048 return unsignedp ? u ## NAME ## _type_node \
3049 : NAME ## _type_node;
3051 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3052 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3053 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3054 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3055 : sat_ ## short_ ## NAME ## _type_node; \
3056 if (type1 == sat_ ## NAME ## _type_node \
3057 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3058 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3059 : sat_ ## NAME ## _type_node; \
3060 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3061 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3062 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3063 : sat_ ## long_ ## NAME ## _type_node; \
3064 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3065 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3066 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3067 : sat_ ## long_long_ ## NAME ## _type_node;
3069 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3070 if (type1 == sat_ ## NAME ## _type_node \
3071 || type1 == sat_ ## u ## NAME ## _type_node) \
3072 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3073 : sat_ ## NAME ## _type_node;
3075 C_COMMON_FIXED_TYPES (fract);
3076 C_COMMON_FIXED_TYPES_SAT (fract);
3077 C_COMMON_FIXED_TYPES (accum);
3078 C_COMMON_FIXED_TYPES_SAT (accum);
3080 C_COMMON_FIXED_MODE_TYPES (qq);
3081 C_COMMON_FIXED_MODE_TYPES (hq);
3082 C_COMMON_FIXED_MODE_TYPES (sq);
3083 C_COMMON_FIXED_MODE_TYPES (dq);
3084 C_COMMON_FIXED_MODE_TYPES (tq);
3085 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3086 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3087 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3088 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3089 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3090 C_COMMON_FIXED_MODE_TYPES (ha);
3091 C_COMMON_FIXED_MODE_TYPES (sa);
3092 C_COMMON_FIXED_MODE_TYPES (da);
3093 C_COMMON_FIXED_MODE_TYPES (ta);
3094 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3095 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3096 C_COMMON_FIXED_MODE_TYPES_SAT (da);
3097 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3099 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3100 the precision; they have precision set to match their range, but
3101 may use a wider mode to match an ABI. If we change modes, we may
3102 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3103 the precision as well, so as to yield correct results for
3104 bit-field types. C++ does not have these separate bit-field
3105 types, and producing a signed or unsigned variant of an
3106 ENUMERAL_TYPE may cause other problems as well. */
3108 if (!INTEGRAL_TYPE_P (type)
3109 || TYPE_UNSIGNED (type) == unsignedp)
3112 #define TYPE_OK(node) \
3113 (TYPE_MODE (type) == TYPE_MODE (node) \
3114 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3115 if (TYPE_OK (signed_char_type_node))
3116 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3117 if (TYPE_OK (integer_type_node))
3118 return unsignedp ? unsigned_type_node : integer_type_node;
3119 if (TYPE_OK (short_integer_type_node))
3120 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3121 if (TYPE_OK (long_integer_type_node))
3122 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3123 if (TYPE_OK (long_long_integer_type_node))
3124 return (unsignedp ? long_long_unsigned_type_node
3125 : long_long_integer_type_node);
3126 if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
3127 return (unsignedp ? int128_unsigned_type_node
3128 : int128_integer_type_node);
3129 if (TYPE_OK (widest_integer_literal_type_node))
3130 return (unsignedp ? widest_unsigned_literal_type_node
3131 : widest_integer_literal_type_node);
3133 #if HOST_BITS_PER_WIDE_INT >= 64
3134 if (TYPE_OK (intTI_type_node))
3135 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3137 if (TYPE_OK (intDI_type_node))
3138 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3139 if (TYPE_OK (intSI_type_node))
3140 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3141 if (TYPE_OK (intHI_type_node))
3142 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3143 if (TYPE_OK (intQI_type_node))
3144 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3147 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3150 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3153 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3155 /* Extended integer types of the same width as a standard type have
3156 lesser rank, so those of the same width as int promote to int or
3157 unsigned int and are valid for printf formats expecting int or
3158 unsigned int. To avoid such special cases, avoid creating
3159 extended integer types for bit-fields if a standard integer type
3161 if (width == TYPE_PRECISION (integer_type_node))
3162 return unsignedp ? unsigned_type_node : integer_type_node;
3163 if (width == TYPE_PRECISION (signed_char_type_node))
3164 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3165 if (width == TYPE_PRECISION (short_integer_type_node))
3166 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3167 if (width == TYPE_PRECISION (long_integer_type_node))
3168 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3169 if (width == TYPE_PRECISION (long_long_integer_type_node))
3170 return (unsignedp ? long_long_unsigned_type_node
3171 : long_long_integer_type_node);
3172 if (int128_integer_type_node
3173 && width == TYPE_PRECISION (int128_integer_type_node))
3174 return (unsignedp ? int128_unsigned_type_node
3175 : int128_integer_type_node);
3176 return build_nonstandard_integer_type (width, unsignedp);
3179 /* The C version of the register_builtin_type langhook. */
3182 c_register_builtin_type (tree type, const char* name)
3186 decl = build_decl (UNKNOWN_LOCATION,
3187 TYPE_DECL, get_identifier (name), type);
3188 DECL_ARTIFICIAL (decl) = 1;
3189 if (!TYPE_NAME (type))
3190 TYPE_NAME (type) = decl;
3193 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3196 /* Print an error message for invalid operands to arith operation
3197 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3198 LOCATION is the location of the message. */
3201 binary_op_error (location_t location, enum tree_code code,
3202 tree type0, tree type1)
3209 opname = "+"; break;
3211 opname = "-"; break;
3213 opname = "*"; break;
3215 opname = "max"; break;
3217 opname = "min"; break;
3219 opname = "=="; break;
3221 opname = "!="; break;
3223 opname = "<="; break;
3225 opname = ">="; break;
3227 opname = "<"; break;
3229 opname = ">"; break;
3231 opname = "<<"; break;
3233 opname = ">>"; break;
3234 case TRUNC_MOD_EXPR:
3235 case FLOOR_MOD_EXPR:
3236 opname = "%"; break;
3237 case TRUNC_DIV_EXPR:
3238 case FLOOR_DIV_EXPR:
3239 opname = "/"; break;
3241 opname = "&"; break;
3243 opname = "|"; break;
3244 case TRUTH_ANDIF_EXPR:
3245 opname = "&&"; break;
3246 case TRUTH_ORIF_EXPR:
3247 opname = "||"; break;
3249 opname = "^"; break;
3254 "invalid operands to binary %s (have %qT and %qT)", opname,
3258 /* Subroutine of build_binary_op, used for comparison operations.
3259 See if the operands have both been converted from subword integer types
3260 and, if so, perhaps change them both back to their original type.
3261 This function is also responsible for converting the two operands
3262 to the proper common type for comparison.
3264 The arguments of this function are all pointers to local variables
3265 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3266 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3268 If this function returns nonzero, it means that the comparison has
3269 a constant value. What this function returns is an expression for
3273 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3274 enum tree_code *rescode_ptr)
3277 tree op0 = *op0_ptr;
3278 tree op1 = *op1_ptr;
3279 int unsignedp0, unsignedp1;
3281 tree primop0, primop1;
3282 enum tree_code code = *rescode_ptr;
3284 /* Throw away any conversions to wider types
3285 already present in the operands. */
3287 primop0 = get_narrower (op0, &unsignedp0);
3288 primop1 = get_narrower (op1, &unsignedp1);
3290 /* Handle the case that OP0 does not *contain* a conversion
3291 but it *requires* conversion to FINAL_TYPE. */
3293 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3294 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3295 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3296 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3298 /* If one of the operands must be floated, we cannot optimize. */
3299 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3300 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3302 /* If first arg is constant, swap the args (changing operation
3303 so value is preserved), for canonicalization. Don't do this if
3304 the second arg is 0. */
3306 if (TREE_CONSTANT (primop0)
3307 && !integer_zerop (primop1) && !real_zerop (primop1)
3308 && !fixed_zerop (primop1))
3311 int temi = unsignedp0;
3319 unsignedp0 = unsignedp1;
3342 *rescode_ptr = code;
3345 /* If comparing an integer against a constant more bits wide,
3346 maybe we can deduce a value of 1 or 0 independent of the data.
3347 Or else truncate the constant now
3348 rather than extend the variable at run time.
3350 This is only interesting if the constant is the wider arg.
3351 Also, it is not safe if the constant is unsigned and the
3352 variable arg is signed, since in this case the variable
3353 would be sign-extended and then regarded as unsigned.
3354 Our technique fails in this case because the lowest/highest
3355 possible unsigned results don't follow naturally from the
3356 lowest/highest possible values of the variable operand.
3357 For just EQ_EXPR and NE_EXPR there is another technique that
3358 could be used: see if the constant can be faithfully represented
3359 in the other operand's type, by truncating it and reextending it
3360 and see if that preserves the constant's value. */
3362 if (!real1 && !real2
3363 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
3364 && TREE_CODE (primop1) == INTEGER_CST
3365 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3367 int min_gt, max_gt, min_lt, max_lt;
3368 tree maxval, minval;
3369 /* 1 if comparison is nominally unsigned. */
3370 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
3373 type = c_common_signed_or_unsigned_type (unsignedp0,
3374 TREE_TYPE (primop0));
3376 maxval = TYPE_MAX_VALUE (type);
3377 minval = TYPE_MIN_VALUE (type);
3379 if (unsignedp && !unsignedp0)
3380 *restype_ptr = c_common_signed_type (*restype_ptr);
3382 if (TREE_TYPE (primop1) != *restype_ptr)
3384 /* Convert primop1 to target type, but do not introduce
3385 additional overflow. We know primop1 is an int_cst. */
3386 primop1 = force_fit_type_double (*restype_ptr,
3387 tree_to_double_int (primop1),
3388 0, TREE_OVERFLOW (primop1));
3390 if (type != *restype_ptr)
3392 minval = convert (*restype_ptr, minval);
3393 maxval = convert (*restype_ptr, maxval);
3396 if (unsignedp && unsignedp0)
3398 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3399 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3400 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3401 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3405 min_gt = INT_CST_LT (primop1, minval);
3406 max_gt = INT_CST_LT (primop1, maxval);
3407 min_lt = INT_CST_LT (minval, primop1);
3408 max_lt = INT_CST_LT (maxval, primop1);
3412 /* This used to be a switch, but Genix compiler can't handle that. */
3413 if (code == NE_EXPR)
3415 if (max_lt || min_gt)
3416 val = truthvalue_true_node;
3418 else if (code == EQ_EXPR)
3420 if (max_lt || min_gt)
3421 val = truthvalue_false_node;
3423 else if (code == LT_EXPR)
3426 val = truthvalue_true_node;
3428 val = truthvalue_false_node;
3430 else if (code == GT_EXPR)
3433 val = truthvalue_true_node;
3435 val = truthvalue_false_node;
3437 else if (code == LE_EXPR)
3440 val = truthvalue_true_node;
3442 val = truthvalue_false_node;
3444 else if (code == GE_EXPR)
3447 val = truthvalue_true_node;
3449 val = truthvalue_false_node;
3452 /* If primop0 was sign-extended and unsigned comparison specd,
3453 we did a signed comparison above using the signed type bounds.
3454 But the comparison we output must be unsigned.
3456 Also, for inequalities, VAL is no good; but if the signed
3457 comparison had *any* fixed result, it follows that the
3458 unsigned comparison just tests the sign in reverse
3459 (positive values are LE, negative ones GE).
3460 So we can generate an unsigned comparison
3461 against an extreme value of the signed type. */
3463 if (unsignedp && !unsignedp0)
3470 primop1 = TYPE_MIN_VALUE (type);
3476 primop1 = TYPE_MAX_VALUE (type);
3483 type = c_common_unsigned_type (type);
3486 if (TREE_CODE (primop0) != INTEGER_CST)
3488 if (val == truthvalue_false_node)
3489 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3490 if (val == truthvalue_true_node)
3491 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3496 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3497 if (TREE_SIDE_EFFECTS (primop0))
3498 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3502 /* Value is not predetermined, but do the comparison
3503 in the type of the operand that is not constant.
3504 TYPE is already properly set. */
3507 /* If either arg is decimal float and the other is float, find the
3508 proper common type to use for comparison. */
3509 else if (real1 && real2
3510 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3511 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3512 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3514 else if (real1 && real2
3515 && (TYPE_PRECISION (TREE_TYPE (primop0))
3516 == TYPE_PRECISION (TREE_TYPE (primop1))))
3517 type = TREE_TYPE (primop0);
3519 /* If args' natural types are both narrower than nominal type
3520 and both extend in the same manner, compare them
3521 in the type of the wider arg.
3522 Otherwise must actually extend both to the nominal
3523 common type lest different ways of extending
3525 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3527 else if (unsignedp0 == unsignedp1 && real1 == real2
3528 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3529 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3531 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3532 type = c_common_signed_or_unsigned_type (unsignedp0
3533 || TYPE_UNSIGNED (*restype_ptr),
3535 /* Make sure shorter operand is extended the right way
3536 to match the longer operand. */
3538 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3539 TREE_TYPE (primop0)),
3542 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3543 TREE_TYPE (primop1)),
3548 /* Here we must do the comparison on the nominal type
3549 using the args exactly as we received them. */
3550 type = *restype_ptr;
3554 if (!real1 && !real2 && integer_zerop (primop1)
3555 && TYPE_UNSIGNED (*restype_ptr))
3561 /* All unsigned values are >= 0, so we warn. However,
3562 if OP0 is a constant that is >= 0, the signedness of
3563 the comparison isn't an issue, so suppress the
3565 if (warn_type_limits && !in_system_header
3566 && !(TREE_CODE (primop0) == INTEGER_CST
3567 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3569 warning (OPT_Wtype_limits,
3570 "comparison of unsigned expression >= 0 is always true");
3571 value = truthvalue_true_node;
3575 if (warn_type_limits && !in_system_header
3576 && !(TREE_CODE (primop0) == INTEGER_CST
3577 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3579 warning (OPT_Wtype_limits,
3580 "comparison of unsigned expression < 0 is always false");
3581 value = truthvalue_false_node;
3590 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3591 if (TREE_SIDE_EFFECTS (primop0))
3592 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3599 *op0_ptr = convert (type, primop0);
3600 *op1_ptr = convert (type, primop1);
3602 *restype_ptr = truthvalue_type_node;
3607 /* Return a tree for the sum or difference (RESULTCODE says which)
3608 of pointer PTROP and integer INTOP. */
3611 pointer_int_sum (location_t loc, enum tree_code resultcode,
3612 tree ptrop, tree intop)
3616 /* The result is a pointer of the same type that is being added. */
3617 tree result_type = TREE_TYPE (ptrop);
3619 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3621 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3622 "pointer of type %<void *%> used in arithmetic");
3623 size_exp = integer_one_node;
3625 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3627 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3628 "pointer to a function used in arithmetic");
3629 size_exp = integer_one_node;
3631 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3633 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3634 "pointer to member function used in arithmetic");
3635 size_exp = integer_one_node;
3638 size_exp = size_in_bytes (TREE_TYPE (result_type));
3640 /* We are manipulating pointer values, so we don't need to warn
3641 about relying on undefined signed overflow. We disable the
3642 warning here because we use integer types so fold won't know that
3643 they are really pointers. */
3644 fold_defer_overflow_warnings ();
3646 /* If what we are about to multiply by the size of the elements
3647 contains a constant term, apply distributive law
3648 and multiply that constant term separately.
3649 This helps produce common subexpressions. */
3650 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3651 && !TREE_CONSTANT (intop)
3652 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3653 && TREE_CONSTANT (size_exp)
3654 /* If the constant comes from pointer subtraction,
3655 skip this optimization--it would cause an error. */
3656 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3657 /* If the constant is unsigned, and smaller than the pointer size,
3658 then we must skip this optimization. This is because it could cause
3659 an overflow error if the constant is negative but INTOP is not. */
3660 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3661 || (TYPE_PRECISION (TREE_TYPE (intop))
3662 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3664 enum tree_code subcode = resultcode;
3665 tree int_type = TREE_TYPE (intop);
3666 if (TREE_CODE (intop) == MINUS_EXPR)
3667 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3668 /* Convert both subexpression types to the type of intop,
3669 because weird cases involving pointer arithmetic
3670 can result in a sum or difference with different type args. */
3671 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3673 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3674 intop = convert (int_type, TREE_OPERAND (intop, 0));
3677 /* Convert the integer argument to a type the same size as sizetype
3678 so the multiply won't overflow spuriously. */
3679 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3680 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3681 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3682 TYPE_UNSIGNED (sizetype)), intop);
3684 /* Replace the integer argument with a suitable product by the object size.
3685 Do this multiplication as signed, then convert to the appropriate type
3686 for the pointer operation and disregard an overflow that occured only
3687 because of the sign-extension change in the latter conversion. */
3689 tree t = build_binary_op (loc,
3691 convert (TREE_TYPE (intop), size_exp), 1);
3692 intop = convert (sizetype, t);
3693 if (TREE_OVERFLOW_P (intop) && !TREE_OVERFLOW (t))
3694 intop = build_int_cst_wide (TREE_TYPE (intop), TREE_INT_CST_LOW (intop),
3695 TREE_INT_CST_HIGH (intop));
3698 /* Create the sum or difference. */
3699 if (resultcode == MINUS_EXPR)
3700 intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop);
3702 ret = fold_build2_loc (loc, POINTER_PLUS_EXPR, result_type, ptrop, intop);
3704 fold_undefer_and_ignore_overflow_warnings ();
3709 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3710 and if NON_CONST is known not to be permitted in an evaluated part
3711 of a constant expression. */
3714 c_wrap_maybe_const (tree expr, bool non_const)
3716 bool nowarning = TREE_NO_WARNING (expr);
3717 location_t loc = EXPR_LOCATION (expr);
3719 /* This should never be called for C++. */
3720 if (c_dialect_cxx ())
3723 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3724 STRIP_TYPE_NOPS (expr);
3725 expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3726 C_MAYBE_CONST_EXPR_NON_CONST (expr) = non_const;
3728 TREE_NO_WARNING (expr) = 1;
3729 protected_set_expr_location (expr, loc);
3734 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3735 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3736 around the SAVE_EXPR if needed so that c_fully_fold does not need
3737 to look inside SAVE_EXPRs. */
3740 c_save_expr (tree expr)
3742 bool maybe_const = true;
3743 if (c_dialect_cxx ())
3744 return save_expr (expr);
3745 expr = c_fully_fold (expr, false, &maybe_const);
3746 expr = save_expr (expr);
3748 expr = c_wrap_maybe_const (expr, true);
3752 /* Return whether EXPR is a declaration whose address can never be
3756 decl_with_nonnull_addr_p (const_tree expr)
3758 return (DECL_P (expr)
3759 && (TREE_CODE (expr) == PARM_DECL
3760 || TREE_CODE (expr) == LABEL_DECL
3761 || !DECL_WEAK (expr)));
3764 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3765 or for an `if' or `while' statement or ?..: exp. It should already
3766 have been validated to be of suitable type; otherwise, a bad
3767 diagnostic may result.
3769 The EXPR is located at LOCATION.
3771 This preparation consists of taking the ordinary
3772 representation of an expression expr and producing a valid tree
3773 boolean expression describing whether expr is nonzero. We could
3774 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3775 but we optimize comparisons, &&, ||, and !.
3777 The resulting type should always be `truthvalue_type_node'. */
3780 c_common_truthvalue_conversion (location_t location, tree expr)
3782 switch (TREE_CODE (expr))
3784 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
3785 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3786 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3787 case ORDERED_EXPR: case UNORDERED_EXPR:
3788 if (TREE_TYPE (expr) == truthvalue_type_node)
3790 expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3791 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3794 case TRUTH_ANDIF_EXPR:
3795 case TRUTH_ORIF_EXPR:
3796 case TRUTH_AND_EXPR:
3798 case TRUTH_XOR_EXPR:
3799 if (TREE_TYPE (expr) == truthvalue_type_node)
3801 expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3802 c_common_truthvalue_conversion (location,
3803 TREE_OPERAND (expr, 0)),
3804 c_common_truthvalue_conversion (location,
3805 TREE_OPERAND (expr, 1)));
3808 case TRUTH_NOT_EXPR:
3809 if (TREE_TYPE (expr) == truthvalue_type_node)
3811 expr = build1 (TREE_CODE (expr), truthvalue_type_node,
3812 c_common_truthvalue_conversion (location,
3813 TREE_OPERAND (expr, 0)));
3820 return integer_zerop (expr) ? truthvalue_false_node
3821 : truthvalue_true_node;
3824 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3825 ? truthvalue_true_node
3826 : truthvalue_false_node;
3829 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3830 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3831 ? truthvalue_true_node
3832 : truthvalue_false_node;
3835 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3840 tree inner = TREE_OPERAND (expr, 0);
3841 if (decl_with_nonnull_addr_p (inner))
3843 /* Common Ada/Pascal programmer's mistake. */
3844 warning_at (location,
3846 "the address of %qD will always evaluate as %<true%>",
3848 return truthvalue_true_node;
3854 expr = build_binary_op (EXPR_LOCATION (expr),
3855 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3856 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3857 c_common_truthvalue_conversion (location,
3858 TREE_OPERAND (expr, 0)),
3859 c_common_truthvalue_conversion (location,
3860 TREE_OPERAND (expr, 1)),
3867 case EXCESS_PRECISION_EXPR:
3868 /* These don't change whether an object is nonzero or zero. */
3869 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
3873 /* These don't change whether an object is zero or nonzero, but
3874 we can't ignore them if their second arg has side-effects. */
3875 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3877 expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
3878 TREE_OPERAND (expr, 1),
3879 c_common_truthvalue_conversion
3880 (location, TREE_OPERAND (expr, 0)));
3884 return c_common_truthvalue_conversion (location,
3885 TREE_OPERAND (expr, 0));
3888 /* Distribute the conversion into the arms of a COND_EXPR. */
3889 if (c_dialect_cxx ())
3891 expr = fold_build3_loc (location, COND_EXPR, truthvalue_type_node,
3892 TREE_OPERAND (expr, 0),
3893 c_common_truthvalue_conversion (location,
3896 c_common_truthvalue_conversion (location,
3903 /* Folding will happen later for C. */
3904 expr = build3 (COND_EXPR, truthvalue_type_node,
3905 TREE_OPERAND (expr, 0),
3906 c_common_truthvalue_conversion (location,
3907 TREE_OPERAND (expr, 1)),
3908 c_common_truthvalue_conversion (location,
3909 TREE_OPERAND (expr, 2)));
3914 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3915 since that affects how `default_conversion' will behave. */
3916 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3917 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3919 /* If this is widening the argument, we can ignore it. */
3920 if (TYPE_PRECISION (TREE_TYPE (expr))
3921 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3922 return c_common_truthvalue_conversion (location,
3923 TREE_OPERAND (expr, 0));
3927 if (!TREE_NO_WARNING (expr)
3928 && warn_parentheses)
3930 warning (OPT_Wparentheses,
3931 "suggest parentheses around assignment used as truth value");
3932 TREE_NO_WARNING (expr) = 1;
3940 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3942 tree t = c_save_expr (expr);
3943 expr = (build_binary_op
3944 (EXPR_LOCATION (expr),
3945 (TREE_SIDE_EFFECTS (expr)
3946 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3947 c_common_truthvalue_conversion
3949 build_unary_op (location, REALPART_EXPR, t, 0)),
3950 c_common_truthvalue_conversion
3952 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3957 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3959 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3961 (TREE_TYPE (expr))));
3962 return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
3965 return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
3968 protected_set_expr_location (expr, location);
3972 static void def_builtin_1 (enum built_in_function fncode,
3974 enum built_in_class fnclass,
3975 tree fntype, tree libtype,
3976 bool both_p, bool fallback_p, bool nonansi_p,
3977 tree fnattrs, bool implicit_p);
3980 /* Apply the TYPE_QUALS to the new DECL. */
3983 c_apply_type_quals_to_decl (int type_quals, tree decl)
3985 tree type = TREE_TYPE (decl);
3987 if (type == error_mark_node)
3990 if (((type_quals & TYPE_QUAL_CONST)
3991 || (type && TREE_CODE (type) == REFERENCE_TYPE))
3992 /* An object declared 'const' is only readonly after it is
3993 initialized. We don't have any way of expressing this currently,
3994 so we need to be conservative and unset TREE_READONLY for types
3995 with constructors. Otherwise aliasing code will ignore stores in
3996 an inline constructor. */
3997 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3998 TREE_READONLY (decl) = 1;
3999 if (type_quals & TYPE_QUAL_VOLATILE)
4001 TREE_SIDE_EFFECTS (decl) = 1;
4002 TREE_THIS_VOLATILE (decl) = 1;
4004 if (type_quals & TYPE_QUAL_RESTRICT)
4006 while (type && TREE_CODE (type) == ARRAY_TYPE)
4007 /* Allow 'restrict' on arrays of pointers.
4008 FIXME currently we just ignore it. */
4009 type = TREE_TYPE (type);
4011 || !POINTER_TYPE_P (type)
4012 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
4013 error ("invalid use of %<restrict%>");
4017 /* Hash function for the problem of multiple type definitions in
4018 different files. This must hash all types that will compare
4019 equal via comptypes to the same value. In practice it hashes
4020 on some of the simple stuff and leaves the details to comptypes. */
4023 c_type_hash (const void *p)
4027 const_tree const t = (const_tree) p;
4029 switch (TREE_CODE (t))
4031 /* For pointers, hash on pointee type plus some swizzling. */
4033 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4034 /* Hash on number of elements and total size. */
4037 t2 = TYPE_VALUES (t);
4041 t2 = TYPE_FIELDS (t);
4043 case QUAL_UNION_TYPE:
4045 t2 = TYPE_FIELDS (t);
4049 t2 = TYPE_FIELDS (t);
4054 for (; t2; t2 = DECL_CHAIN (t2))
4056 /* We might have a VLA here. */
4057 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4060 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
4061 return ((size << 24) | (i << shift));
4064 static GTY((param_is (union tree_node))) htab_t type_hash_table;
4066 /* Return the typed-based alias set for T, which may be an expression
4067 or a type. Return -1 if we don't do anything special. */
4070 c_common_get_alias_set (tree t)
4075 /* For VLAs, use the alias set of the element type rather than the
4076 default of alias set 0 for types compared structurally. */
4077 if (TYPE_P (t) && TYPE_STRUCTURAL_EQUALITY_P (t))
4079 if (TREE_CODE (t) == ARRAY_TYPE)
4080 return get_alias_set (TREE_TYPE (t));
4084 /* Permit type-punning when accessing a union, provided the access
4085 is directly through the union. For example, this code does not
4086 permit taking the address of a union member and then storing
4087 through it. Even the type-punning allowed here is a GCC
4088 extension, albeit a common and useful one; the C standard says
4089 that such accesses have implementation-defined behavior. */
4091 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4092 u = TREE_OPERAND (u, 0))
4093 if (TREE_CODE (u) == COMPONENT_REF
4094 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4097 /* That's all the expressions we handle specially. */
4101 /* The C standard guarantees that any object may be accessed via an
4102 lvalue that has character type. */
4103 if (t == char_type_node
4104 || t == signed_char_type_node
4105 || t == unsigned_char_type_node)
4108 /* The C standard specifically allows aliasing between signed and
4109 unsigned variants of the same type. We treat the signed
4110 variant as canonical. */
4111 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4113 tree t1 = c_common_signed_type (t);
4115 /* t1 == t can happen for boolean nodes which are always unsigned. */
4117 return get_alias_set (t1);
4120 /* Handle the case of multiple type nodes referring to "the same" type,
4121 which occurs with IMA. These share an alias set. FIXME: Currently only
4122 C90 is handled. (In C99 type compatibility is not transitive, which
4123 complicates things mightily. The alias set splay trees can theoretically
4124 represent this, but insertion is tricky when you consider all the
4125 different orders things might arrive in.) */
4127 if (c_language != clk_c || flag_isoc99)
4130 /* Save time if there's only one input file. */
4131 if (num_in_fnames == 1)
4134 /* Pointers need special handling if they point to any type that
4135 needs special handling (below). */
4136 if (TREE_CODE (t) == POINTER_TYPE)
4139 /* Find bottom type under any nested POINTERs. */
4140 for (t2 = TREE_TYPE (t);
4141 TREE_CODE (t2) == POINTER_TYPE;
4142 t2 = TREE_TYPE (t2))
4144 if (TREE_CODE (t2) != RECORD_TYPE
4145 && TREE_CODE (t2) != ENUMERAL_TYPE
4146 && TREE_CODE (t2) != QUAL_UNION_TYPE
4147 && TREE_CODE (t2) != UNION_TYPE)
4149 if (TYPE_SIZE (t2) == 0)
4152 /* These are the only cases that need special handling. */
4153 if (TREE_CODE (t) != RECORD_TYPE
4154 && TREE_CODE (t) != ENUMERAL_TYPE
4155 && TREE_CODE (t) != QUAL_UNION_TYPE
4156 && TREE_CODE (t) != UNION_TYPE
4157 && TREE_CODE (t) != POINTER_TYPE)
4160 if (TYPE_SIZE (t) == 0)
4163 /* Look up t in hash table. Only one of the compatible types within each
4164 alias set is recorded in the table. */
4165 if (!type_hash_table)
4166 type_hash_table = htab_create_ggc (1021, c_type_hash,
4167 (htab_eq) lang_hooks.types_compatible_p,
4169 slot = htab_find_slot (type_hash_table, t, INSERT);
4172 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4173 return TYPE_ALIAS_SET ((tree)*slot);
4176 /* Our caller will assign and record (in t) a new alias set; all we need
4177 to do is remember t in the hash table. */
4183 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4184 the second parameter indicates which OPERATOR is being applied.
4185 The COMPLAIN flag controls whether we should diagnose possibly
4186 ill-formed constructs or not. LOC is the location of the SIZEOF or
4190 c_sizeof_or_alignof_type (location_t loc,
4191 tree type, bool is_sizeof, int complain)
4193 const char *op_name;
4195 enum tree_code type_code = TREE_CODE (type);
4197 op_name = is_sizeof ? "sizeof" : "__alignof__";
4199 if (type_code == FUNCTION_TYPE)
4203 if (complain && (pedantic || warn_pointer_arith))
4204 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4205 "invalid application of %<sizeof%> to a function type");
4207 return error_mark_node;
4208 value = size_one_node;
4211 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4213 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4215 if (type_code == VOID_TYPE
4216 && complain && (pedantic || warn_pointer_arith))
4217 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4218 "invalid application of %qs to a void type", op_name);
4220 return error_mark_node;
4221 value = size_one_node;
4223 else if (!COMPLETE_TYPE_P (type))
4226 error_at (loc, "invalid application of %qs to incomplete type %qT ",
4228 return error_mark_node;
4233 /* Convert in case a char is more than one unit. */
4234 value = size_binop_loc (loc, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4235 size_int (TYPE_PRECISION (char_type_node)
4238 value = size_int (TYPE_ALIGN_UNIT (type));
4241 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4242 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4243 never happen. However, this node should really have type
4244 `size_t', which is just a typedef for an ordinary integer type. */
4245 value = fold_convert_loc (loc, size_type_node, value);
4246 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
4251 /* Implement the __alignof keyword: Return the minimum required
4252 alignment of EXPR, measured in bytes. For VAR_DECLs,
4253 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4254 from an "aligned" __attribute__ specification). LOC is the
4255 location of the ALIGNOF operator. */
4258 c_alignof_expr (location_t loc, tree expr)
4262 if (VAR_OR_FUNCTION_DECL_P (expr))
4263 t = size_int (DECL_ALIGN_UNIT (expr));
4265 else if (TREE_CODE (expr) == COMPONENT_REF
4266 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4268 error_at (loc, "%<__alignof%> applied to a bit-field");
4271 else if (TREE_CODE (expr) == COMPONENT_REF
4272 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
4273 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
4275 else if (TREE_CODE (expr) == INDIRECT_REF)
4277 tree t = TREE_OPERAND (expr, 0);
4279 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4281 while (CONVERT_EXPR_P (t)
4282 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
4286 t = TREE_OPERAND (t, 0);
4287 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4288 if (thisalign > bestalign)
4289 best = t, bestalign = thisalign;
4291 return c_alignof (loc, TREE_TYPE (TREE_TYPE (best)));
4294 return c_alignof (loc, TREE_TYPE (expr));
4296 return fold_convert_loc (loc, size_type_node, t);
4299 /* Handle C and C++ default attributes. */
4301 enum built_in_attribute
4303 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4304 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4305 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4306 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4307 #include "builtin-attrs.def"
4308 #undef DEF_ATTR_NULL_TREE
4310 #undef DEF_ATTR_IDENT
4311 #undef DEF_ATTR_TREE_LIST
4315 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4317 static void c_init_attributes (void);
4321 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4322 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4323 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4324 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4325 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4326 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4327 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4328 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4329 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4330 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4331 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4332 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4333 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4334 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4335 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4337 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4338 #include "builtin-types.def"
4339 #undef DEF_PRIMITIVE_TYPE
4340 #undef DEF_FUNCTION_TYPE_0
4341 #undef DEF_FUNCTION_TYPE_1
4342 #undef DEF_FUNCTION_TYPE_2
4343 #undef DEF_FUNCTION_TYPE_3
4344 #undef DEF_FUNCTION_TYPE_4
4345 #undef DEF_FUNCTION_TYPE_5
4346 #undef DEF_FUNCTION_TYPE_6
4347 #undef DEF_FUNCTION_TYPE_7
4348 #undef DEF_FUNCTION_TYPE_VAR_0
4349 #undef DEF_FUNCTION_TYPE_VAR_1
4350 #undef DEF_FUNCTION_TYPE_VAR_2
4351 #undef DEF_FUNCTION_TYPE_VAR_3
4352 #undef DEF_FUNCTION_TYPE_VAR_4
4353 #undef DEF_FUNCTION_TYPE_VAR_5
4354 #undef DEF_POINTER_TYPE
4358 typedef enum c_builtin_type builtin_type;
4360 /* A temporary array for c_common_nodes_and_builtins. Used in
4361 communication with def_fn_type. */
4362 static tree builtin_types[(int) BT_LAST + 1];
4364 /* A helper function for c_common_nodes_and_builtins. Build function type
4365 for DEF with return type RET and N arguments. If VAR is true, then the
4366 function should be variadic after those N arguments.
4368 Takes special care not to ICE if any of the types involved are
4369 error_mark_node, which indicates that said type is not in fact available
4370 (see builtin_type_for_size). In which case the function type as a whole
4371 should be error_mark_node. */
4374 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4376 tree args = NULL, t;
4381 for (i = 0; i < n; ++i)
4383 builtin_type a = (builtin_type) va_arg (list, int);
4384 t = builtin_types[a];
4385 if (t == error_mark_node)
4387 args = tree_cons (NULL_TREE, t, args);
4391 args = nreverse (args);
4393 args = chainon (args, void_list_node);
4395 t = builtin_types[ret];
4396 if (t == error_mark_node)
4398 t = build_function_type (t, args);
4401 builtin_types[def] = t;
4404 /* Build builtin functions common to both C and C++ language
4408 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4410 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4411 builtin_types[ENUM] = VALUE;
4412 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4413 def_fn_type (ENUM, RETURN, 0, 0);
4414 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4415 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4416 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4417 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4418 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4419 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4420 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4421 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4422 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4423 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4424 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4426 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4427 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4429 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4430 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4431 def_fn_type (ENUM, RETURN, 1, 0);
4432 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4433 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4434 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4435 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4436 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4437 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4438 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4439 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4440 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4441 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4442 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4443 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4445 #include "builtin-types.def"
4447 #undef DEF_PRIMITIVE_TYPE
4448 #undef DEF_FUNCTION_TYPE_1
4449 #undef DEF_FUNCTION_TYPE_2
4450 #undef DEF_FUNCTION_TYPE_3
4451 #undef DEF_FUNCTION_TYPE_4
4452 #undef DEF_FUNCTION_TYPE_5
4453 #undef DEF_FUNCTION_TYPE_6
4454 #undef DEF_FUNCTION_TYPE_VAR_0
4455 #undef DEF_FUNCTION_TYPE_VAR_1
4456 #undef DEF_FUNCTION_TYPE_VAR_2
4457 #undef DEF_FUNCTION_TYPE_VAR_3
4458 #undef DEF_FUNCTION_TYPE_VAR_4
4459 #undef DEF_FUNCTION_TYPE_VAR_5
4460 #undef DEF_POINTER_TYPE
4461 builtin_types[(int) BT_LAST] = NULL_TREE;
4463 c_init_attributes ();
4465 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4466 NONANSI_P, ATTRS, IMPLICIT, COND) \
4468 def_builtin_1 (ENUM, NAME, CLASS, \
4469 builtin_types[(int) TYPE], \
4470 builtin_types[(int) LIBTYPE], \
4471 BOTH_P, FALLBACK_P, NONANSI_P, \
4472 built_in_attributes[(int) ATTRS], IMPLICIT);
4473 #include "builtins.def"
4476 targetm.init_builtins ();
4478 build_common_builtin_nodes ();
4484 /* Like get_identifier, but avoid warnings about null arguments when
4485 the argument may be NULL for targets where GCC lacks stdint.h type
4489 c_get_ident (const char *id)
4491 return get_identifier (id);
4494 /* Build tree nodes and builtin functions common to both C and C++ language
4498 c_common_nodes_and_builtins (void)
4500 int char16_type_size;
4501 int char32_type_size;
4502 int wchar_type_size;
4503 tree array_domain_type;
4504 tree va_list_ref_type_node;
4505 tree va_list_arg_type_node;
4507 /* Define `int' and `char' first so that dbx will output them first. */
4508 record_builtin_type (RID_INT, NULL, integer_type_node);
4509 record_builtin_type (RID_CHAR, "char", char_type_node);
4511 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4512 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4513 but not C. Are the conditionals here needed? */
4514 if (c_dialect_cxx ())
4515 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4516 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4517 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4518 record_builtin_type (RID_MAX, "long unsigned int",
4519 long_unsigned_type_node);
4520 if (int128_integer_type_node != NULL_TREE)
4522 record_builtin_type (RID_INT128, "__int128",
4523 int128_integer_type_node);
4524 record_builtin_type (RID_MAX, "__int128 unsigned",
4525 int128_unsigned_type_node);
4527 if (c_dialect_cxx ())
4528 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4529 record_builtin_type (RID_MAX, "long long int",
4530 long_long_integer_type_node);
4531 record_builtin_type (RID_MAX, "long long unsigned int",
4532 long_long_unsigned_type_node);
4533 if (c_dialect_cxx ())
4534 record_builtin_type (RID_MAX, "long long unsigned",
4535 long_long_unsigned_type_node);
4536 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4537 record_builtin_type (RID_MAX, "short unsigned int",
4538 short_unsigned_type_node);
4539 if (c_dialect_cxx ())
4540 record_builtin_type (RID_MAX, "unsigned short",
4541 short_unsigned_type_node);
4543 /* Define both `signed char' and `unsigned char'. */
4544 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4545 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4547 /* These are types that c_common_type_for_size and
4548 c_common_type_for_mode use. */
4549 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4550 TYPE_DECL, NULL_TREE,
4552 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4553 TYPE_DECL, NULL_TREE,
4555 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4556 TYPE_DECL, NULL_TREE,
4558 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4559 TYPE_DECL, NULL_TREE,
4561 #if HOST_BITS_PER_WIDE_INT >= 64
4562 if (targetm.scalar_mode_supported_p (TImode))
4563 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4565 get_identifier ("__int128_t"),
4568 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4569 TYPE_DECL, NULL_TREE,
4570 unsigned_intQI_type_node));
4571 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4572 TYPE_DECL, NULL_TREE,
4573 unsigned_intHI_type_node));
4574 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4575 TYPE_DECL, NULL_TREE,
4576 unsigned_intSI_type_node));
4577 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4578 TYPE_DECL, NULL_TREE,
4579 unsigned_intDI_type_node));
4580 #if HOST_BITS_PER_WIDE_INT >= 64
4581 if (targetm.scalar_mode_supported_p (TImode))
4582 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4584 get_identifier ("__uint128_t"),
4585 unsigned_intTI_type_node));
4588 /* Create the widest literal types. */
4589 widest_integer_literal_type_node
4590 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4591 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4592 TYPE_DECL, NULL_TREE,
4593 widest_integer_literal_type_node));
4595 widest_unsigned_literal_type_node
4596 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4597 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4598 TYPE_DECL, NULL_TREE,
4599 widest_unsigned_literal_type_node));
4601 /* `unsigned long' is the standard type for sizeof.
4602 Note that stddef.h uses `unsigned long',
4603 and this must agree, even if long and int are the same size. */
4605 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4606 signed_size_type_node = c_common_signed_type (size_type_node);
4607 set_sizetype (size_type_node);
4610 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4612 build_common_tree_nodes_2 (flag_short_double);
4614 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4615 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4616 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4618 /* Only supported decimal floating point extension if the target
4619 actually supports underlying modes. */
4620 if (targetm.scalar_mode_supported_p (SDmode)
4621 && targetm.scalar_mode_supported_p (DDmode)
4622 && targetm.scalar_mode_supported_p (TDmode))
4624 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4625 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4626 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4629 if (targetm.fixed_point_supported_p ())
4631 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4632 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4633 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4634 record_builtin_type (RID_MAX, "long long _Fract",
4635 long_long_fract_type_node);
4636 record_builtin_type (RID_MAX, "unsigned short _Fract",
4637 unsigned_short_fract_type_node);
4638 record_builtin_type (RID_MAX, "unsigned _Fract",
4639 unsigned_fract_type_node);
4640 record_builtin_type (RID_MAX, "unsigned long _Fract",
4641 unsigned_long_fract_type_node);
4642 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4643 unsigned_long_long_fract_type_node);
4644 record_builtin_type (RID_MAX, "_Sat short _Fract",
4645 sat_short_fract_type_node);
4646 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4647 record_builtin_type (RID_MAX, "_Sat long _Fract",
4648 sat_long_fract_type_node);
4649 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4650 sat_long_long_fract_type_node);
4651 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4652 sat_unsigned_short_fract_type_node);
4653 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4654 sat_unsigned_fract_type_node);
4655 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4656 sat_unsigned_long_fract_type_node);
4657 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4658 sat_unsigned_long_long_fract_type_node);
4659 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4660 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4661 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4662 record_builtin_type (RID_MAX, "long long _Accum",
4663 long_long_accum_type_node);
4664 record_builtin_type (RID_MAX, "unsigned short _Accum",
4665 unsigned_short_accum_type_node);
4666 record_builtin_type (RID_MAX, "unsigned _Accum",
4667 unsigned_accum_type_node);
4668 record_builtin_type (RID_MAX, "unsigned long _Accum",
4669 unsigned_long_accum_type_node);
4670 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4671 unsigned_long_long_accum_type_node);
4672 record_builtin_type (RID_MAX, "_Sat short _Accum",
4673 sat_short_accum_type_node);
4674 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4675 record_builtin_type (RID_MAX, "_Sat long _Accum",
4676 sat_long_accum_type_node);
4677 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4678 sat_long_long_accum_type_node);
4679 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4680 sat_unsigned_short_accum_type_node);
4681 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4682 sat_unsigned_accum_type_node);
4683 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4684 sat_unsigned_long_accum_type_node);
4685 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4686 sat_unsigned_long_long_accum_type_node);
4690 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4692 get_identifier ("complex int"),
4693 complex_integer_type_node));
4694 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4696 get_identifier ("complex float"),
4697 complex_float_type_node));
4698 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4700 get_identifier ("complex double"),
4701 complex_double_type_node));
4702 lang_hooks.decls.pushdecl
4703 (build_decl (UNKNOWN_LOCATION,
4704 TYPE_DECL, get_identifier ("complex long double"),
4705 complex_long_double_type_node));
4707 if (c_dialect_cxx ())
4708 /* For C++, make fileptr_type_node a distinct void * type until
4709 FILE type is defined. */
4710 fileptr_type_node = build_variant_type_copy (ptr_type_node);
4712 record_builtin_type (RID_VOID, NULL, void_type_node);
4714 /* Set the TYPE_NAME for any variants that were built before
4715 record_builtin_type gave names to the built-in types. */
4717 tree void_name = TYPE_NAME (void_type_node);
4718 TYPE_NAME (void_type_node) = NULL_TREE;
4719 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4721 TYPE_NAME (void_type_node) = void_name;
4724 /* This node must not be shared. */
4725 void_zero_node = make_node (INTEGER_CST);
4726 TREE_TYPE (void_zero_node) = void_type_node;
4728 void_list_node = build_void_list_node ();
4730 /* Make a type to be the domain of a few array types
4731 whose domains don't really matter.
4732 200 is small enough that it always fits in size_t
4733 and large enough that it can hold most function names for the
4734 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4735 array_domain_type = build_index_type (size_int (200));
4737 /* Make a type for arrays of characters.
4738 With luck nothing will ever really depend on the length of this
4740 char_array_type_node
4741 = build_array_type (char_type_node, array_domain_type);
4743 /* Likewise for arrays of ints. */
4745 = build_array_type (integer_type_node, array_domain_type);
4747 string_type_node = build_pointer_type (char_type_node);
4748 const_string_type_node
4749 = build_pointer_type (build_qualified_type
4750 (char_type_node, TYPE_QUAL_CONST));
4752 /* This is special for C++ so functions can be overloaded. */
4753 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4754 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4755 wchar_type_size = TYPE_PRECISION (wchar_type_node);
4756 underlying_wchar_type_node = wchar_type_node;
4757 if (c_dialect_cxx ())
4759 if (TYPE_UNSIGNED (wchar_type_node))
4760 wchar_type_node = make_unsigned_type (wchar_type_size);
4762 wchar_type_node = make_signed_type (wchar_type_size);
4763 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4766 /* This is for wide string constants. */
4767 wchar_array_type_node
4768 = build_array_type (wchar_type_node, array_domain_type);
4770 /* Define 'char16_t'. */
4771 char16_type_node = get_identifier (CHAR16_TYPE);
4772 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4773 char16_type_size = TYPE_PRECISION (char16_type_node);
4774 if (c_dialect_cxx ())
4776 char16_type_node = make_unsigned_type (char16_type_size);
4778 if (cxx_dialect == cxx0x)
4779 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4782 /* This is for UTF-16 string constants. */
4783 char16_array_type_node
4784 = build_array_type (char16_type_node, array_domain_type);
4786 /* Define 'char32_t'. */
4787 char32_type_node = get_identifier (CHAR32_TYPE);
4788 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4789 char32_type_size = TYPE_PRECISION (char32_type_node);
4790 if (c_dialect_cxx ())
4792 char32_type_node = make_unsigned_type (char32_type_size);
4794 if (cxx_dialect == cxx0x)
4795 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4798 /* This is for UTF-32 string constants. */
4799 char32_array_type_node
4800 = build_array_type (char32_type_node, array_domain_type);
4803 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4806 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4808 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4810 if (SIG_ATOMIC_TYPE)
4811 sig_atomic_type_node =
4812 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
4815 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
4818 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
4821 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
4824 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
4827 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
4830 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
4832 c_uint32_type_node =
4833 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
4835 c_uint64_type_node =
4836 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
4837 if (INT_LEAST8_TYPE)
4838 int_least8_type_node =
4839 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
4840 if (INT_LEAST16_TYPE)
4841 int_least16_type_node =
4842 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
4843 if (INT_LEAST32_TYPE)
4844 int_least32_type_node =
4845 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
4846 if (INT_LEAST64_TYPE)
4847 int_least64_type_node =
4848 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
4849 if (UINT_LEAST8_TYPE)
4850 uint_least8_type_node =
4851 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
4852 if (UINT_LEAST16_TYPE)
4853 uint_least16_type_node =
4854 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
4855 if (UINT_LEAST32_TYPE)
4856 uint_least32_type_node =
4857 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
4858 if (UINT_LEAST64_TYPE)
4859 uint_least64_type_node =
4860 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
4862 int_fast8_type_node =
4863 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
4864 if (INT_FAST16_TYPE)
4865 int_fast16_type_node =
4866 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
4867 if (INT_FAST32_TYPE)
4868 int_fast32_type_node =
4869 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
4870 if (INT_FAST64_TYPE)
4871 int_fast64_type_node =
4872 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
4873 if (UINT_FAST8_TYPE)
4874 uint_fast8_type_node =
4875 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
4876 if (UINT_FAST16_TYPE)
4877 uint_fast16_type_node =
4878 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
4879 if (UINT_FAST32_TYPE)
4880 uint_fast32_type_node =
4881 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
4882 if (UINT_FAST64_TYPE)
4883 uint_fast64_type_node =
4884 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
4887 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
4890 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
4892 default_function_type = build_function_type (integer_type_node, NULL_TREE);
4894 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
4895 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
4897 lang_hooks.decls.pushdecl
4898 (build_decl (UNKNOWN_LOCATION,
4899 TYPE_DECL, get_identifier ("__builtin_va_list"),
4900 va_list_type_node));
4901 if (targetm.enum_va_list_p)
4907 for (l = 0; targetm.enum_va_list_p (l, &pname, &ptype); ++l)
4909 lang_hooks.decls.pushdecl
4910 (build_decl (UNKNOWN_LOCATION,
4911 TYPE_DECL, get_identifier (pname),
4917 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4919 va_list_arg_type_node = va_list_ref_type_node =
4920 build_pointer_type (TREE_TYPE (va_list_type_node));
4924 va_list_arg_type_node = va_list_type_node;
4925 va_list_ref_type_node = build_reference_type (va_list_type_node);
4928 if (!flag_preprocess_only)
4929 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4931 main_identifier_node = get_identifier ("main");
4933 /* Create the built-in __null node. It is important that this is
4935 null_node = make_node (INTEGER_CST);
4936 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
4938 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4939 memset (builtin_types, 0, sizeof (builtin_types));
4942 /* The number of named compound-literals generated thus far. */
4943 static GTY(()) int compound_literal_number;
4945 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4948 set_compound_literal_name (tree decl)
4951 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4952 compound_literal_number);
4953 compound_literal_number++;
4954 DECL_NAME (decl) = get_identifier (name);
4958 build_va_arg (location_t loc, tree expr, tree type)
4960 expr = build1 (VA_ARG_EXPR, type, expr);
4961 SET_EXPR_LOCATION (expr, loc);
4966 /* Linked list of disabled built-in functions. */
4968 typedef struct disabled_builtin
4971 struct disabled_builtin *next;
4973 static disabled_builtin *disabled_builtins = NULL;
4975 static bool builtin_function_disabled_p (const char *);
4977 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4978 begins with "__builtin_", give an error. */
4981 disable_builtin_function (const char *name)
4983 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4984 error ("cannot disable built-in function %qs", name);
4987 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4988 new_disabled_builtin->name = name;
4989 new_disabled_builtin->next = disabled_builtins;
4990 disabled_builtins = new_disabled_builtin;
4995 /* Return true if the built-in function NAME has been disabled, false
4999 builtin_function_disabled_p (const char *name)
5001 disabled_builtin *p;
5002 for (p = disabled_builtins; p != NULL; p = p->next)
5004 if (strcmp (name, p->name) == 0)
5011 /* Worker for DEF_BUILTIN.
5012 Possibly define a builtin function with one or two names.
5013 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5014 nonansi_p and flag_no_nonansi_builtin. */
5017 def_builtin_1 (enum built_in_function fncode,
5019 enum built_in_class fnclass,
5020 tree fntype, tree libtype,
5021 bool both_p, bool fallback_p, bool nonansi_p,
5022 tree fnattrs, bool implicit_p)
5025 const char *libname;
5027 if (fntype == error_mark_node)
5030 gcc_assert ((!both_p && !fallback_p)
5031 || !strncmp (name, "__builtin_",
5032 strlen ("__builtin_")));
5034 libname = name + strlen ("__builtin_");
5035 decl = add_builtin_function (name, fntype, fncode, fnclass,
5036 (fallback_p ? libname : NULL),
5039 && !flag_no_builtin && !builtin_function_disabled_p (libname)
5040 && !(nonansi_p && flag_no_nonansi_builtin))
5041 add_builtin_function (libname, libtype, fncode, fnclass,
5044 built_in_decls[(int) fncode] = decl;
5046 implicit_built_in_decls[(int) fncode] = decl;
5049 /* Nonzero if the type T promotes to int. This is (nearly) the
5050 integral promotions defined in ISO C99 6.3.1.1/2. */
5053 c_promoting_integer_type_p (const_tree t)
5055 switch (TREE_CODE (t))
5058 return (TYPE_MAIN_VARIANT (t) == char_type_node
5059 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5060 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5061 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
5062 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5063 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
5066 /* ??? Technically all enumerations not larger than an int
5067 promote to an int. But this is used along code paths
5068 that only want to notice a size change. */
5069 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5079 /* Return 1 if PARMS specifies a fixed number of parameters
5080 and none of their types is affected by default promotions. */
5083 self_promoting_args_p (const_tree parms)
5086 for (t = parms; t; t = TREE_CHAIN (t))
5088 tree type = TREE_VALUE (t);
5090 if (type == error_mark_node)
5093 if (TREE_CHAIN (t) == 0 && type != void_type_node)
5099 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5102 if (c_promoting_integer_type_p (type))
5108 /* Recursively remove any '*' or '&' operator from TYPE. */
5110 strip_pointer_operator (tree t)
5112 while (POINTER_TYPE_P (t))
5117 /* Recursively remove pointer or array type from TYPE. */
5119 strip_pointer_or_array_types (tree t)
5121 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5126 /* Used to compare case labels. K1 and K2 are actually tree nodes
5127 representing case labels, or NULL_TREE for a `default' label.
5128 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5129 K2, and 0 if K1 and K2 are equal. */
5132 case_compare (splay_tree_key k1, splay_tree_key k2)
5134 /* Consider a NULL key (such as arises with a `default' label) to be
5135 smaller than anything else. */
5141 return tree_int_cst_compare ((tree) k1, (tree) k2);
5144 /* Process a case label, located at LOC, for the range LOW_VALUE
5145 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5146 then this case label is actually a `default' label. If only
5147 HIGH_VALUE is NULL_TREE, then case label was declared using the
5148 usual C/C++ syntax, rather than the GNU case range extension.
5149 CASES is a tree containing all the case ranges processed so far;
5150 COND is the condition for the switch-statement itself. Returns the
5151 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5155 c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type,
5156 tree low_value, tree high_value)
5161 splay_tree_node node;
5163 /* Create the LABEL_DECL itself. */
5164 label = create_artificial_label (loc);
5166 /* If there was an error processing the switch condition, bail now
5167 before we get more confused. */
5168 if (!cond || cond == error_mark_node)
5171 if ((low_value && TREE_TYPE (low_value)
5172 && POINTER_TYPE_P (TREE_TYPE (low_value)))
5173 || (high_value && TREE_TYPE (high_value)
5174 && POINTER_TYPE_P (TREE_TYPE (high_value))))
5176 error_at (loc, "pointers are not permitted as case values");
5180 /* Case ranges are a GNU extension. */
5182 pedwarn (loc, OPT_pedantic,
5183 "range expressions in switch statements are non-standard");
5185 type = TREE_TYPE (cond);
5188 low_value = check_case_value (low_value);
5189 low_value = convert_and_check (type, low_value);
5190 if (low_value == error_mark_node)
5195 high_value = check_case_value (high_value);
5196 high_value = convert_and_check (type, high_value);
5197 if (high_value == error_mark_node)
5201 if (low_value && high_value)
5203 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5204 really a case range, even though it was written that way.
5205 Remove the HIGH_VALUE to simplify later processing. */
5206 if (tree_int_cst_equal (low_value, high_value))
5207 high_value = NULL_TREE;
5208 else if (!tree_int_cst_lt (low_value, high_value))
5209 warning_at (loc, 0, "empty range specified");
5212 /* See if the case is in range of the type of the original testing
5213 expression. If both low_value and high_value are out of range,
5214 don't insert the case label and return NULL_TREE. */
5216 && !check_case_bounds (type, orig_type,
5217 &low_value, high_value ? &high_value : NULL))
5220 /* Look up the LOW_VALUE in the table of case labels we already
5222 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5223 /* If there was not an exact match, check for overlapping ranges.
5224 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5225 that's a `default' label and the only overlap is an exact match. */
5226 if (!node && (low_value || high_value))
5228 splay_tree_node low_bound;
5229 splay_tree_node high_bound;
5231 /* Even though there wasn't an exact match, there might be an
5232 overlap between this case range and another case range.
5233 Since we've (inductively) not allowed any overlapping case
5234 ranges, we simply need to find the greatest low case label
5235 that is smaller that LOW_VALUE, and the smallest low case
5236 label that is greater than LOW_VALUE. If there is an overlap
5237 it will occur in one of these two ranges. */
5238 low_bound = splay_tree_predecessor (cases,
5239 (splay_tree_key) low_value);
5240 high_bound = splay_tree_successor (cases,
5241 (splay_tree_key) low_value);
5243 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5244 the LOW_VALUE, so there is no need to check unless the
5245 LOW_BOUND is in fact itself a case range. */
5247 && CASE_HIGH ((tree) low_bound->value)
5248 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5251 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5252 range is bigger than the low end of the current range, so we
5253 are only interested if the current range is a real range, and
5254 not an ordinary case label. */
5257 && (tree_int_cst_compare ((tree) high_bound->key,
5262 /* If there was an overlap, issue an error. */
5265 tree duplicate = CASE_LABEL ((tree) node->value);
5269 error_at (loc, "duplicate (or overlapping) case value");
5270 error_at (DECL_SOURCE_LOCATION (duplicate),
5271 "this is the first entry overlapping that value");
5275 error_at (loc, "duplicate case value") ;
5276 error_at (DECL_SOURCE_LOCATION (duplicate), "previously used here");
5280 error_at (loc, "multiple default labels in one switch");
5281 error_at (DECL_SOURCE_LOCATION (duplicate),
5282 "this is the first default label");
5287 /* Add a CASE_LABEL to the statement-tree. */
5288 case_label = add_stmt (build_case_label (loc, low_value, high_value, label));
5289 /* Register this case label in the splay tree. */
5290 splay_tree_insert (cases,
5291 (splay_tree_key) low_value,
5292 (splay_tree_value) case_label);
5297 /* Add a label so that the back-end doesn't think that the beginning of
5298 the switch is unreachable. Note that we do not add a case label, as
5299 that just leads to duplicates and thence to failure later on. */
5302 tree t = create_artificial_label (loc);
5303 add_stmt (build_stmt (loc, LABEL_EXPR, t));
5305 return error_mark_node;
5308 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5309 Used to verify that case values match up with enumerator values. */
5312 match_case_to_enum_1 (tree key, tree type, tree label)
5314 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5316 /* ??? Not working too hard to print the double-word value.
5317 Should perhaps be done with %lwd in the diagnostic routines? */
5318 if (TREE_INT_CST_HIGH (key) == 0)
5319 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5320 TREE_INT_CST_LOW (key));
5321 else if (!TYPE_UNSIGNED (type)
5322 && TREE_INT_CST_HIGH (key) == -1
5323 && TREE_INT_CST_LOW (key) != 0)
5324 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5325 -TREE_INT_CST_LOW (key));
5327 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5328 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5329 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
5331 if (TYPE_NAME (type) == 0)
5332 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5333 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5334 "case value %qs not in enumerated type",
5337 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5338 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5339 "case value %qs not in enumerated type %qT",
5343 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5344 Used to verify that case values match up with enumerator values. */
5347 match_case_to_enum (splay_tree_node node, void *data)
5349 tree label = (tree) node->value;
5350 tree type = (tree) data;
5352 /* Skip default case. */
5353 if (!CASE_LOW (label))
5356 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5357 when we did our enum->case scan. Reset our scratch bit after. */
5358 if (!CASE_LOW_SEEN (label))
5359 match_case_to_enum_1 (CASE_LOW (label), type, label);
5361 CASE_LOW_SEEN (label) = 0;
5363 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5364 not set, that means that CASE_HIGH did not appear when we did our
5365 enum->case scan. Reset our scratch bit after. */
5366 if (CASE_HIGH (label))
5368 if (!CASE_HIGH_SEEN (label))
5369 match_case_to_enum_1 (CASE_HIGH (label), type, label);
5371 CASE_HIGH_SEEN (label) = 0;
5377 /* Handle -Wswitch*. Called from the front end after parsing the
5378 switch construct. */
5379 /* ??? Should probably be somewhere generic, since other languages
5380 besides C and C++ would want this. At the moment, however, C/C++
5381 are the only tree-ssa languages that support enumerations at all,
5382 so the point is moot. */
5385 c_do_switch_warnings (splay_tree cases, location_t switch_location,
5386 tree type, tree cond)
5388 splay_tree_node default_node;
5389 splay_tree_node node;
5392 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5395 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
5397 warning_at (switch_location, OPT_Wswitch_default,
5398 "switch missing default case");
5400 /* From here on, we only care about about enumerated types. */
5401 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5404 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
5405 if (!warn_switch_enum && !warn_switch)
5408 /* Check the cases. Warn about case values which are not members of
5409 the enumerated type. For -Wswitch-enum, or for -Wswitch when
5410 there is no default case, check that exactly all enumeration
5411 literals are covered by the cases. */
5413 /* Clearing COND if it is not an integer constant simplifies
5414 the tests inside the loop below. */
5415 if (TREE_CODE (cond) != INTEGER_CST)
5418 /* The time complexity here is O(N*lg(N)) worst case, but for the
5419 common case of monotonically increasing enumerators, it is
5420 O(N), since the nature of the splay tree will keep the next
5421 element adjacent to the root at all times. */
5423 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5425 tree value = TREE_VALUE (chain);
5426 if (TREE_CODE (value) == CONST_DECL)
5427 value = DECL_INITIAL (value);
5428 node = splay_tree_lookup (cases, (splay_tree_key) value);
5431 /* Mark the CASE_LOW part of the case entry as seen. */
5432 tree label = (tree) node->value;
5433 CASE_LOW_SEEN (label) = 1;
5437 /* Even though there wasn't an exact match, there might be a
5438 case range which includes the enumerator's value. */
5439 node = splay_tree_predecessor (cases, (splay_tree_key) value);
5440 if (node && CASE_HIGH ((tree) node->value))
5442 tree label = (tree) node->value;
5443 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5446 /* If we match the upper bound exactly, mark the CASE_HIGH
5447 part of the case entry as seen. */
5449 CASE_HIGH_SEEN (label) = 1;
5454 /* We've now determined that this enumerated literal isn't
5455 handled by the case labels of the switch statement. */
5457 /* If the switch expression is a constant, we only really care
5458 about whether that constant is handled by the switch. */
5459 if (cond && tree_int_cst_compare (cond, value))
5462 /* If there is a default_node, the only relevant option is
5463 Wswitch-enum. Otherwise, if both are enabled then we prefer
5464 to warn using -Wswitch because -Wswitch is enabled by -Wall
5465 while -Wswitch-enum is explicit. */
5466 warning_at (switch_location,
5467 (default_node || !warn_switch
5470 "enumeration value %qE not handled in switch",
5471 TREE_PURPOSE (chain));
5474 /* Warn if there are case expressions that don't correspond to
5475 enumerators. This can occur since C and C++ don't enforce
5476 type-checking of assignments to enumeration variables.
5478 The time complexity here is now always O(N) worst case, since
5479 we should have marked both the lower bound and upper bound of
5480 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5481 above. This scan also resets those fields. */
5483 splay_tree_foreach (cases, match_case_to_enum, type);
5486 /* Finish an expression taking the address of LABEL (an
5487 IDENTIFIER_NODE). Returns an expression for the address.
5489 LOC is the location for the expression returned. */
5492 finish_label_address_expr (tree label, location_t loc)
5496 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5498 if (label == error_mark_node)
5499 return error_mark_node;
5501 label = lookup_label (label);
5502 if (label == NULL_TREE)
5503 result = null_pointer_node;
5506 TREE_USED (label) = 1;
5507 result = build1 (ADDR_EXPR, ptr_type_node, label);
5508 /* The current function is not necessarily uninlinable.
5509 Computed gotos are incompatible with inlining, but the value
5510 here could be used only in a diagnostic, for example. */
5511 protected_set_expr_location (result, loc);
5518 /* Given a boolean expression ARG, return a tree representing an increment
5519 or decrement (as indicated by CODE) of ARG. The front end must check for
5520 invalid cases (e.g., decrement in C++). */
5522 boolean_increment (enum tree_code code, tree arg)
5525 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5527 arg = stabilize_reference (arg);
5530 case PREINCREMENT_EXPR:
5531 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5533 case POSTINCREMENT_EXPR:
5534 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5535 arg = save_expr (arg);
5536 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5537 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5539 case PREDECREMENT_EXPR:
5540 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5541 invert_truthvalue_loc (input_location, arg));
5543 case POSTDECREMENT_EXPR:
5544 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5545 invert_truthvalue_loc (input_location, arg));
5546 arg = save_expr (arg);
5547 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5548 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5553 TREE_SIDE_EFFECTS (val) = 1;
5557 /* Built-in macros for stddef.h and stdint.h, that require macros
5558 defined in this file. */
5560 c_stddef_cpp_builtins(void)
5562 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5563 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5564 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5565 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5566 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5567 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5568 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5569 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5570 if (SIG_ATOMIC_TYPE)
5571 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5573 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5575 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5577 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5579 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5581 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5583 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5585 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5587 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5588 if (INT_LEAST8_TYPE)
5589 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5590 if (INT_LEAST16_TYPE)
5591 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5592 if (INT_LEAST32_TYPE)
5593 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5594 if (INT_LEAST64_TYPE)
5595 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5596 if (UINT_LEAST8_TYPE)
5597 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5598 if (UINT_LEAST16_TYPE)
5599 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5600 if (UINT_LEAST32_TYPE)
5601 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5602 if (UINT_LEAST64_TYPE)
5603 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5605 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5606 if (INT_FAST16_TYPE)
5607 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5608 if (INT_FAST32_TYPE)
5609 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5610 if (INT_FAST64_TYPE)
5611 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5612 if (UINT_FAST8_TYPE)
5613 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5614 if (UINT_FAST16_TYPE)
5615 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5616 if (UINT_FAST32_TYPE)
5617 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5618 if (UINT_FAST64_TYPE)
5619 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5621 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5623 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
5627 c_init_attributes (void)
5629 /* Fill in the built_in_attributes array. */
5630 #define DEF_ATTR_NULL_TREE(ENUM) \
5631 built_in_attributes[(int) ENUM] = NULL_TREE;
5632 #define DEF_ATTR_INT(ENUM, VALUE) \
5633 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5634 #define DEF_ATTR_IDENT(ENUM, STRING) \
5635 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5636 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5637 built_in_attributes[(int) ENUM] \
5638 = tree_cons (built_in_attributes[(int) PURPOSE], \
5639 built_in_attributes[(int) VALUE], \
5640 built_in_attributes[(int) CHAIN]);
5641 #include "builtin-attrs.def"
5642 #undef DEF_ATTR_NULL_TREE
5644 #undef DEF_ATTR_IDENT
5645 #undef DEF_ATTR_TREE_LIST
5648 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
5649 identifier as an argument, so the front end shouldn't look it up. */
5652 attribute_takes_identifier_p (const_tree attr_id)
5654 if (is_attribute_p ("mode", attr_id)
5655 || is_attribute_p ("format", attr_id)
5656 || is_attribute_p ("cleanup", attr_id))
5659 return targetm.attribute_takes_identifier_p (attr_id);
5662 /* Attribute handlers common to C front ends. */
5664 /* Handle a "packed" attribute; arguments as in
5665 struct attribute_spec.handler. */
5668 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5669 int flags, bool *no_add_attrs)
5673 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5674 *node = build_variant_type_copy (*node);
5675 TYPE_PACKED (*node) = 1;
5677 else if (TREE_CODE (*node) == FIELD_DECL)
5679 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5680 /* Still pack bitfields. */
5681 && ! DECL_INITIAL (*node))
5682 warning (OPT_Wattributes,
5683 "%qE attribute ignored for field of type %qT",
5684 name, TREE_TYPE (*node));
5686 DECL_PACKED (*node) = 1;
5688 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5689 used for DECL_REGISTER. It wouldn't mean anything anyway.
5690 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5691 that changes what the typedef is typing. */
5694 warning (OPT_Wattributes, "%qE attribute ignored", name);
5695 *no_add_attrs = true;
5701 /* Handle a "nocommon" attribute; arguments as in
5702 struct attribute_spec.handler. */
5705 handle_nocommon_attribute (tree *node, tree name,
5706 tree ARG_UNUSED (args),
5707 int ARG_UNUSED (flags), bool *no_add_attrs)
5709 if (TREE_CODE (*node) == VAR_DECL)
5710 DECL_COMMON (*node) = 0;
5713 warning (OPT_Wattributes, "%qE attribute ignored", name);
5714 *no_add_attrs = true;
5720 /* Handle a "common" attribute; arguments as in
5721 struct attribute_spec.handler. */
5724 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5725 int ARG_UNUSED (flags), bool *no_add_attrs)
5727 if (TREE_CODE (*node) == VAR_DECL)
5728 DECL_COMMON (*node) = 1;
5731 warning (OPT_Wattributes, "%qE attribute ignored", name);
5732 *no_add_attrs = true;
5738 /* Handle a "noreturn" attribute; arguments as in
5739 struct attribute_spec.handler. */
5742 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5743 int ARG_UNUSED (flags), bool *no_add_attrs)
5745 tree type = TREE_TYPE (*node);
5747 /* See FIXME comment in c_common_attribute_table. */
5748 if (TREE_CODE (*node) == FUNCTION_DECL
5749 || objc_method_decl (TREE_CODE (*node)))
5750 TREE_THIS_VOLATILE (*node) = 1;
5751 else if (TREE_CODE (type) == POINTER_TYPE
5752 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5754 = build_pointer_type
5755 (build_type_variant (TREE_TYPE (type),
5756 TYPE_READONLY (TREE_TYPE (type)), 1));
5759 warning (OPT_Wattributes, "%qE attribute ignored", name);
5760 *no_add_attrs = true;
5766 /* Handle a "hot" and attribute; arguments as in
5767 struct attribute_spec.handler. */
5770 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5771 int ARG_UNUSED (flags), bool *no_add_attrs)
5773 if (TREE_CODE (*node) == FUNCTION_DECL)
5775 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5777 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5779 *no_add_attrs = true;
5781 /* Most of the rest of the hot processing is done later with
5782 lookup_attribute. */
5786 warning (OPT_Wattributes, "%qE attribute ignored", name);
5787 *no_add_attrs = true;
5792 /* Handle a "cold" and attribute; arguments as in
5793 struct attribute_spec.handler. */
5796 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5797 int ARG_UNUSED (flags), bool *no_add_attrs)
5799 if (TREE_CODE (*node) == FUNCTION_DECL)
5801 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5803 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5805 *no_add_attrs = true;
5807 /* Most of the rest of the cold processing is done later with
5808 lookup_attribute. */
5812 warning (OPT_Wattributes, "%qE attribute ignored", name);
5813 *no_add_attrs = true;
5819 /* Handle a "noinline" attribute; arguments as in
5820 struct attribute_spec.handler. */
5823 handle_noinline_attribute (tree *node, tree name,
5824 tree ARG_UNUSED (args),
5825 int ARG_UNUSED (flags), bool *no_add_attrs)
5827 if (TREE_CODE (*node) == FUNCTION_DECL)
5828 DECL_UNINLINABLE (*node) = 1;
5831 warning (OPT_Wattributes, "%qE attribute ignored", name);
5832 *no_add_attrs = true;
5838 /* Handle a "noclone" attribute; arguments as in
5839 struct attribute_spec.handler. */
5842 handle_noclone_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)
5848 warning (OPT_Wattributes, "%qE attribute ignored", name);
5849 *no_add_attrs = true;
5855 /* Handle a "always_inline" attribute; arguments as in
5856 struct attribute_spec.handler. */
5859 handle_always_inline_attribute (tree *node, tree name,
5860 tree ARG_UNUSED (args),
5861 int ARG_UNUSED (flags),
5864 if (TREE_CODE (*node) == FUNCTION_DECL)
5866 /* Set the attribute and mark it for disregarding inline
5868 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
5872 warning (OPT_Wattributes, "%qE attribute ignored", name);
5873 *no_add_attrs = true;
5879 /* Handle a "gnu_inline" attribute; arguments as in
5880 struct attribute_spec.handler. */
5883 handle_gnu_inline_attribute (tree *node, tree name,
5884 tree ARG_UNUSED (args),
5885 int ARG_UNUSED (flags),
5888 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5890 /* Do nothing else, just set the attribute. We'll get at
5891 it later with lookup_attribute. */
5895 warning (OPT_Wattributes, "%qE attribute ignored", name);
5896 *no_add_attrs = true;
5902 /* Handle a "leaf" attribute; arguments as in
5903 struct attribute_spec.handler. */
5906 handle_leaf_attribute (tree *node, tree name,
5907 tree ARG_UNUSED (args),
5908 int ARG_UNUSED (flags), bool *no_add_attrs)
5910 if (TREE_CODE (*node) != FUNCTION_DECL)
5912 warning (OPT_Wattributes, "%qE attribute ignored", name);
5913 *no_add_attrs = true;
5915 if (!TREE_PUBLIC (*node))
5917 warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
5918 *no_add_attrs = true;
5924 /* Handle an "artificial" attribute; arguments as in
5925 struct attribute_spec.handler. */
5928 handle_artificial_attribute (tree *node, tree name,
5929 tree ARG_UNUSED (args),
5930 int ARG_UNUSED (flags),
5933 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5935 /* Do nothing else, just set the attribute. We'll get at
5936 it later with lookup_attribute. */
5940 warning (OPT_Wattributes, "%qE attribute ignored", name);
5941 *no_add_attrs = true;
5947 /* Handle a "flatten" attribute; arguments as in
5948 struct attribute_spec.handler. */
5951 handle_flatten_attribute (tree *node, tree name,
5952 tree args ATTRIBUTE_UNUSED,
5953 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5955 if (TREE_CODE (*node) == FUNCTION_DECL)
5956 /* Do nothing else, just set the attribute. We'll get at
5957 it later with lookup_attribute. */
5961 warning (OPT_Wattributes, "%qE attribute ignored", name);
5962 *no_add_attrs = true;
5968 /* Handle a "warning" or "error" attribute; arguments as in
5969 struct attribute_spec.handler. */
5972 handle_error_attribute (tree *node, tree name, tree args,
5973 int ARG_UNUSED (flags), bool *no_add_attrs)
5975 if (TREE_CODE (*node) == FUNCTION_DECL
5976 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5977 /* Do nothing else, just set the attribute. We'll get at
5978 it later with lookup_attribute. */
5982 warning (OPT_Wattributes, "%qE attribute ignored", name);
5983 *no_add_attrs = true;
5989 /* Handle a "used" attribute; arguments as in
5990 struct attribute_spec.handler. */
5993 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
5994 int ARG_UNUSED (flags), bool *no_add_attrs)
5998 if (TREE_CODE (node) == FUNCTION_DECL
5999 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
6001 TREE_USED (node) = 1;
6002 DECL_PRESERVE_P (node) = 1;
6003 if (TREE_CODE (node) == VAR_DECL)
6004 DECL_READ_P (node) = 1;
6008 warning (OPT_Wattributes, "%qE attribute ignored", name);
6009 *no_add_attrs = true;
6015 /* Handle a "unused" attribute; arguments as in
6016 struct attribute_spec.handler. */
6019 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6020 int flags, bool *no_add_attrs)
6026 if (TREE_CODE (decl) == PARM_DECL
6027 || TREE_CODE (decl) == VAR_DECL
6028 || TREE_CODE (decl) == FUNCTION_DECL
6029 || TREE_CODE (decl) == LABEL_DECL
6030 || TREE_CODE (decl) == TYPE_DECL)
6032 TREE_USED (decl) = 1;
6033 if (TREE_CODE (decl) == VAR_DECL
6034 || TREE_CODE (decl) == PARM_DECL)
6035 DECL_READ_P (decl) = 1;
6039 warning (OPT_Wattributes, "%qE attribute ignored", name);
6040 *no_add_attrs = true;
6045 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6046 *node = build_variant_type_copy (*node);
6047 TREE_USED (*node) = 1;
6053 /* Handle a "externally_visible" attribute; arguments as in
6054 struct attribute_spec.handler. */
6057 handle_externally_visible_attribute (tree *pnode, tree name,
6058 tree ARG_UNUSED (args),
6059 int ARG_UNUSED (flags),
6064 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
6066 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6067 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6069 warning (OPT_Wattributes,
6070 "%qE attribute have effect only on public objects", name);
6071 *no_add_attrs = true;
6076 warning (OPT_Wattributes, "%qE attribute ignored", name);
6077 *no_add_attrs = true;
6083 /* Handle a "const" attribute; arguments as in
6084 struct attribute_spec.handler. */
6087 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6088 int ARG_UNUSED (flags), bool *no_add_attrs)
6090 tree type = TREE_TYPE (*node);
6092 /* See FIXME comment on noreturn in c_common_attribute_table. */
6093 if (TREE_CODE (*node) == FUNCTION_DECL)
6094 TREE_READONLY (*node) = 1;
6095 else if (TREE_CODE (type) == POINTER_TYPE
6096 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6098 = build_pointer_type
6099 (build_type_variant (TREE_TYPE (type), 1,
6100 TREE_THIS_VOLATILE (TREE_TYPE (type))));
6103 warning (OPT_Wattributes, "%qE attribute ignored", name);
6104 *no_add_attrs = true;
6110 /* Handle a "transparent_union" attribute; arguments as in
6111 struct attribute_spec.handler. */
6114 handle_transparent_union_attribute (tree *node, tree name,
6115 tree ARG_UNUSED (args), int flags,
6120 *no_add_attrs = true;
6122 if (TREE_CODE (*node) == TYPE_DECL)
6123 node = &TREE_TYPE (*node);
6126 if (TREE_CODE (type) == UNION_TYPE)
6128 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6129 the code in finish_struct. */
6130 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6132 if (TYPE_FIELDS (type) == NULL_TREE
6133 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6136 /* A type variant isn't good enough, since we don't a cast
6137 to such a type removed as a no-op. */
6138 *node = type = build_duplicate_type (type);
6141 TYPE_TRANSPARENT_AGGR (type) = 1;
6146 warning (OPT_Wattributes, "%qE attribute ignored", name);
6150 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6151 get the requested priority for a constructor or destructor,
6152 possibly issuing diagnostics for invalid or reserved
6155 static priority_type
6156 get_priority (tree args, bool is_destructor)
6162 return DEFAULT_INIT_PRIORITY;
6164 if (!SUPPORTS_INIT_PRIORITY)
6167 error ("destructor priorities are not supported");
6169 error ("constructor priorities are not supported");
6170 return DEFAULT_INIT_PRIORITY;
6173 arg = TREE_VALUE (args);
6174 if (!host_integerp (arg, /*pos=*/0)
6175 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
6178 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6179 if (pri < 0 || pri > MAX_INIT_PRIORITY)
6182 if (pri <= MAX_RESERVED_INIT_PRIORITY)
6186 "destructor priorities from 0 to %d are reserved "
6187 "for the implementation",
6188 MAX_RESERVED_INIT_PRIORITY);
6191 "constructor priorities from 0 to %d are reserved "
6192 "for the implementation",
6193 MAX_RESERVED_INIT_PRIORITY);
6199 error ("destructor priorities must be integers from 0 to %d inclusive",
6202 error ("constructor priorities must be integers from 0 to %d inclusive",
6204 return DEFAULT_INIT_PRIORITY;
6207 /* Handle a "constructor" attribute; arguments as in
6208 struct attribute_spec.handler. */
6211 handle_constructor_attribute (tree *node, tree name, tree args,
6212 int ARG_UNUSED (flags),
6216 tree type = TREE_TYPE (decl);
6218 if (TREE_CODE (decl) == FUNCTION_DECL
6219 && TREE_CODE (type) == FUNCTION_TYPE
6220 && decl_function_context (decl) == 0)
6222 priority_type priority;
6223 DECL_STATIC_CONSTRUCTOR (decl) = 1;
6224 priority = get_priority (args, /*is_destructor=*/false);
6225 SET_DECL_INIT_PRIORITY (decl, priority);
6226 TREE_USED (decl) = 1;
6230 warning (OPT_Wattributes, "%qE attribute ignored", name);
6231 *no_add_attrs = true;
6237 /* Handle a "destructor" attribute; arguments as in
6238 struct attribute_spec.handler. */
6241 handle_destructor_attribute (tree *node, tree name, tree args,
6242 int ARG_UNUSED (flags),
6246 tree type = TREE_TYPE (decl);
6248 if (TREE_CODE (decl) == FUNCTION_DECL
6249 && TREE_CODE (type) == FUNCTION_TYPE
6250 && decl_function_context (decl) == 0)
6252 priority_type priority;
6253 DECL_STATIC_DESTRUCTOR (decl) = 1;
6254 priority = get_priority (args, /*is_destructor=*/true);
6255 SET_DECL_FINI_PRIORITY (decl, priority);
6256 TREE_USED (decl) = 1;
6260 warning (OPT_Wattributes, "%qE attribute ignored", name);
6261 *no_add_attrs = true;
6267 /* Nonzero if the mode is a valid vector mode for this architecture.
6268 This returns nonzero even if there is no hardware support for the
6269 vector mode, but we can emulate with narrower modes. */
6272 vector_mode_valid_p (enum machine_mode mode)
6274 enum mode_class mclass = GET_MODE_CLASS (mode);
6275 enum machine_mode innermode;
6277 /* Doh! What's going on? */
6278 if (mclass != MODE_VECTOR_INT
6279 && mclass != MODE_VECTOR_FLOAT
6280 && mclass != MODE_VECTOR_FRACT
6281 && mclass != MODE_VECTOR_UFRACT
6282 && mclass != MODE_VECTOR_ACCUM
6283 && mclass != MODE_VECTOR_UACCUM)
6286 /* Hardware support. Woo hoo! */
6287 if (targetm.vector_mode_supported_p (mode))
6290 innermode = GET_MODE_INNER (mode);
6292 /* We should probably return 1 if requesting V4DI and we have no DI,
6293 but we have V2DI, but this is probably very unlikely. */
6295 /* If we have support for the inner mode, we can safely emulate it.
6296 We may not have V2DI, but me can emulate with a pair of DIs. */
6297 return targetm.scalar_mode_supported_p (innermode);
6301 /* Handle a "mode" attribute; arguments as in
6302 struct attribute_spec.handler. */
6305 handle_mode_attribute (tree *node, tree name, tree args,
6306 int ARG_UNUSED (flags), bool *no_add_attrs)
6309 tree ident = TREE_VALUE (args);
6311 *no_add_attrs = true;
6313 if (TREE_CODE (ident) != IDENTIFIER_NODE)
6314 warning (OPT_Wattributes, "%qE attribute ignored", name);
6318 const char *p = IDENTIFIER_POINTER (ident);
6319 int len = strlen (p);
6320 enum machine_mode mode = VOIDmode;
6324 if (len > 4 && p[0] == '_' && p[1] == '_'
6325 && p[len - 1] == '_' && p[len - 2] == '_')
6327 char *newp = (char *) alloca (len - 1);
6329 strcpy (newp, &p[2]);
6330 newp[len - 4] = '\0';
6334 /* Change this type to have a type with the specified mode.
6335 First check for the special modes. */
6336 if (!strcmp (p, "byte"))
6338 else if (!strcmp (p, "word"))
6340 else if (!strcmp (p, "pointer"))
6342 else if (!strcmp (p, "libgcc_cmp_return"))
6343 mode = targetm.libgcc_cmp_return_mode ();
6344 else if (!strcmp (p, "libgcc_shift_count"))
6345 mode = targetm.libgcc_shift_count_mode ();
6346 else if (!strcmp (p, "unwind_word"))
6347 mode = targetm.unwind_word_mode ();
6349 for (j = 0; j < NUM_MACHINE_MODES; j++)
6350 if (!strcmp (p, GET_MODE_NAME (j)))
6352 mode = (enum machine_mode) j;
6356 if (mode == VOIDmode)
6358 error ("unknown machine mode %qE", ident);
6363 switch (GET_MODE_CLASS (mode))
6366 case MODE_PARTIAL_INT:
6368 case MODE_DECIMAL_FLOAT:
6373 valid_mode = targetm.scalar_mode_supported_p (mode);
6376 case MODE_COMPLEX_INT:
6377 case MODE_COMPLEX_FLOAT:
6378 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6381 case MODE_VECTOR_INT:
6382 case MODE_VECTOR_FLOAT:
6383 case MODE_VECTOR_FRACT:
6384 case MODE_VECTOR_UFRACT:
6385 case MODE_VECTOR_ACCUM:
6386 case MODE_VECTOR_UACCUM:
6387 warning (OPT_Wattributes, "specifying vector types with "
6388 "__attribute__ ((mode)) is deprecated");
6389 warning (OPT_Wattributes,
6390 "use __attribute__ ((vector_size)) instead");
6391 valid_mode = vector_mode_valid_p (mode);
6399 error ("unable to emulate %qs", p);
6403 if (POINTER_TYPE_P (type))
6405 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
6406 tree (*fn)(tree, enum machine_mode, bool);
6408 if (!targetm.addr_space.valid_pointer_mode (mode, as))
6410 error ("invalid pointer mode %qs", p);
6414 if (TREE_CODE (type) == POINTER_TYPE)
6415 fn = build_pointer_type_for_mode;
6417 fn = build_reference_type_for_mode;
6418 typefm = fn (TREE_TYPE (type), mode, false);
6422 /* For fixed-point modes, we need to test if the signness of type
6423 and the machine mode are consistent. */
6424 if (ALL_FIXED_POINT_MODE_P (mode)
6425 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6427 error ("signedness of type and machine mode %qs don%'t match", p);
6430 /* For fixed-point modes, we need to pass saturating info. */
6431 typefm = lang_hooks.types.type_for_mode (mode,
6432 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6433 : TYPE_UNSIGNED (type));
6436 if (typefm == NULL_TREE)
6438 error ("no data type for mode %qs", p);
6441 else if (TREE_CODE (type) == ENUMERAL_TYPE)
6443 /* For enumeral types, copy the precision from the integer
6444 type returned above. If not an INTEGER_TYPE, we can't use
6445 this mode for this type. */
6446 if (TREE_CODE (typefm) != INTEGER_TYPE)
6448 error ("cannot use mode %qs for enumeral types", p);
6452 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6454 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6459 /* We cannot build a type variant, as there's code that assumes
6460 that TYPE_MAIN_VARIANT has the same mode. This includes the
6461 debug generators. Instead, create a subrange type. This
6462 results in all of the enumeral values being emitted only once
6463 in the original, and the subtype gets them by reference. */
6464 if (TYPE_UNSIGNED (type))
6465 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6467 typefm = make_signed_type (TYPE_PRECISION (typefm));
6468 TREE_TYPE (typefm) = type;
6471 else if (VECTOR_MODE_P (mode)
6472 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6473 : TREE_CODE (type) != TREE_CODE (typefm))
6475 error ("mode %qs applied to inappropriate type", p);
6485 /* Handle a "section" attribute; arguments as in
6486 struct attribute_spec.handler. */
6489 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6490 int ARG_UNUSED (flags), bool *no_add_attrs)
6494 if (targetm.have_named_sections)
6496 user_defined_section_attribute = true;
6498 if ((TREE_CODE (decl) == FUNCTION_DECL
6499 || TREE_CODE (decl) == VAR_DECL)
6500 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6502 if (TREE_CODE (decl) == VAR_DECL
6503 && current_function_decl != NULL_TREE
6504 && !TREE_STATIC (decl))
6506 error_at (DECL_SOURCE_LOCATION (decl),
6507 "section attribute cannot be specified for "
6509 *no_add_attrs = true;
6512 /* The decl may have already been given a section attribute
6513 from a previous declaration. Ensure they match. */
6514 else if (DECL_SECTION_NAME (decl) != NULL_TREE
6515 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6516 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6518 error ("section of %q+D conflicts with previous declaration",
6520 *no_add_attrs = true;
6522 else if (TREE_CODE (decl) == VAR_DECL
6523 && !targetm.have_tls && targetm.emutls.tmpl_section
6524 && DECL_THREAD_LOCAL_P (decl))
6526 error ("section of %q+D cannot be overridden", *node);
6527 *no_add_attrs = true;
6530 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6534 error ("section attribute not allowed for %q+D", *node);
6535 *no_add_attrs = true;
6540 error_at (DECL_SOURCE_LOCATION (*node),
6541 "section attributes are not supported for this target");
6542 *no_add_attrs = true;
6548 /* Handle a "aligned" attribute; arguments as in
6549 struct attribute_spec.handler. */
6552 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6553 int flags, bool *no_add_attrs)
6555 tree decl = NULL_TREE;
6558 tree align_expr = (args ? TREE_VALUE (args)
6559 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
6565 type = &TREE_TYPE (decl);
6566 is_type = TREE_CODE (*node) == TYPE_DECL;
6568 else if (TYPE_P (*node))
6569 type = node, is_type = 1;
6571 if (TREE_CODE (align_expr) != INTEGER_CST)
6573 error ("requested alignment is not a constant");
6574 *no_add_attrs = true;
6576 else if ((i = tree_log2 (align_expr)) == -1)
6578 error ("requested alignment is not a power of 2");
6579 *no_add_attrs = true;
6581 else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
6583 error ("requested alignment is too large");
6584 *no_add_attrs = true;
6588 if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6589 /* OK, modify the type in place. */;
6590 /* If we have a TYPE_DECL, then copy the type, so that we
6591 don't accidentally modify a builtin type. See pushdecl. */
6592 else if (decl && TREE_TYPE (decl) != error_mark_node
6593 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6595 tree tt = TREE_TYPE (decl);
6596 *type = build_variant_type_copy (*type);
6597 DECL_ORIGINAL_TYPE (decl) = tt;
6598 TYPE_NAME (*type) = decl;
6599 TREE_USED (*type) = TREE_USED (decl);
6600 TREE_TYPE (decl) = *type;
6603 *type = build_variant_type_copy (*type);
6605 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
6606 TYPE_USER_ALIGN (*type) = 1;
6608 else if (! VAR_OR_FUNCTION_DECL_P (decl)
6609 && TREE_CODE (decl) != FIELD_DECL)
6611 error ("alignment may not be specified for %q+D", decl);
6612 *no_add_attrs = true;
6614 else if (TREE_CODE (decl) == FUNCTION_DECL
6615 && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
6617 if (DECL_USER_ALIGN (decl))
6618 error ("alignment for %q+D was previously specified as %d "
6619 "and may not be decreased", decl,
6620 DECL_ALIGN (decl) / BITS_PER_UNIT);
6622 error ("alignment for %q+D must be at least %d", decl,
6623 DECL_ALIGN (decl) / BITS_PER_UNIT);
6624 *no_add_attrs = true;
6628 DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
6629 DECL_USER_ALIGN (decl) = 1;
6635 /* Handle a "weak" attribute; arguments as in
6636 struct attribute_spec.handler. */
6639 handle_weak_attribute (tree *node, tree name,
6640 tree ARG_UNUSED (args),
6641 int ARG_UNUSED (flags),
6642 bool * ARG_UNUSED (no_add_attrs))
6644 if (TREE_CODE (*node) == FUNCTION_DECL
6645 && DECL_DECLARED_INLINE_P (*node))
6647 error ("inline function %q+D cannot be declared weak", *node);
6648 *no_add_attrs = true;
6650 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6652 error ("indirect function %q+D cannot be declared weak", *node);
6653 *no_add_attrs = true;
6656 else if (TREE_CODE (*node) == FUNCTION_DECL
6657 || TREE_CODE (*node) == VAR_DECL)
6658 declare_weak (*node);
6660 warning (OPT_Wattributes, "%qE attribute ignored", name);
6665 /* Handle an "alias" or "ifunc" attribute; arguments as in
6666 struct attribute_spec.handler, except that IS_ALIAS tells us
6667 whether this is an alias as opposed to ifunc attribute. */
6670 handle_alias_ifunc_attribute (bool is_alias, tree *node, tree name, tree args,
6675 if (TREE_CODE (decl) != FUNCTION_DECL
6676 && (!is_alias || TREE_CODE (decl) != VAR_DECL))
6678 warning (OPT_Wattributes, "%qE attribute ignored", name);
6679 *no_add_attrs = true;
6681 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6682 || (TREE_CODE (decl) != FUNCTION_DECL
6683 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6684 /* A static variable declaration is always a tentative definition,
6685 but the alias is a non-tentative definition which overrides. */
6686 || (TREE_CODE (decl) != FUNCTION_DECL
6687 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6689 error ("%q+D defined both normally and as %qE attribute", decl, name);
6690 *no_add_attrs = true;
6694 && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
6695 || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))))
6697 error ("weak %q+D cannot be defined %qE", decl, name);
6698 *no_add_attrs = true;
6702 /* Note that the very first time we process a nested declaration,
6703 decl_function_context will not be set. Indeed, *would* never
6704 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6705 we do below. After such frobbery, pushdecl would set the context.
6706 In any case, this is never what we want. */
6707 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6711 id = TREE_VALUE (args);
6712 if (TREE_CODE (id) != STRING_CST)
6714 error ("attribute %qE argument not a string", name);
6715 *no_add_attrs = true;
6718 id = get_identifier (TREE_STRING_POINTER (id));
6719 /* This counts as a use of the object pointed to. */
6722 if (TREE_CODE (decl) == FUNCTION_DECL)
6723 DECL_INITIAL (decl) = error_mark_node;
6726 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6727 DECL_EXTERNAL (decl) = 1;
6729 DECL_EXTERNAL (decl) = 0;
6730 TREE_STATIC (decl) = 1;
6734 /* ifuncs are also aliases, so set that attribute too. */
6735 DECL_ATTRIBUTES (decl)
6736 = tree_cons (get_identifier ("alias"), args, DECL_ATTRIBUTES (decl));
6740 warning (OPT_Wattributes, "%qE attribute ignored", name);
6741 *no_add_attrs = true;
6747 /* Handle an "alias" or "ifunc" attribute; arguments as in
6748 struct attribute_spec.handler. */
6751 handle_ifunc_attribute (tree *node, tree name, tree args,
6752 int ARG_UNUSED (flags), bool *no_add_attrs)
6754 return handle_alias_ifunc_attribute (false, node, name, args, no_add_attrs);
6757 /* Handle an "alias" or "ifunc" attribute; arguments as in
6758 struct attribute_spec.handler. */
6761 handle_alias_attribute (tree *node, tree name, tree args,
6762 int ARG_UNUSED (flags), bool *no_add_attrs)
6764 return handle_alias_ifunc_attribute (true, node, name, args, no_add_attrs);
6767 /* Handle a "weakref" attribute; arguments as in struct
6768 attribute_spec.handler. */
6771 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6772 int flags, bool *no_add_attrs)
6774 tree attr = NULL_TREE;
6776 /* We must ignore the attribute when it is associated with
6777 local-scoped decls, since attribute alias is ignored and many
6778 such symbols do not even have a DECL_WEAK field. */
6779 if (decl_function_context (*node)
6780 || current_function_decl
6781 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6783 warning (OPT_Wattributes, "%qE attribute ignored", name);
6784 *no_add_attrs = true;
6788 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6790 error ("indirect function %q+D cannot be declared weakref", *node);
6791 *no_add_attrs = true;
6795 /* The idea here is that `weakref("name")' mutates into `weakref,
6796 alias("name")', and weakref without arguments, in turn,
6797 implicitly adds weak. */
6801 attr = tree_cons (get_identifier ("alias"), args, attr);
6802 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6804 *no_add_attrs = true;
6806 decl_attributes (node, attr, flags);
6810 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6811 error_at (DECL_SOURCE_LOCATION (*node),
6812 "weakref attribute must appear before alias attribute");
6814 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6815 and that isn't supported; and because it wants to add it to
6816 the list of weak decls, which isn't helpful. */
6817 DECL_WEAK (*node) = 1;
6823 /* Handle an "visibility" attribute; arguments as in
6824 struct attribute_spec.handler. */
6827 handle_visibility_attribute (tree *node, tree name, tree args,
6828 int ARG_UNUSED (flags),
6829 bool *ARG_UNUSED (no_add_attrs))
6832 tree id = TREE_VALUE (args);
6833 enum symbol_visibility vis;
6837 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6839 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6841 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6845 else if (TYPE_FIELDS (*node))
6847 error ("%qE attribute ignored because %qT is already defined",
6852 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6854 warning (OPT_Wattributes, "%qE attribute ignored", name);
6858 if (TREE_CODE (id) != STRING_CST)
6860 error ("visibility argument not a string");
6864 /* If this is a type, set the visibility on the type decl. */
6867 decl = TYPE_NAME (decl);
6870 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6872 warning (OPT_Wattributes, "%qE attribute ignored on types",
6878 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6879 vis = VISIBILITY_DEFAULT;
6880 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6881 vis = VISIBILITY_INTERNAL;
6882 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6883 vis = VISIBILITY_HIDDEN;
6884 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6885 vis = VISIBILITY_PROTECTED;
6888 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6889 vis = VISIBILITY_DEFAULT;
6892 if (DECL_VISIBILITY_SPECIFIED (decl)
6893 && vis != DECL_VISIBILITY (decl))
6895 tree attributes = (TYPE_P (*node)
6896 ? TYPE_ATTRIBUTES (*node)
6897 : DECL_ATTRIBUTES (decl));
6898 if (lookup_attribute ("visibility", attributes))
6899 error ("%qD redeclared with different visibility", decl);
6900 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6901 && lookup_attribute ("dllimport", attributes))
6902 error ("%qD was declared %qs which implies default visibility",
6904 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6905 && lookup_attribute ("dllexport", attributes))
6906 error ("%qD was declared %qs which implies default visibility",
6910 DECL_VISIBILITY (decl) = vis;
6911 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6913 /* Go ahead and attach the attribute to the node as well. This is needed
6914 so we can determine whether we have VISIBILITY_DEFAULT because the
6915 visibility was not specified, or because it was explicitly overridden
6916 from the containing scope. */
6921 /* Determine the ELF symbol visibility for DECL, which is either a
6922 variable or a function. It is an error to use this function if a
6923 definition of DECL is not available in this translation unit.
6924 Returns true if the final visibility has been determined by this
6925 function; false if the caller is free to make additional
6929 c_determine_visibility (tree decl)
6931 gcc_assert (TREE_CODE (decl) == VAR_DECL
6932 || TREE_CODE (decl) == FUNCTION_DECL);
6934 /* If the user explicitly specified the visibility with an
6935 attribute, honor that. DECL_VISIBILITY will have been set during
6936 the processing of the attribute. We check for an explicit
6937 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6938 to distinguish the use of an attribute from the use of a "#pragma
6939 GCC visibility push(...)"; in the latter case we still want other
6940 considerations to be able to overrule the #pragma. */
6941 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6942 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6943 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6944 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6947 /* Set default visibility to whatever the user supplied with
6948 visibility_specified depending on #pragma GCC visibility. */
6949 if (!DECL_VISIBILITY_SPECIFIED (decl))
6951 if (visibility_options.inpragma
6952 || DECL_VISIBILITY (decl) != default_visibility)
6954 DECL_VISIBILITY (decl) = default_visibility;
6955 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6956 /* If visibility changed and DECL already has DECL_RTL, ensure
6957 symbol flags are updated. */
6958 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6959 || TREE_CODE (decl) == FUNCTION_DECL)
6960 && DECL_RTL_SET_P (decl))
6961 make_decl_rtl (decl);
6967 /* Handle an "tls_model" attribute; arguments as in
6968 struct attribute_spec.handler. */
6971 handle_tls_model_attribute (tree *node, tree name, tree args,
6972 int ARG_UNUSED (flags), bool *no_add_attrs)
6976 enum tls_model kind;
6978 *no_add_attrs = true;
6980 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
6982 warning (OPT_Wattributes, "%qE attribute ignored", name);
6986 kind = DECL_TLS_MODEL (decl);
6987 id = TREE_VALUE (args);
6988 if (TREE_CODE (id) != STRING_CST)
6990 error ("tls_model argument not a string");
6994 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
6995 kind = TLS_MODEL_LOCAL_EXEC;
6996 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
6997 kind = TLS_MODEL_INITIAL_EXEC;
6998 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
6999 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7000 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7001 kind = TLS_MODEL_GLOBAL_DYNAMIC;
7003 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7005 DECL_TLS_MODEL (decl) = kind;
7009 /* Handle a "no_instrument_function" attribute; arguments as in
7010 struct attribute_spec.handler. */
7013 handle_no_instrument_function_attribute (tree *node, tree name,
7014 tree ARG_UNUSED (args),
7015 int ARG_UNUSED (flags),
7020 if (TREE_CODE (decl) != FUNCTION_DECL)
7022 error_at (DECL_SOURCE_LOCATION (decl),
7023 "%qE attribute applies only to functions", name);
7024 *no_add_attrs = true;
7026 else if (DECL_INITIAL (decl))
7028 error_at (DECL_SOURCE_LOCATION (decl),
7029 "can%'t set %qE attribute after definition", name);
7030 *no_add_attrs = true;
7033 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7038 /* Handle a "malloc" attribute; arguments as in
7039 struct attribute_spec.handler. */
7042 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7043 int ARG_UNUSED (flags), bool *no_add_attrs)
7045 if (TREE_CODE (*node) == FUNCTION_DECL
7046 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
7047 DECL_IS_MALLOC (*node) = 1;
7050 warning (OPT_Wattributes, "%qE attribute ignored", name);
7051 *no_add_attrs = true;
7057 /* Handle a "alloc_size" attribute; arguments as in
7058 struct attribute_spec.handler. */
7061 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7062 int ARG_UNUSED (flags), bool *no_add_attrs)
7064 unsigned arg_count = type_num_arguments (*node);
7065 for (; args; args = TREE_CHAIN (args))
7067 tree position = TREE_VALUE (args);
7069 if (TREE_CODE (position) != INTEGER_CST
7070 || TREE_INT_CST_HIGH (position)
7071 || TREE_INT_CST_LOW (position) < 1
7072 || TREE_INT_CST_LOW (position) > arg_count )
7074 warning (OPT_Wattributes,
7075 "alloc_size parameter outside range");
7076 *no_add_attrs = true;
7083 /* Handle a "fn spec" attribute; arguments as in
7084 struct attribute_spec.handler. */
7087 handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
7088 tree args, int ARG_UNUSED (flags),
7089 bool *no_add_attrs ATTRIBUTE_UNUSED)
7092 && TREE_CODE (TREE_VALUE (args)) == STRING_CST
7093 && !TREE_CHAIN (args));
7097 /* Handle a "returns_twice" attribute; arguments as in
7098 struct attribute_spec.handler. */
7101 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7102 int ARG_UNUSED (flags), bool *no_add_attrs)
7104 if (TREE_CODE (*node) == FUNCTION_DECL)
7105 DECL_IS_RETURNS_TWICE (*node) = 1;
7108 warning (OPT_Wattributes, "%qE attribute ignored", name);
7109 *no_add_attrs = true;
7115 /* Handle a "no_limit_stack" attribute; arguments as in
7116 struct attribute_spec.handler. */
7119 handle_no_limit_stack_attribute (tree *node, tree name,
7120 tree ARG_UNUSED (args),
7121 int ARG_UNUSED (flags),
7126 if (TREE_CODE (decl) != FUNCTION_DECL)
7128 error_at (DECL_SOURCE_LOCATION (decl),
7129 "%qE attribute applies only to functions", name);
7130 *no_add_attrs = true;
7132 else if (DECL_INITIAL (decl))
7134 error_at (DECL_SOURCE_LOCATION (decl),
7135 "can%'t set %qE attribute after definition", name);
7136 *no_add_attrs = true;
7139 DECL_NO_LIMIT_STACK (decl) = 1;
7144 /* Handle a "pure" attribute; arguments as in
7145 struct attribute_spec.handler. */
7148 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7149 int ARG_UNUSED (flags), bool *no_add_attrs)
7151 if (TREE_CODE (*node) == FUNCTION_DECL)
7152 DECL_PURE_P (*node) = 1;
7153 /* ??? TODO: Support types. */
7156 warning (OPT_Wattributes, "%qE attribute ignored", name);
7157 *no_add_attrs = true;
7163 /* Handle a "no vops" attribute; arguments as in
7164 struct attribute_spec.handler. */
7167 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7168 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7169 bool *ARG_UNUSED (no_add_attrs))
7171 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7172 DECL_IS_NOVOPS (*node) = 1;
7176 /* Handle a "deprecated" attribute; arguments as in
7177 struct attribute_spec.handler. */
7180 handle_deprecated_attribute (tree *node, tree name,
7181 tree args, int flags,
7184 tree type = NULL_TREE;
7186 tree what = NULL_TREE;
7189 *no_add_attrs = true;
7190 else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
7192 error ("deprecated message is not a string");
7193 *no_add_attrs = true;
7199 type = TREE_TYPE (decl);
7201 if (TREE_CODE (decl) == TYPE_DECL
7202 || TREE_CODE (decl) == PARM_DECL
7203 || TREE_CODE (decl) == VAR_DECL
7204 || TREE_CODE (decl) == FUNCTION_DECL
7205 || TREE_CODE (decl) == FIELD_DECL
7206 || objc_method_decl (TREE_CODE (decl)))
7207 TREE_DEPRECATED (decl) = 1;
7211 else if (TYPE_P (*node))
7213 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
7214 *node = build_variant_type_copy (*node);
7215 TREE_DEPRECATED (*node) = 1;
7223 *no_add_attrs = true;
7224 if (type && TYPE_NAME (type))
7226 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7227 what = TYPE_NAME (*node);
7228 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7229 && DECL_NAME (TYPE_NAME (type)))
7230 what = DECL_NAME (TYPE_NAME (type));
7233 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
7235 warning (OPT_Wattributes, "%qE attribute ignored", name);
7241 /* Handle a "vector_size" attribute; arguments as in
7242 struct attribute_spec.handler. */
7245 handle_vector_size_attribute (tree *node, tree name, tree args,
7246 int ARG_UNUSED (flags),
7249 unsigned HOST_WIDE_INT vecsize, nunits;
7250 enum machine_mode orig_mode;
7251 tree type = *node, new_type, size;
7253 *no_add_attrs = true;
7255 size = TREE_VALUE (args);
7257 if (!host_integerp (size, 1))
7259 warning (OPT_Wattributes, "%qE attribute ignored", name);
7263 /* Get the vector size (in bytes). */
7264 vecsize = tree_low_cst (size, 1);
7266 /* We need to provide for vector pointers, vector arrays, and
7267 functions returning vectors. For example:
7269 __attribute__((vector_size(16))) short *foo;
7271 In this case, the mode is SI, but the type being modified is
7272 HI, so we need to look further. */
7274 while (POINTER_TYPE_P (type)
7275 || TREE_CODE (type) == FUNCTION_TYPE
7276 || TREE_CODE (type) == METHOD_TYPE
7277 || TREE_CODE (type) == ARRAY_TYPE
7278 || TREE_CODE (type) == OFFSET_TYPE)
7279 type = TREE_TYPE (type);
7281 /* Get the mode of the type being modified. */
7282 orig_mode = TYPE_MODE (type);
7284 if ((!INTEGRAL_TYPE_P (type)
7285 && !SCALAR_FLOAT_TYPE_P (type)
7286 && !FIXED_POINT_TYPE_P (type))
7287 || (!SCALAR_FLOAT_MODE_P (orig_mode)
7288 && GET_MODE_CLASS (orig_mode) != MODE_INT
7289 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7290 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7291 || TREE_CODE (type) == BOOLEAN_TYPE)
7293 error ("invalid vector type for attribute %qE", name);
7297 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7299 error ("vector size not an integral multiple of component size");
7305 error ("zero vector size");
7309 /* Calculate how many units fit in the vector. */
7310 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7311 if (nunits & (nunits - 1))
7313 error ("number of components of the vector not a power of two");
7317 new_type = build_vector_type (type, nunits);
7319 /* Build back pointers if needed. */
7320 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
7325 /* Handle the "nonnull" attribute. */
7327 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7328 tree args, int ARG_UNUSED (flags),
7332 unsigned HOST_WIDE_INT attr_arg_num;
7334 /* If no arguments are specified, all pointer arguments should be
7335 non-null. Verify a full prototype is given so that the arguments
7336 will have the correct types when we actually check them later. */
7339 if (!TYPE_ARG_TYPES (type))
7341 error ("nonnull attribute without arguments on a non-prototype");
7342 *no_add_attrs = true;
7347 /* Argument list specified. Verify that each argument number references
7348 a pointer argument. */
7349 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7352 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
7354 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
7356 error ("nonnull argument has invalid operand number (argument %lu)",
7357 (unsigned long) attr_arg_num);
7358 *no_add_attrs = true;
7362 argument = TYPE_ARG_TYPES (type);
7365 for (ck_num = 1; ; ck_num++)
7367 if (!argument || ck_num == arg_num)
7369 argument = TREE_CHAIN (argument);
7373 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7375 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7376 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7377 *no_add_attrs = true;
7381 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
7383 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7384 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7385 *no_add_attrs = true;
7394 /* Check the argument list of a function call for null in argument slots
7395 that are marked as requiring a non-null pointer argument. The NARGS
7396 arguments are passed in the array ARGARRAY.
7400 check_function_nonnull (tree attrs, int nargs, tree *argarray)
7405 for (a = attrs; a; a = TREE_CHAIN (a))
7407 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7409 args = TREE_VALUE (a);
7411 /* Walk the argument list. If we encounter an argument number we
7412 should check for non-null, do it. If the attribute has no args,
7413 then every pointer argument is checked (in which case the check
7414 for pointer type is done in check_nonnull_arg). */
7415 for (i = 0; i < nargs; i++)
7417 if (!args || nonnull_check_p (args, i + 1))
7418 check_function_arguments_recurse (check_nonnull_arg, NULL,
7426 /* Check that the Nth argument of a function call (counting backwards
7427 from the end) is a (pointer)0. The NARGS arguments are passed in the
7431 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
7433 tree attr = lookup_attribute ("sentinel", attrs);
7441 /* Skip over the named arguments. */
7442 while (typelist && len < nargs)
7444 typelist = TREE_CHAIN (typelist);
7448 if (TREE_VALUE (attr))
7450 tree p = TREE_VALUE (TREE_VALUE (attr));
7451 pos = TREE_INT_CST_LOW (p);
7454 /* The sentinel must be one of the varargs, i.e.
7455 in position >= the number of fixed arguments. */
7456 if ((nargs - 1 - pos) < len)
7458 warning (OPT_Wformat,
7459 "not enough variable arguments to fit a sentinel");
7463 /* Validate the sentinel. */
7464 sentinel = argarray[nargs - 1 - pos];
7465 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7466 || !integer_zerop (sentinel))
7467 /* Although __null (in C++) is only an integer we allow it
7468 nevertheless, as we are guaranteed that it's exactly
7469 as wide as a pointer, and we don't want to force
7470 users to cast the NULL they have written there.
7471 We warn with -Wstrict-null-sentinel, though. */
7472 && (warn_strict_null_sentinel || null_node != sentinel))
7473 warning (OPT_Wformat, "missing sentinel in function call");
7477 /* Helper for check_function_nonnull; given a list of operands which
7478 must be non-null in ARGS, determine if operand PARAM_NUM should be
7482 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
7484 unsigned HOST_WIDE_INT arg_num = 0;
7486 for (; args; args = TREE_CHAIN (args))
7488 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7492 if (arg_num == param_num)
7498 /* Check that the function argument PARAM (which is operand number
7499 PARAM_NUM) is non-null. This is called by check_function_nonnull
7500 via check_function_arguments_recurse. */
7503 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
7504 unsigned HOST_WIDE_INT param_num)
7506 /* Just skip checking the argument if it's not a pointer. This can
7507 happen if the "nonnull" attribute was given without an operand
7508 list (which means to check every pointer argument). */
7510 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7513 if (integer_zerop (param))
7514 warning (OPT_Wnonnull, "null argument where non-null required "
7515 "(argument %lu)", (unsigned long) param_num);
7518 /* Helper for nonnull attribute handling; fetch the operand number
7519 from the attribute argument list. */
7522 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
7524 /* Verify the arg number is a constant. */
7525 if (TREE_CODE (arg_num_expr) != INTEGER_CST
7526 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7529 *valp = TREE_INT_CST_LOW (arg_num_expr);
7533 /* Handle a "nothrow" attribute; arguments as in
7534 struct attribute_spec.handler. */
7537 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7538 int ARG_UNUSED (flags), bool *no_add_attrs)
7540 if (TREE_CODE (*node) == FUNCTION_DECL)
7541 TREE_NOTHROW (*node) = 1;
7542 /* ??? TODO: Support types. */
7545 warning (OPT_Wattributes, "%qE attribute ignored", name);
7546 *no_add_attrs = true;
7552 /* Handle a "cleanup" attribute; arguments as in
7553 struct attribute_spec.handler. */
7556 handle_cleanup_attribute (tree *node, tree name, tree args,
7557 int ARG_UNUSED (flags), bool *no_add_attrs)
7560 tree cleanup_id, cleanup_decl;
7562 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7563 for global destructors in C++. This requires infrastructure that
7564 we don't have generically at the moment. It's also not a feature
7565 we'd be missing too much, since we do have attribute constructor. */
7566 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7568 warning (OPT_Wattributes, "%qE attribute ignored", name);
7569 *no_add_attrs = true;
7573 /* Verify that the argument is a function in scope. */
7574 /* ??? We could support pointers to functions here as well, if
7575 that was considered desirable. */
7576 cleanup_id = TREE_VALUE (args);
7577 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7579 error ("cleanup argument not an identifier");
7580 *no_add_attrs = true;
7583 cleanup_decl = lookup_name (cleanup_id);
7584 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7586 error ("cleanup argument not a function");
7587 *no_add_attrs = true;
7591 /* That the function has proper type is checked with the
7592 eventual call to build_function_call. */
7597 /* Handle a "warn_unused_result" attribute. No special handling. */
7600 handle_warn_unused_result_attribute (tree *node, tree name,
7601 tree ARG_UNUSED (args),
7602 int ARG_UNUSED (flags), bool *no_add_attrs)
7604 /* Ignore the attribute for functions not returning any value. */
7605 if (VOID_TYPE_P (TREE_TYPE (*node)))
7607 warning (OPT_Wattributes, "%qE attribute ignored", name);
7608 *no_add_attrs = true;
7614 /* Handle a "sentinel" attribute. */
7617 handle_sentinel_attribute (tree *node, tree name, tree args,
7618 int ARG_UNUSED (flags), bool *no_add_attrs)
7620 tree params = TYPE_ARG_TYPES (*node);
7624 warning (OPT_Wattributes,
7625 "%qE attribute requires prototypes with named arguments", name);
7626 *no_add_attrs = true;
7630 while (TREE_CHAIN (params))
7631 params = TREE_CHAIN (params);
7633 if (VOID_TYPE_P (TREE_VALUE (params)))
7635 warning (OPT_Wattributes,
7636 "%qE attribute only applies to variadic functions", name);
7637 *no_add_attrs = true;
7643 tree position = TREE_VALUE (args);
7645 if (TREE_CODE (position) != INTEGER_CST)
7647 warning (OPT_Wattributes,
7648 "requested position is not an integer constant");
7649 *no_add_attrs = true;
7653 if (tree_int_cst_lt (position, integer_zero_node))
7655 warning (OPT_Wattributes,
7656 "requested position is less than zero");
7657 *no_add_attrs = true;
7665 /* Handle a "type_generic" attribute. */
7668 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7669 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7670 bool * ARG_UNUSED (no_add_attrs))
7674 /* Ensure we have a function type. */
7675 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
7677 params = TYPE_ARG_TYPES (*node);
7678 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7679 params = TREE_CHAIN (params);
7681 /* Ensure we have a variadic function. */
7682 gcc_assert (!params);
7687 /* Handle a "target" attribute. */
7690 handle_target_attribute (tree *node, tree name, tree args, int flags,
7693 /* Ensure we have a function type. */
7694 if (TREE_CODE (*node) != FUNCTION_DECL)
7696 warning (OPT_Wattributes, "%qE attribute ignored", name);
7697 *no_add_attrs = true;
7699 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7701 *no_add_attrs = true;
7706 /* Arguments being collected for optimization. */
7707 typedef const char *const_char_p; /* For DEF_VEC_P. */
7708 DEF_VEC_P(const_char_p);
7709 DEF_VEC_ALLOC_P(const_char_p, gc);
7710 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7713 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7714 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7715 false for #pragma GCC optimize. */
7718 parse_optimize_options (tree args, bool attr_p)
7723 int saved_flag_strict_aliasing;
7724 const char **opt_argv;
7725 struct cl_decoded_option *decoded_options;
7726 unsigned int decoded_options_count;
7729 /* Build up argv vector. Just in case the string is stored away, use garbage
7730 collected strings. */
7731 VEC_truncate (const_char_p, optimize_args, 0);
7732 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7734 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7736 tree value = TREE_VALUE (ap);
7738 if (TREE_CODE (value) == INTEGER_CST)
7741 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7742 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7745 else if (TREE_CODE (value) == STRING_CST)
7747 /* Split string into multiple substrings. */
7748 size_t len = TREE_STRING_LENGTH (value);
7749 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7750 char *end = p + len;
7754 while (next_p != NULL)
7760 comma = strchr (p, ',');
7773 r = q = (char *) ggc_alloc_atomic (len2 + 3);
7775 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7777 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7781 warning (OPT_Wattributes,
7782 "bad option %s to optimize attribute", p);
7784 warning (OPT_Wpragmas,
7785 "bad option %s to pragma attribute", p);
7793 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7794 itself is -Os, and any other switch begins with a -f. */
7795 if ((*p >= '0' && *p <= '9')
7796 || (p[0] == 's' && p[1] == '\0'))
7802 memcpy (r, p, len2);
7804 VEC_safe_push (const_char_p, gc, optimize_args, q);
7810 opt_argc = VEC_length (const_char_p, optimize_args);
7811 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7813 for (i = 1; i < opt_argc; i++)
7814 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7816 saved_flag_strict_aliasing = flag_strict_aliasing;
7818 /* Now parse the options. */
7819 decode_cmdline_options_to_array_default_mask (opt_argc, opt_argv,
7821 &decoded_options_count);
7822 decode_options (&global_options, &global_options_set,
7823 decoded_options, decoded_options_count,
7824 input_location, global_dc);
7826 targetm.override_options_after_change();
7828 /* Don't allow changing -fstrict-aliasing. */
7829 flag_strict_aliasing = saved_flag_strict_aliasing;
7831 VEC_truncate (const_char_p, optimize_args, 0);
7835 /* For handling "optimize" attribute. arguments as in
7836 struct attribute_spec.handler. */
7839 handle_optimize_attribute (tree *node, tree name, tree args,
7840 int ARG_UNUSED (flags), bool *no_add_attrs)
7842 /* Ensure we have a function type. */
7843 if (TREE_CODE (*node) != FUNCTION_DECL)
7845 warning (OPT_Wattributes, "%qE attribute ignored", name);
7846 *no_add_attrs = true;
7850 struct cl_optimization cur_opts;
7851 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7853 /* Save current options. */
7854 cl_optimization_save (&cur_opts, &global_options);
7856 /* If we previously had some optimization options, use them as the
7859 cl_optimization_restore (&global_options,
7860 TREE_OPTIMIZATION (old_opts));
7862 /* Parse options, and update the vector. */
7863 parse_optimize_options (args, true);
7864 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7865 = build_optimization_node ();
7867 /* Restore current options. */
7868 cl_optimization_restore (&global_options, &cur_opts);
7874 /* Handle a "no_split_stack" attribute. */
7877 handle_no_split_stack_attribute (tree *node, tree name,
7878 tree ARG_UNUSED (args),
7879 int ARG_UNUSED (flags),
7884 if (TREE_CODE (decl) != FUNCTION_DECL)
7886 error_at (DECL_SOURCE_LOCATION (decl),
7887 "%qE attribute applies only to functions", name);
7888 *no_add_attrs = true;
7890 else if (DECL_INITIAL (decl))
7892 error_at (DECL_SOURCE_LOCATION (decl),
7893 "can%'t set %qE attribute after definition", name);
7894 *no_add_attrs = true;
7900 /* Check for valid arguments being passed to a function.
7901 ATTRS is a list of attributes. There are NARGS arguments in the array
7902 ARGARRAY. TYPELIST is the list of argument types for the function.
7905 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7907 /* Check for null being passed in a pointer argument that must be
7908 non-null. We also need to do this if format checking is enabled. */
7911 check_function_nonnull (attrs, nargs, argarray);
7913 /* Check for errors in format strings. */
7915 if (warn_format || warn_missing_format_attribute)
7916 check_function_format (attrs, nargs, argarray);
7919 check_function_sentinel (attrs, nargs, argarray, typelist);
7922 /* Generic argument checking recursion routine. PARAM is the argument to
7923 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7924 once the argument is resolved. CTX is context for the callback. */
7926 check_function_arguments_recurse (void (*callback)
7927 (void *, tree, unsigned HOST_WIDE_INT),
7928 void *ctx, tree param,
7929 unsigned HOST_WIDE_INT param_num)
7931 if (CONVERT_EXPR_P (param)
7932 && (TYPE_PRECISION (TREE_TYPE (param))
7933 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7935 /* Strip coercion. */
7936 check_function_arguments_recurse (callback, ctx,
7937 TREE_OPERAND (param, 0), param_num);
7941 if (TREE_CODE (param) == CALL_EXPR)
7943 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7945 bool found_format_arg = false;
7947 /* See if this is a call to a known internationalization function
7948 that modifies a format arg. Such a function may have multiple
7949 format_arg attributes (for example, ngettext). */
7951 for (attrs = TYPE_ATTRIBUTES (type);
7953 attrs = TREE_CHAIN (attrs))
7954 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7957 tree format_num_expr;
7960 call_expr_arg_iterator iter;
7962 /* Extract the argument number, which was previously checked
7964 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7966 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7967 && !TREE_INT_CST_HIGH (format_num_expr));
7969 format_num = TREE_INT_CST_LOW (format_num_expr);
7971 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7973 inner_arg = next_call_expr_arg (&iter), i++)
7974 if (i == format_num)
7976 check_function_arguments_recurse (callback, ctx,
7977 inner_arg, param_num);
7978 found_format_arg = true;
7983 /* If we found a format_arg attribute and did a recursive check,
7984 we are done with checking this argument. Otherwise, we continue
7985 and this will be considered a non-literal. */
7986 if (found_format_arg)
7990 if (TREE_CODE (param) == COND_EXPR)
7992 /* Check both halves of the conditional expression. */
7993 check_function_arguments_recurse (callback, ctx,
7994 TREE_OPERAND (param, 1), param_num);
7995 check_function_arguments_recurse (callback, ctx,
7996 TREE_OPERAND (param, 2), param_num);
8000 (*callback) (ctx, param, param_num);
8003 /* Checks for a builtin function FNDECL that the number of arguments
8004 NARGS against the required number REQUIRED and issues an error if
8005 there is a mismatch. Returns true if the number of arguments is
8006 correct, otherwise false. */
8009 builtin_function_validate_nargs (tree fndecl, int nargs, int required)
8011 if (nargs < required)
8013 error_at (input_location,
8014 "not enough arguments to function %qE", fndecl);
8017 else if (nargs > required)
8019 error_at (input_location,
8020 "too many arguments to function %qE", fndecl);
8026 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
8027 Returns false if there was an error, otherwise true. */
8030 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
8032 if (!DECL_BUILT_IN (fndecl)
8033 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
8036 switch (DECL_FUNCTION_CODE (fndecl))
8038 case BUILT_IN_CONSTANT_P:
8039 return builtin_function_validate_nargs (fndecl, nargs, 1);
8041 case BUILT_IN_ISFINITE:
8042 case BUILT_IN_ISINF:
8043 case BUILT_IN_ISINF_SIGN:
8044 case BUILT_IN_ISNAN:
8045 case BUILT_IN_ISNORMAL:
8046 if (builtin_function_validate_nargs (fndecl, nargs, 1))
8048 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8050 error ("non-floating-point argument in call to "
8051 "function %qE", fndecl);
8058 case BUILT_IN_ISGREATER:
8059 case BUILT_IN_ISGREATEREQUAL:
8060 case BUILT_IN_ISLESS:
8061 case BUILT_IN_ISLESSEQUAL:
8062 case BUILT_IN_ISLESSGREATER:
8063 case BUILT_IN_ISUNORDERED:
8064 if (builtin_function_validate_nargs (fndecl, nargs, 2))
8066 enum tree_code code0, code1;
8067 code0 = TREE_CODE (TREE_TYPE (args[0]));
8068 code1 = TREE_CODE (TREE_TYPE (args[1]));
8069 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8070 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8071 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8073 error ("non-floating-point arguments in call to "
8074 "function %qE", fndecl);
8081 case BUILT_IN_FPCLASSIFY:
8082 if (builtin_function_validate_nargs (fndecl, nargs, 6))
8087 if (TREE_CODE (args[i]) != INTEGER_CST)
8089 error ("non-const integer argument %u in call to function %qE",
8094 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8096 error ("non-floating-point argument in call to function %qE",
8109 /* Function to help qsort sort FIELD_DECLs by name order. */
8112 field_decl_cmp (const void *x_p, const void *y_p)
8114 const tree *const x = (const tree *const) x_p;
8115 const tree *const y = (const tree *const) y_p;
8117 if (DECL_NAME (*x) == DECL_NAME (*y))
8118 /* A nontype is "greater" than a type. */
8119 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8120 if (DECL_NAME (*x) == NULL_TREE)
8122 if (DECL_NAME (*y) == NULL_TREE)
8124 if (DECL_NAME (*x) < DECL_NAME (*y))
8130 gt_pointer_operator new_value;
8134 /* This routine compares two fields like field_decl_cmp but using the
8135 pointer operator in resort_data. */
8138 resort_field_decl_cmp (const void *x_p, const void *y_p)
8140 const tree *const x = (const tree *const) x_p;
8141 const tree *const y = (const tree *const) y_p;
8143 if (DECL_NAME (*x) == DECL_NAME (*y))
8144 /* A nontype is "greater" than a type. */
8145 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8146 if (DECL_NAME (*x) == NULL_TREE)
8148 if (DECL_NAME (*y) == NULL_TREE)
8151 tree d1 = DECL_NAME (*x);
8152 tree d2 = DECL_NAME (*y);
8153 resort_data.new_value (&d1, resort_data.cookie);
8154 resort_data.new_value (&d2, resort_data.cookie);
8161 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8164 resort_sorted_fields (void *obj,
8165 void * ARG_UNUSED (orig_obj),
8166 gt_pointer_operator new_value,
8169 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
8170 resort_data.new_value = new_value;
8171 resort_data.cookie = cookie;
8172 qsort (&sf->elts[0], sf->len, sizeof (tree),
8173 resort_field_decl_cmp);
8176 /* Subroutine of c_parse_error.
8177 Return the result of concatenating LHS and RHS. RHS is really
8178 a string literal, its first character is indicated by RHS_START and
8179 RHS_SIZE is its length (including the terminating NUL character).
8181 The caller is responsible for deleting the returned pointer. */
8184 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8186 const int lhs_size = strlen (lhs);
8187 char *result = XNEWVEC (char, lhs_size + rhs_size);
8188 strncpy (result, lhs, lhs_size);
8189 strncpy (result + lhs_size, rhs_start, rhs_size);
8193 /* Issue the error given by GMSGID, indicating that it occurred before
8194 TOKEN, which had the associated VALUE. */
8197 c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
8198 tree value, unsigned char token_flags)
8200 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8202 char *message = NULL;
8204 if (token_type == CPP_EOF)
8205 message = catenate_messages (gmsgid, " at end of input");
8206 else if (token_type == CPP_CHAR
8207 || token_type == CPP_WCHAR
8208 || token_type == CPP_CHAR16
8209 || token_type == CPP_CHAR32)
8211 unsigned int val = TREE_INT_CST_LOW (value);
8230 if (val <= UCHAR_MAX && ISGRAPH (val))
8231 message = catenate_messages (gmsgid, " before %s'%c'");
8233 message = catenate_messages (gmsgid, " before %s'\\x%x'");
8235 error (message, prefix, val);
8239 else if (token_type == CPP_STRING
8240 || token_type == CPP_WSTRING
8241 || token_type == CPP_STRING16
8242 || token_type == CPP_STRING32
8243 || token_type == CPP_UTF8STRING)
8244 message = catenate_messages (gmsgid, " before string constant");
8245 else if (token_type == CPP_NUMBER)
8246 message = catenate_messages (gmsgid, " before numeric constant");
8247 else if (token_type == CPP_NAME)
8249 message = catenate_messages (gmsgid, " before %qE");
8250 error (message, value);
8254 else if (token_type == CPP_PRAGMA)
8255 message = catenate_messages (gmsgid, " before %<#pragma%>");
8256 else if (token_type == CPP_PRAGMA_EOL)
8257 message = catenate_messages (gmsgid, " before end of line");
8258 else if (token_type < N_TTYPES)
8260 message = catenate_messages (gmsgid, " before %qs token");
8261 error (message, cpp_type2name (token_type, token_flags));
8273 #undef catenate_messages
8276 /* Mapping for cpp message reasons to the options that enable them. */
8278 struct reason_option_codes_t
8280 const int reason; /* cpplib message reason. */
8281 const int option_code; /* gcc option that controls this message. */
8284 static const struct reason_option_codes_t option_codes[] = {
8285 {CPP_W_DEPRECATED, OPT_Wdeprecated},
8286 {CPP_W_COMMENTS, OPT_Wcomment},
8287 {CPP_W_TRIGRAPHS, OPT_Wtrigraphs},
8288 {CPP_W_MULTICHAR, OPT_Wmultichar},
8289 {CPP_W_TRADITIONAL, OPT_Wtraditional},
8290 {CPP_W_LONG_LONG, OPT_Wlong_long},
8291 {CPP_W_ENDIF_LABELS, OPT_Wendif_labels},
8292 {CPP_W_VARIADIC_MACROS, OPT_Wvariadic_macros},
8293 {CPP_W_BUILTIN_MACRO_REDEFINED, OPT_Wbuiltin_macro_redefined},
8294 {CPP_W_UNDEF, OPT_Wundef},
8295 {CPP_W_UNUSED_MACROS, OPT_Wunused_macros},
8296 {CPP_W_CXX_OPERATOR_NAMES, OPT_Wc___compat},
8297 {CPP_W_NORMALIZE, OPT_Wnormalized_},
8298 {CPP_W_INVALID_PCH, OPT_Winvalid_pch},
8299 {CPP_W_WARNING_DIRECTIVE, OPT_Wcpp},
8303 /* Return the gcc option code associated with the reason for a cpp
8304 message, or 0 if none. */
8307 c_option_controlling_cpp_error (int reason)
8309 const struct reason_option_codes_t *entry;
8311 for (entry = option_codes; entry->reason != CPP_W_NONE; entry++)
8313 if (entry->reason == reason)
8314 return entry->option_code;
8319 /* Callback from cpp_error for PFILE to print diagnostics from the
8320 preprocessor. The diagnostic is of type LEVEL, with REASON set
8321 to the reason code if LEVEL is represents a warning, at location
8322 LOCATION unless this is after lexing and the compiler's location
8323 should be used instead, with column number possibly overridden by
8324 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8325 the arguments. Returns true if a diagnostic was emitted, false
8329 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
8330 location_t location, unsigned int column_override,
8331 const char *msg, va_list *ap)
8333 diagnostic_info diagnostic;
8334 diagnostic_t dlevel;
8335 bool save_warn_system_headers = global_dc->dc_warn_system_headers;
8340 case CPP_DL_WARNING_SYSHDR:
8343 global_dc->dc_warn_system_headers = 1;
8345 case CPP_DL_WARNING:
8348 dlevel = DK_WARNING;
8350 case CPP_DL_PEDWARN:
8351 if (flag_no_output && !flag_pedantic_errors)
8353 dlevel = DK_PEDWARN;
8371 location = input_location;
8372 diagnostic_set_info_translated (&diagnostic, msg, ap,
8374 if (column_override)
8375 diagnostic_override_column (&diagnostic, column_override);
8376 diagnostic_override_option_index (&diagnostic,
8377 c_option_controlling_cpp_error (reason));
8378 ret = report_diagnostic (&diagnostic);
8379 if (level == CPP_DL_WARNING_SYSHDR)
8380 global_dc->dc_warn_system_headers = save_warn_system_headers;
8384 /* Convert a character from the host to the target execution character
8385 set. cpplib handles this, mostly. */
8388 c_common_to_target_charset (HOST_WIDE_INT c)
8390 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8391 zero-extended under -fno-signed-char. cpplib insists that characters
8392 and character constants are always unsigned. Hence we must convert
8394 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8396 uc = cpp_host_to_exec_charset (parse_in, uc);
8398 if (flag_signed_char)
8399 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8400 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8405 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8406 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8407 NULL, at the bottom; much like the traditional rendering of offsetof as a
8408 macro. Returns the folded and properly cast result. */
8411 fold_offsetof_1 (tree expr, tree stop_ref)
8413 enum tree_code code = PLUS_EXPR;
8416 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8417 return size_zero_node;
8419 switch (TREE_CODE (expr))
8425 error ("cannot apply %<offsetof%> to static data member %qD", expr);
8426 return error_mark_node;
8430 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8431 return error_mark_node;
8435 if (!integer_zerop (TREE_OPERAND (expr, 0)))
8437 error ("cannot apply %<offsetof%> to a non constant address");
8438 return error_mark_node;
8440 return size_zero_node;
8443 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8444 if (base == error_mark_node)
8447 t = TREE_OPERAND (expr, 1);
8448 if (DECL_C_BIT_FIELD (t))
8450 error ("attempt to take address of bit-field structure "
8452 return error_mark_node;
8454 off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t),
8455 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t),
8461 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8462 if (base == error_mark_node)
8465 t = TREE_OPERAND (expr, 1);
8466 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8469 t = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (t), t);
8471 t = convert (sizetype, t);
8472 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8474 /* Check if the offset goes beyond the upper bound of the array. */
8475 if (code == PLUS_EXPR && TREE_CODE (t) == INTEGER_CST)
8477 tree upbound = array_ref_up_bound (expr);
8478 if (upbound != NULL_TREE
8479 && TREE_CODE (upbound) == INTEGER_CST
8480 && !tree_int_cst_equal (upbound,
8481 TYPE_MAX_VALUE (TREE_TYPE (upbound))))
8483 upbound = size_binop (PLUS_EXPR, upbound,
8484 build_int_cst (TREE_TYPE (upbound), 1));
8485 if (tree_int_cst_lt (upbound, t))
8489 for (v = TREE_OPERAND (expr, 0);
8490 TREE_CODE (v) == COMPONENT_REF;
8491 v = TREE_OPERAND (v, 0))
8492 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
8495 tree fld_chain = DECL_CHAIN (TREE_OPERAND (v, 1));
8496 for (; fld_chain; fld_chain = DECL_CHAIN (fld_chain))
8497 if (TREE_CODE (fld_chain) == FIELD_DECL)
8503 /* Don't warn if the array might be considered a poor
8504 man's flexible array member with a very permissive
8505 definition thereof. */
8506 if (TREE_CODE (v) == ARRAY_REF
8507 || TREE_CODE (v) == COMPONENT_REF)
8508 warning (OPT_Warray_bounds,
8509 "index %E denotes an offset "
8510 "greater than size of %qT",
8511 t, TREE_TYPE (TREE_OPERAND (expr, 0)));
8518 /* Handle static members of volatile structs. */
8519 t = TREE_OPERAND (expr, 1);
8520 gcc_assert (TREE_CODE (t) == VAR_DECL);
8521 return fold_offsetof_1 (t, stop_ref);
8527 return size_binop (code, base, off);
8531 fold_offsetof (tree expr, tree stop_ref)
8533 /* Convert back from the internal sizetype to size_t. */
8534 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
8537 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
8538 expression, because B will always be true. */
8541 warn_for_omitted_condop (location_t location, tree cond)
8543 if (truth_value_p (TREE_CODE (cond)))
8544 warning_at (location, OPT_Wparentheses,
8545 "the omitted middle operand in ?: will always be %<true%>, "
8546 "suggest explicit middle operand");
8549 /* Print an error message for an invalid lvalue. USE says
8550 how the lvalue is being used and so selects the error message. */
8553 lvalue_error (enum lvalue_use use)
8558 error ("lvalue required as left operand of assignment");
8561 error ("lvalue required as increment operand");
8564 error ("lvalue required as decrement operand");
8567 error ("lvalue required as unary %<&%> operand");
8570 error ("lvalue required in asm statement");
8577 /* *PTYPE is an incomplete array. Complete it with a domain based on
8578 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8579 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8580 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8583 complete_array_type (tree *ptype, tree initial_value, bool do_default)
8585 tree maxindex, type, main_type, elt, unqual_elt;
8586 int failure = 0, quals;
8587 hashval_t hashcode = 0;
8589 maxindex = size_zero_node;
8592 if (TREE_CODE (initial_value) == STRING_CST)
8595 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8596 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8598 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8600 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
8602 if (VEC_empty (constructor_elt, v))
8606 maxindex = integer_minus_one_node;
8611 unsigned HOST_WIDE_INT cnt;
8612 constructor_elt *ce;
8613 bool fold_p = false;
8615 if (VEC_index (constructor_elt, v, 0)->index)
8616 maxindex = fold_convert_loc (input_location, sizetype,
8617 VEC_index (constructor_elt,
8619 curindex = maxindex;
8622 VEC_iterate (constructor_elt, v, cnt, ce);
8625 bool curfold_p = false;
8627 curindex = ce->index, curfold_p = true;
8631 curindex = fold_convert (sizetype, curindex);
8632 curindex = size_binop (PLUS_EXPR, curindex,
8635 if (tree_int_cst_lt (maxindex, curindex))
8636 maxindex = curindex, fold_p = curfold_p;
8639 maxindex = fold_convert (sizetype, maxindex);
8644 /* Make an error message unless that happened already. */
8645 if (initial_value != error_mark_node)
8657 elt = TREE_TYPE (type);
8658 quals = TYPE_QUALS (strip_array_types (elt));
8662 unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals));
8664 /* Using build_distinct_type_copy and modifying things afterward instead
8665 of using build_array_type to create a new type preserves all of the
8666 TYPE_LANG_FLAG_? bits that the front end may have set. */
8667 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8668 TREE_TYPE (main_type) = unqual_elt;
8669 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8670 layout_type (main_type);
8672 /* Make sure we have the canonical MAIN_TYPE. */
8673 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
8674 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
8676 main_type = type_hash_canon (hashcode, main_type);
8678 /* Fix the canonical type. */
8679 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8680 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8681 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8682 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8683 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8684 != TYPE_DOMAIN (main_type)))
8685 TYPE_CANONICAL (main_type)
8686 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8687 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8689 TYPE_CANONICAL (main_type) = main_type;
8694 type = c_build_qualified_type (main_type, quals);
8696 if (COMPLETE_TYPE_P (type)
8697 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8698 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8700 error ("size of array is too large");
8701 /* If we proceed with the array type as it is, we'll eventually
8702 crash in tree_low_cst(). */
8703 type = error_mark_node;
8710 /* Like c_mark_addressable but don't check register qualifier. */
8712 c_common_mark_addressable_vec (tree t)
8714 while (handled_component_p (t))
8715 t = TREE_OPERAND (t, 0);
8716 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
8718 TREE_ADDRESSABLE (t) = 1;
8723 /* Used to help initialize the builtin-types.def table. When a type of
8724 the correct size doesn't exist, use error_mark_node instead of NULL.
8725 The later results in segfaults even when a decl using the type doesn't
8729 builtin_type_for_size (int size, bool unsignedp)
8731 tree type = lang_hooks.types.type_for_size (size, unsignedp);
8732 return type ? type : error_mark_node;
8735 /* A helper function for resolve_overloaded_builtin in resolving the
8736 overloaded __sync_ builtins. Returns a positive power of 2 if the
8737 first operand of PARAMS is a pointer to a supported data type.
8738 Returns 0 if an error is encountered. */
8741 sync_resolve_size (tree function, VEC(tree,gc) *params)
8746 if (VEC_empty (tree, params))
8748 error ("too few arguments to function %qE", function);
8752 type = TREE_TYPE (VEC_index (tree, params, 0));
8753 if (TREE_CODE (type) != POINTER_TYPE)
8756 type = TREE_TYPE (type);
8757 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8760 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
8761 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
8765 error ("incompatible type for argument %d of %qE", 1, function);
8769 /* A helper function for resolve_overloaded_builtin. Adds casts to
8770 PARAMS to make arguments match up with those of FUNCTION. Drops
8771 the variadic arguments at the end. Returns false if some error
8772 was encountered; true on success. */
8775 sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
8777 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8779 unsigned int parmnum;
8781 /* We've declared the implementation functions to use "volatile void *"
8782 as the pointer parameter, so we shouldn't get any complaints from the
8783 call to check_function_arguments what ever type the user used. */
8784 arg_types = TREE_CHAIN (arg_types);
8785 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
8787 /* For the rest of the values, we need to cast these to FTYPE, so that we
8788 don't get warnings for passing pointer types, etc. */
8790 while (arg_types != void_list_node)
8795 if (VEC_length (tree, params) <= parmnum)
8797 error ("too few arguments to function %qE", orig_function);
8801 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8802 so that we get warnings for anything that doesn't match the pointer
8803 type. This isn't portable across the C and C++ front ends atm. */
8804 val = VEC_index (tree, params, parmnum);
8805 val = convert (ptype, val);
8806 val = convert (TREE_VALUE (arg_types), val);
8807 VEC_replace (tree, params, parmnum, val);
8809 arg_types = TREE_CHAIN (arg_types);
8812 /* The definition of these primitives is variadic, with the remaining
8813 being "an optional list of variables protected by the memory barrier".
8814 No clue what that's supposed to mean, precisely, but we consider all
8815 call-clobbered variables to be protected so we're safe. */
8816 VEC_truncate (tree, params, parmnum + 1);
8821 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8822 RESULT to make it match the type of the first pointer argument in
8826 sync_resolve_return (tree first_param, tree result)
8828 tree ptype = TREE_TYPE (TREE_TYPE (first_param));
8829 ptype = TYPE_MAIN_VARIANT (ptype);
8830 return convert (ptype, result);
8833 /* Some builtin functions are placeholders for other expressions. This
8834 function should be called immediately after parsing the call expression
8835 before surrounding code has committed to the type of the expression.
8837 LOC is the location of the builtin call.
8839 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8840 PARAMS is the argument list for the call. The return value is non-null
8841 when expansion is complete, and null if normal processing should
8845 resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
8847 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8848 switch (DECL_BUILT_IN_CLASS (function))
8850 case BUILT_IN_NORMAL:
8853 if (targetm.resolve_overloaded_builtin)
8854 return targetm.resolve_overloaded_builtin (loc, function, params);
8861 /* Handle BUILT_IN_NORMAL here. */
8864 case BUILT_IN_FETCH_AND_ADD_N:
8865 case BUILT_IN_FETCH_AND_SUB_N:
8866 case BUILT_IN_FETCH_AND_OR_N:
8867 case BUILT_IN_FETCH_AND_AND_N:
8868 case BUILT_IN_FETCH_AND_XOR_N:
8869 case BUILT_IN_FETCH_AND_NAND_N:
8870 case BUILT_IN_ADD_AND_FETCH_N:
8871 case BUILT_IN_SUB_AND_FETCH_N:
8872 case BUILT_IN_OR_AND_FETCH_N:
8873 case BUILT_IN_AND_AND_FETCH_N:
8874 case BUILT_IN_XOR_AND_FETCH_N:
8875 case BUILT_IN_NAND_AND_FETCH_N:
8876 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8877 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8878 case BUILT_IN_LOCK_TEST_AND_SET_N:
8879 case BUILT_IN_LOCK_RELEASE_N:
8881 int n = sync_resolve_size (function, params);
8882 tree new_function, first_param, result;
8885 return error_mark_node;
8887 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8888 if (!sync_resolve_params (function, new_function, params))
8889 return error_mark_node;
8891 first_param = VEC_index (tree, params, 0);
8892 result = build_function_call_vec (loc, new_function, params, NULL);
8893 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8894 && orig_code != BUILT_IN_LOCK_RELEASE_N)
8895 result = sync_resolve_return (first_param, result);
8905 /* Ignoring their sign, return true if two scalar types are the same. */
8907 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8909 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8911 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8912 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8913 || c2 == FIXED_POINT_TYPE));
8915 /* Equality works here because c_common_signed_type uses
8916 TYPE_MAIN_VARIANT. */
8917 return c_common_signed_type (t1)
8918 == c_common_signed_type (t2);
8921 /* Check for missing format attributes on function pointers. LTYPE is
8922 the new type or left-hand side type. RTYPE is the old type or
8923 right-hand side type. Returns TRUE if LTYPE is missing the desired
8927 check_missing_format_attribute (tree ltype, tree rtype)
8929 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8932 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8933 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8938 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8939 if (is_attribute_p ("format", TREE_PURPOSE (la)))
8947 /* Subscripting with type char is likely to lose on a machine where
8948 chars are signed. So warn on any machine, but optionally. Don't
8949 warn for unsigned char since that type is safe. Don't warn for
8950 signed char because anyone who uses that must have done so
8951 deliberately. Furthermore, we reduce the false positive load by
8952 warning only for non-constant value of type char. */
8955 warn_array_subscript_with_type_char (tree index)
8957 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8958 && TREE_CODE (index) != INTEGER_CST)
8959 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8962 /* Implement -Wparentheses for the unexpected C precedence rules, to
8963 cover cases like x + y << z which readers are likely to
8964 misinterpret. We have seen an expression in which CODE is a binary
8965 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8966 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8967 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8968 expression was not formed using a binary or unary operator, or it
8969 was enclosed in parentheses. */
8972 warn_about_parentheses (enum tree_code code,
8973 enum tree_code code_left, tree arg_left,
8974 enum tree_code code_right, tree arg_right)
8976 if (!warn_parentheses)
8979 /* This macro tests that the expression ARG with original tree code
8980 CODE appears to be a boolean expression. or the result of folding a
8981 boolean expression. */
8982 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8983 (truth_value_p (TREE_CODE (ARG)) \
8984 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8985 /* Folding may create 0 or 1 integers from other expressions. */ \
8986 || ((CODE) != INTEGER_CST \
8987 && (integer_onep (ARG) || integer_zerop (ARG))))
8992 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8993 warning (OPT_Wparentheses,
8994 "suggest parentheses around %<+%> inside %<<<%>");
8995 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8996 warning (OPT_Wparentheses,
8997 "suggest parentheses around %<-%> inside %<<<%>");
9001 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9002 warning (OPT_Wparentheses,
9003 "suggest parentheses around %<+%> inside %<>>%>");
9004 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9005 warning (OPT_Wparentheses,
9006 "suggest parentheses around %<-%> inside %<>>%>");
9009 case TRUTH_ORIF_EXPR:
9010 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
9011 warning (OPT_Wparentheses,
9012 "suggest parentheses around %<&&%> within %<||%>");
9016 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
9017 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9018 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
9019 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9020 warning (OPT_Wparentheses,
9021 "suggest parentheses around arithmetic in operand of %<|%>");
9022 /* Check cases like x|y==z */
9023 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9024 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9025 warning (OPT_Wparentheses,
9026 "suggest parentheses around comparison in operand of %<|%>");
9027 /* Check cases like !x | y */
9028 else if (code_left == TRUTH_NOT_EXPR
9029 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
9030 warning (OPT_Wparentheses, "suggest parentheses around operand of "
9031 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
9035 if (code_left == BIT_AND_EXPR
9036 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9037 || code_right == BIT_AND_EXPR
9038 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9039 warning (OPT_Wparentheses,
9040 "suggest parentheses around arithmetic in operand of %<^%>");
9041 /* Check cases like x^y==z */
9042 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9043 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9044 warning (OPT_Wparentheses,
9045 "suggest parentheses around comparison in operand of %<^%>");
9049 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9050 warning (OPT_Wparentheses,
9051 "suggest parentheses around %<+%> in operand of %<&%>");
9052 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9053 warning (OPT_Wparentheses,
9054 "suggest parentheses around %<-%> in operand of %<&%>");
9055 /* Check cases like x&y==z */
9056 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9057 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9058 warning (OPT_Wparentheses,
9059 "suggest parentheses around comparison in operand of %<&%>");
9060 /* Check cases like !x & y */
9061 else if (code_left == TRUTH_NOT_EXPR
9062 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
9063 warning (OPT_Wparentheses, "suggest parentheses around operand of "
9064 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
9068 if (TREE_CODE_CLASS (code_left) == tcc_comparison
9069 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9070 warning (OPT_Wparentheses,
9071 "suggest parentheses around comparison in operand of %<==%>");
9074 if (TREE_CODE_CLASS (code_left) == tcc_comparison
9075 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9076 warning (OPT_Wparentheses,
9077 "suggest parentheses around comparison in operand of %<!=%>");
9081 if (TREE_CODE_CLASS (code) == tcc_comparison
9082 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
9083 && code_left != NE_EXPR && code_left != EQ_EXPR
9084 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
9085 || (TREE_CODE_CLASS (code_right) == tcc_comparison
9086 && code_right != NE_EXPR && code_right != EQ_EXPR
9087 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
9088 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
9089 "have their mathematical meaning");
9092 #undef NOT_A_BOOLEAN_EXPR_P
9095 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
9098 warn_for_unused_label (tree label)
9100 if (!TREE_USED (label))
9102 if (DECL_INITIAL (label))
9103 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9105 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9109 #ifndef TARGET_HAS_TARGETCM
9110 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
9113 /* Warn for division by zero according to the value of DIVISOR. LOC
9114 is the location of the division operator. */
9117 warn_for_div_by_zero (location_t loc, tree divisor)
9119 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9120 about division by zero. Do not issue a warning if DIVISOR has a
9121 floating-point type, since we consider 0.0/0.0 a valid way of
9122 generating a NaN. */
9123 if (c_inhibit_evaluation_warnings == 0
9124 && (integer_zerop (divisor) || fixed_zerop (divisor)))
9125 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
9128 /* Subroutine of build_binary_op. Give warnings for comparisons
9129 between signed and unsigned quantities that may fail. Do the
9130 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9131 so that casts will be considered, but default promotions won't
9134 LOCATION is the location of the comparison operator.
9136 The arguments of this function map directly to local variables
9137 of build_binary_op. */
9140 warn_for_sign_compare (location_t location,
9141 tree orig_op0, tree orig_op1,
9143 tree result_type, enum tree_code resultcode)
9145 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9146 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9147 int unsignedp0, unsignedp1;
9149 /* In C++, check for comparison of different enum types. */
9151 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9152 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9153 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
9154 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
9156 warning_at (location,
9157 OPT_Wsign_compare, "comparison between types %qT and %qT",
9158 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
9161 /* Do not warn if the comparison is being done in a signed type,
9162 since the signed type will only be chosen if it can represent
9163 all the values of the unsigned type. */
9164 if (!TYPE_UNSIGNED (result_type))
9166 /* Do not warn if both operands are unsigned. */
9167 else if (op0_signed == op1_signed)
9171 tree sop, uop, base_type;
9175 sop = orig_op0, uop = orig_op1;
9177 sop = orig_op1, uop = orig_op0;
9179 STRIP_TYPE_NOPS (sop);
9180 STRIP_TYPE_NOPS (uop);
9181 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9182 ? TREE_TYPE (result_type) : result_type);
9184 /* Do not warn if the signed quantity is an unsuffixed integer
9185 literal (or some static constant expression involving such
9186 literals or a conditional expression involving such literals)
9187 and it is non-negative. */
9188 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9190 /* Do not warn if the comparison is an equality operation, the
9191 unsigned quantity is an integral constant, and it would fit
9192 in the result if the result were signed. */
9193 else if (TREE_CODE (uop) == INTEGER_CST
9194 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
9195 && int_fits_type_p (uop, c_common_signed_type (base_type)))
9197 /* In C, do not warn if the unsigned quantity is an enumeration
9198 constant and its maximum value would fit in the result if the
9199 result were signed. */
9200 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9201 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9202 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
9203 c_common_signed_type (base_type)))
9206 warning_at (location,
9208 "comparison between signed and unsigned integer expressions");
9211 /* Warn if two unsigned values are being compared in a size larger
9212 than their original size, and one (and only one) is the result of
9213 a `~' operator. This comparison will always fail.
9215 Also warn if one operand is a constant, and the constant does not
9216 have all bits set that are set in the ~ operand when it is
9219 op0 = get_narrower (op0, &unsignedp0);
9220 op1 = get_narrower (op1, &unsignedp1);
9222 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9223 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9225 if (TREE_CODE (op0) == BIT_NOT_EXPR)
9226 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9227 if (TREE_CODE (op1) == BIT_NOT_EXPR)
9228 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9230 if (host_integerp (op0, 0) || host_integerp (op1, 0))
9233 HOST_WIDE_INT constant, mask;
9237 if (host_integerp (op0, 0))
9240 unsignedp = unsignedp1;
9241 constant = tree_low_cst (op0, 0);
9246 unsignedp = unsignedp0;
9247 constant = tree_low_cst (op1, 0);
9250 bits = TYPE_PRECISION (TREE_TYPE (primop));
9251 if (bits < TYPE_PRECISION (result_type)
9252 && bits < HOST_BITS_PER_LONG && unsignedp)
9254 mask = (~ (HOST_WIDE_INT) 0) << bits;
9255 if ((mask & constant) != mask)
9258 warning (OPT_Wsign_compare,
9259 "promoted ~unsigned is always non-zero");
9261 warning_at (location, OPT_Wsign_compare,
9262 "comparison of promoted ~unsigned with constant");
9266 else if (unsignedp0 && unsignedp1
9267 && (TYPE_PRECISION (TREE_TYPE (op0))
9268 < TYPE_PRECISION (result_type))
9269 && (TYPE_PRECISION (TREE_TYPE (op1))
9270 < TYPE_PRECISION (result_type)))
9271 warning_at (location, OPT_Wsign_compare,
9272 "comparison of promoted ~unsigned with unsigned");
9276 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
9277 type via c_common_type. If -Wdouble-promotion is in use, and the
9278 conditions for warning have been met, issue a warning. GMSGID is
9279 the warning message. It must have two %T specifiers for the type
9280 that was converted (generally "float") and the type to which it was
9281 converted (generally "double), respectively. LOC is the location
9282 to which the awrning should refer. */
9285 do_warn_double_promotion (tree result_type, tree type1, tree type2,
9286 const char *gmsgid, location_t loc)
9290 if (!warn_double_promotion)
9292 /* If the conversion will not occur at run-time, there is no need to
9294 if (c_inhibit_evaluation_warnings)
9296 if (TYPE_MAIN_VARIANT (result_type) != double_type_node
9297 && TYPE_MAIN_VARIANT (result_type) != complex_double_type_node)
9299 if (TYPE_MAIN_VARIANT (type1) == float_type_node
9300 || TYPE_MAIN_VARIANT (type1) == complex_float_type_node)
9301 source_type = type1;
9302 else if (TYPE_MAIN_VARIANT (type2) == float_type_node
9303 || TYPE_MAIN_VARIANT (type2) == complex_float_type_node)
9304 source_type = type2;
9307 warning_at (loc, OPT_Wdouble_promotion, gmsgid, source_type, result_type);
9310 /* Setup a TYPE_DECL node as a typedef representation.
9312 X is a TYPE_DECL for a typedef statement. Create a brand new
9313 ..._TYPE node (which will be just a variant of the existing
9314 ..._TYPE node with identical properties) and then install X
9315 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9317 The whole point here is to end up with a situation where each
9318 and every ..._TYPE node the compiler creates will be uniquely
9319 associated with AT MOST one node representing a typedef name.
9320 This way, even though the compiler substitutes corresponding
9321 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9322 early on, later parts of the compiler can always do the reverse
9323 translation and get back the corresponding typedef name. For
9326 typedef struct S MY_TYPE;
9329 Later parts of the compiler might only know that `object' was of
9330 type `struct S' if it were not for code just below. With this
9331 code however, later parts of the compiler see something like:
9333 struct S' == struct S
9334 typedef struct S' MY_TYPE;
9337 And they can then deduce (from the node for type struct S') that
9338 the original object declaration was:
9342 Being able to do this is important for proper support of protoize,
9343 and also for generating precise symbolic debugging information
9344 which takes full account of the programmer's (typedef) vocabulary.
9346 Obviously, we don't want to generate a duplicate ..._TYPE node if
9347 the TYPE_DECL node that we are now processing really represents a
9348 standard built-in type. */
9351 set_underlying_type (tree x)
9353 if (x == error_mark_node)
9355 if (DECL_IS_BUILTIN (x))
9357 if (TYPE_NAME (TREE_TYPE (x)) == 0)
9358 TYPE_NAME (TREE_TYPE (x)) = x;
9360 else if (TREE_TYPE (x) != error_mark_node
9361 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9363 tree tt = TREE_TYPE (x);
9364 DECL_ORIGINAL_TYPE (x) = tt;
9365 tt = build_variant_type_copy (tt);
9366 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9368 TREE_USED (tt) = TREE_USED (x);
9373 /* Record the types used by the current global variable declaration
9374 being parsed, so that we can decide later to emit their debug info.
9375 Those types are in types_used_by_cur_var_decl, and we are going to
9376 store them in the types_used_by_vars_hash hash table.
9377 DECL is the declaration of the global variable that has been parsed. */
9380 record_types_used_by_current_var_decl (tree decl)
9382 gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
9384 while (!VEC_empty (tree, types_used_by_cur_var_decl))
9386 tree type = VEC_pop (tree, types_used_by_cur_var_decl);
9387 types_used_by_var_decl_insert (type, decl);
9391 /* The C and C++ parsers both use vectors to hold function arguments.
9392 For efficiency, we keep a cache of unused vectors. This is the
9395 typedef VEC(tree,gc)* tree_gc_vec;
9396 DEF_VEC_P(tree_gc_vec);
9397 DEF_VEC_ALLOC_P(tree_gc_vec,gc);
9398 static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
9400 /* Return a new vector from the cache. If the cache is empty,
9401 allocate a new vector. These vectors are GC'ed, so it is OK if the
9402 pointer is not released.. */
9405 make_tree_vector (void)
9407 if (!VEC_empty (tree_gc_vec, tree_vector_cache))
9408 return VEC_pop (tree_gc_vec, tree_vector_cache);
9411 /* Passing 0 to VEC_alloc returns NULL, and our callers require
9412 that we always return a non-NULL value. The vector code uses
9413 4 when growing a NULL vector, so we do too. */
9414 return VEC_alloc (tree, gc, 4);
9418 /* Release a vector of trees back to the cache. */
9421 release_tree_vector (VEC(tree,gc) *vec)
9425 VEC_truncate (tree, vec, 0);
9426 VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
9430 /* Get a new tree vector holding a single tree. */
9433 make_tree_vector_single (tree t)
9435 VEC(tree,gc) *ret = make_tree_vector ();
9436 VEC_quick_push (tree, ret, t);
9440 /* Get a new tree vector which is a copy of an existing one. */
9443 make_tree_vector_copy (const VEC(tree,gc) *orig)
9449 ret = make_tree_vector ();
9450 VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
9451 FOR_EACH_VEC_ELT (tree, orig, ix, t)
9452 VEC_quick_push (tree, ret, t);
9456 #include "gt-c-family-c-common.h"