1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
35 #include "common/common-target.h"
36 #include "langhooks.h"
37 #include "tree-inline.h"
39 #include "diagnostic.h"
40 #include "tree-iterator.h"
44 #include "target-def.h"
46 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
48 /* The following symbols are subsumed in the c_global_trees array, and
49 listed here individually for documentation purposes.
51 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
53 tree short_integer_type_node;
54 tree long_integer_type_node;
55 tree long_long_integer_type_node;
56 tree int128_integer_type_node;
58 tree short_unsigned_type_node;
59 tree long_unsigned_type_node;
60 tree long_long_unsigned_type_node;
61 tree int128_unsigned_type_node;
63 tree truthvalue_type_node;
64 tree truthvalue_false_node;
65 tree truthvalue_true_node;
67 tree ptrdiff_type_node;
69 tree unsigned_char_type_node;
70 tree signed_char_type_node;
73 tree char16_type_node;
74 tree char32_type_node;
77 tree double_type_node;
78 tree long_double_type_node;
80 tree complex_integer_type_node;
81 tree complex_float_type_node;
82 tree complex_double_type_node;
83 tree complex_long_double_type_node;
85 tree dfloat32_type_node;
86 tree dfloat64_type_node;
87 tree_dfloat128_type_node;
95 tree unsigned_intQI_type_node;
96 tree unsigned_intHI_type_node;
97 tree unsigned_intSI_type_node;
98 tree unsigned_intDI_type_node;
99 tree unsigned_intTI_type_node;
101 tree widest_integer_literal_type_node;
102 tree widest_unsigned_literal_type_node;
104 Nodes for types `void *' and `const void *'.
106 tree ptr_type_node, const_ptr_type_node;
108 Nodes for types `char *' and `const char *'.
110 tree string_type_node, const_string_type_node;
112 Type `char[SOMENUMBER]'.
113 Used when an array of char is needed and the size is irrelevant.
115 tree char_array_type_node;
117 Type `int[SOMENUMBER]' or something like it.
118 Used when an array of int needed and the size is irrelevant.
120 tree int_array_type_node;
122 Type `wchar_t[SOMENUMBER]' or something like it.
123 Used when a wide string literal is created.
125 tree wchar_array_type_node;
127 Type `char16_t[SOMENUMBER]' or something like it.
128 Used when a UTF-16 string literal is created.
130 tree char16_array_type_node;
132 Type `char32_t[SOMENUMBER]' or something like it.
133 Used when a UTF-32 string literal is created.
135 tree char32_array_type_node;
137 Type `int ()' -- used for implicit declaration of functions.
139 tree default_function_type;
141 A VOID_TYPE node, packaged in a TREE_LIST.
145 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
146 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
147 VAR_DECLS, but C++ does.)
149 tree function_name_decl_node;
150 tree pretty_function_name_decl_node;
151 tree c99_function_name_decl_node;
153 Stack of nested function name VAR_DECLs.
155 tree saved_function_name_decls;
159 tree c_global_trees
[CTI_MAX
];
161 /* Switches common to the C front ends. */
163 /* Nonzero means don't output line number information. */
165 char flag_no_line_commands
;
167 /* Nonzero causes -E output not to be done, but directives such as
168 #define that have side effects are still obeyed. */
172 /* Nonzero means dump macros in some fashion. */
174 char flag_dump_macros
;
176 /* Nonzero means pass #include lines through to the output. */
178 char flag_dump_includes
;
180 /* Nonzero means process PCH files while preprocessing. */
182 bool flag_pch_preprocess
;
184 /* The file name to which we should write a precompiled header, or
185 NULL if no header will be written in this compile. */
187 const char *pch_file
;
189 /* Nonzero if an ISO standard was selected. It rejects macros in the
193 /* C/ObjC language option variables. */
196 /* Nonzero means allow type mismatches in conditional expressions;
197 just make their values `void'. */
199 int flag_cond_mismatch
;
201 /* Nonzero means enable C89 Amendment 1 features. */
205 /* Nonzero means use the ISO C99 (or C11) dialect of C. */
209 /* Nonzero means use the ISO C11 dialect of C. */
213 /* Nonzero means that we have builtin functions, and main is an int. */
218 /* ObjC language option variables. */
221 /* Tells the compiler that this is a special run. Do not perform any
222 compiling, instead we are to test some platform dependent features
223 and output a C header file with appropriate definitions. */
225 int print_struct_values
;
227 /* Tells the compiler what is the constant string class for ObjC. */
229 const char *constant_string_class_name
;
232 /* C++ language option variables. */
235 /* Nonzero means generate separate instantiation control files and
236 juggle them at link time. */
238 int flag_use_repository
;
240 /* The C++ dialect being used. C++98 is the default. */
242 enum cxx_dialect cxx_dialect
= cxx98
;
244 /* Maximum template instantiation depth. This limit exists to limit the
245 time it takes to notice excessively recursive template instantiations.
247 The default is lower than the 1024 recommended by the C++0x standard
248 because G++ runs out of stack before 1024 with highly recursive template
249 argument deduction substitution (g++.dg/cpp0x/enum11.C). */
251 int max_tinst_depth
= 900;
253 /* The elements of `ridpointers' are identifier nodes for the reserved
254 type names and storage classes. It is indexed by a RID_... value. */
257 tree (*make_fname_decl
) (location_t
, tree
, int);
259 /* Nonzero means don't warn about problems that occur when the code is
261 int c_inhibit_evaluation_warnings
;
263 /* Whether we are building a boolean conversion inside
264 convert_for_assignment, or some other late binary operation. If
265 build_binary_op is called for C (from code shared by C and C++) in
266 this case, then the operands have already been folded and the
267 result will not be folded again, so C_MAYBE_CONST_EXPR should not
269 bool in_late_binary_op
;
271 /* Whether lexing has been completed, so subsequent preprocessor
272 errors should use the compiler's input_location. */
273 bool done_lexing
= false;
275 /* Information about how a function name is generated. */
278 tree
*const decl
; /* pointer to the VAR_DECL. */
279 const unsigned rid
; /* RID number for the identifier. */
280 const int pretty
; /* How pretty is it? */
283 /* The three ways of getting then name of the current function. */
285 const struct fname_var_t fname_vars
[] =
287 /* C99 compliant __func__, must be first. */
288 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
289 /* GCC __FUNCTION__ compliant. */
290 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
291 /* GCC __PRETTY_FUNCTION__ compliant. */
292 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
296 /* Global visibility options. */
297 struct visibility_flags visibility_options
;
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_no_sanitize_address_attribute (tree
*, tree
, tree
,
311 static tree
handle_no_address_safety_analysis_attribute (tree
*, tree
, tree
,
313 static tree
handle_no_sanitize_undefined_attribute (tree
*, tree
, tree
, int,
315 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
316 static tree
handle_noclone_attribute (tree
*, tree
, tree
, int, bool *);
317 static tree
handle_leaf_attribute (tree
*, tree
, tree
, int, bool *);
318 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
320 static tree
handle_gnu_inline_attribute (tree
*, tree
, tree
, int, bool *);
321 static tree
handle_artificial_attribute (tree
*, tree
, tree
, int, bool *);
322 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
323 static tree
handle_error_attribute (tree
*, tree
, tree
, int, bool *);
324 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
325 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
326 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
328 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
329 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
331 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
332 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
333 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
334 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
335 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
336 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
337 static tree
handle_alias_ifunc_attribute (bool, tree
*, tree
, tree
, bool *);
338 static tree
handle_ifunc_attribute (tree
*, tree
, tree
, int, bool *);
339 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
340 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
341 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
343 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
345 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
347 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
348 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
349 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
351 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
352 static tree
handle_tm_attribute (tree
*, tree
, tree
, int, bool *);
353 static tree
handle_tm_wrap_attribute (tree
*, tree
, tree
, int, bool *);
354 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
355 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
357 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
359 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
360 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
361 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
362 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
364 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
365 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
366 static tree
handle_alloc_size_attribute (tree
*, tree
, tree
, int, bool *);
367 static tree
handle_target_attribute (tree
*, tree
, tree
, int, bool *);
368 static tree
handle_optimize_attribute (tree
*, tree
, tree
, int, bool *);
369 static tree
ignore_attribute (tree
*, tree
, tree
, int, bool *);
370 static tree
handle_no_split_stack_attribute (tree
*, tree
, tree
, int, bool *);
371 static tree
handle_fnspec_attribute (tree
*, tree
, tree
, int, bool *);
372 static tree
handle_warn_unused_attribute (tree
*, tree
, tree
, int, bool *);
373 static tree
handle_returns_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
374 static tree
handle_omp_declare_simd_attribute (tree
*, tree
, tree
, int,
376 static tree
handle_omp_declare_target_attribute (tree
*, tree
, tree
, int,
378 static tree
handle_bnd_variable_size_attribute (tree
*, tree
, tree
, int, bool *);
379 static tree
handle_bnd_legacy (tree
*, tree
, tree
, int, bool *);
381 static void check_function_nonnull (tree
, int, tree
*);
382 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
383 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
384 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
385 static int resort_field_decl_cmp (const void *, const void *);
387 /* Reserved words. The third field is a mask: keywords are disabled
388 if they match the mask.
391 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
392 C --std=c99: D_CXXONLY | D_OBJC
393 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
394 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
395 C++ --std=c0x: D_CONLY | D_OBJC
396 ObjC++ is like C++ except that D_OBJC is not set
398 If -fno-asm is used, D_ASM is added to the mask. If
399 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
400 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
401 In C with -Wc++-compat, we warn if D_CXXWARN is set.
403 Note the complication of the D_CXX_OBJC keywords. These are
404 reserved words such as 'class'. In C++, 'class' is a reserved
405 word. In Objective-C++ it is too. In Objective-C, it is a
406 reserved word too, but only if it follows an '@' sign.
408 const struct c_common_resword c_common_reswords
[] =
410 { "_Alignas", RID_ALIGNAS
, D_CONLY
},
411 { "_Alignof", RID_ALIGNOF
, D_CONLY
},
412 { "_Atomic", RID_ATOMIC
, D_CONLY
},
413 { "_Bool", RID_BOOL
, D_CONLY
},
414 { "_Complex", RID_COMPLEX
, 0 },
415 { "_Cilk_spawn", RID_CILK_SPAWN
, 0 },
416 { "_Cilk_sync", RID_CILK_SYNC
, 0 },
417 { "_Imaginary", RID_IMAGINARY
, D_CONLY
},
418 { "_Decimal32", RID_DFLOAT32
, D_CONLY
| D_EXT
},
419 { "_Decimal64", RID_DFLOAT64
, D_CONLY
| D_EXT
},
420 { "_Decimal128", RID_DFLOAT128
, D_CONLY
| D_EXT
},
421 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
422 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
423 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
424 { "_Static_assert", RID_STATIC_ASSERT
, D_CONLY
},
425 { "_Noreturn", RID_NORETURN
, D_CONLY
},
426 { "_Generic", RID_GENERIC
, D_CONLY
},
427 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
428 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
429 { "__alignof", RID_ALIGNOF
, 0 },
430 { "__alignof__", RID_ALIGNOF
, 0 },
431 { "__asm", RID_ASM
, 0 },
432 { "__asm__", RID_ASM
, 0 },
433 { "__attribute", RID_ATTRIBUTE
, 0 },
434 { "__attribute__", RID_ATTRIBUTE
, 0 },
435 { "__bases", RID_BASES
, D_CXXONLY
},
436 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
437 { "__builtin_complex", RID_BUILTIN_COMPLEX
, D_CONLY
},
438 { "__builtin_shuffle", RID_BUILTIN_SHUFFLE
, 0 },
439 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
440 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
441 { "__builtin_va_arg", RID_VA_ARG
, 0 },
442 { "__complex", RID_COMPLEX
, 0 },
443 { "__complex__", RID_COMPLEX
, 0 },
444 { "__const", RID_CONST
, 0 },
445 { "__const__", RID_CONST
, 0 },
446 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
447 { "__direct_bases", RID_DIRECT_BASES
, D_CXXONLY
},
448 { "__extension__", RID_EXTENSION
, 0 },
449 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
450 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
451 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
452 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
453 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
454 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
455 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
456 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
457 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
458 { "__imag", RID_IMAGPART
, 0 },
459 { "__imag__", RID_IMAGPART
, 0 },
460 { "__inline", RID_INLINE
, 0 },
461 { "__inline__", RID_INLINE
, 0 },
462 { "__int128", RID_INT128
, 0 },
463 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
464 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
465 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
466 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO
, D_CXXONLY
},
467 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
468 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
469 { "__is_final", RID_IS_FINAL
, D_CXXONLY
},
470 { "__is_literal_type", RID_IS_LITERAL_TYPE
, D_CXXONLY
},
471 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
472 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
473 { "__is_standard_layout", RID_IS_STD_LAYOUT
, D_CXXONLY
},
474 { "__is_trivial", RID_IS_TRIVIAL
, D_CXXONLY
},
475 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
476 { "__label__", RID_LABEL
, 0 },
477 { "__null", RID_NULL
, 0 },
478 { "__real", RID_REALPART
, 0 },
479 { "__real__", RID_REALPART
, 0 },
480 { "__restrict", RID_RESTRICT
, 0 },
481 { "__restrict__", RID_RESTRICT
, 0 },
482 { "__signed", RID_SIGNED
, 0 },
483 { "__signed__", RID_SIGNED
, 0 },
484 { "__thread", RID_THREAD
, 0 },
485 { "__transaction_atomic", RID_TRANSACTION_ATOMIC
, 0 },
486 { "__transaction_relaxed", RID_TRANSACTION_RELAXED
, 0 },
487 { "__transaction_cancel", RID_TRANSACTION_CANCEL
, 0 },
488 { "__typeof", RID_TYPEOF
, 0 },
489 { "__typeof__", RID_TYPEOF
, 0 },
490 { "__underlying_type", RID_UNDERLYING_TYPE
, D_CXXONLY
},
491 { "__volatile", RID_VOLATILE
, 0 },
492 { "__volatile__", RID_VOLATILE
, 0 },
493 { "alignas", RID_ALIGNAS
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
494 { "alignof", RID_ALIGNOF
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
495 { "asm", RID_ASM
, D_ASM
},
496 { "auto", RID_AUTO
, 0 },
497 { "bool", RID_BOOL
, D_CXXONLY
| D_CXXWARN
},
498 { "break", RID_BREAK
, 0 },
499 { "case", RID_CASE
, 0 },
500 { "catch", RID_CATCH
, D_CXX_OBJC
| D_CXXWARN
},
501 { "char", RID_CHAR
, 0 },
502 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
503 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
504 { "class", RID_CLASS
, D_CXX_OBJC
| D_CXXWARN
},
505 { "const", RID_CONST
, 0 },
506 { "constexpr", RID_CONSTEXPR
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
507 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
508 { "continue", RID_CONTINUE
, 0 },
509 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
510 { "default", RID_DEFAULT
, 0 },
511 { "delete", RID_DELETE
, D_CXXONLY
| D_CXXWARN
},
513 { "double", RID_DOUBLE
, 0 },
514 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
515 { "else", RID_ELSE
, 0 },
516 { "enum", RID_ENUM
, 0 },
517 { "explicit", RID_EXPLICIT
, D_CXXONLY
| D_CXXWARN
},
518 { "export", RID_EXPORT
, D_CXXONLY
| D_CXXWARN
},
519 { "extern", RID_EXTERN
, 0 },
520 { "false", RID_FALSE
, D_CXXONLY
| D_CXXWARN
},
521 { "float", RID_FLOAT
, 0 },
522 { "for", RID_FOR
, 0 },
523 { "friend", RID_FRIEND
, D_CXXONLY
| D_CXXWARN
},
524 { "goto", RID_GOTO
, 0 },
526 { "inline", RID_INLINE
, D_EXT89
},
527 { "int", RID_INT
, 0 },
528 { "long", RID_LONG
, 0 },
529 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
530 { "namespace", RID_NAMESPACE
, D_CXXONLY
| D_CXXWARN
},
531 { "new", RID_NEW
, D_CXXONLY
| D_CXXWARN
},
532 { "noexcept", RID_NOEXCEPT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
533 { "nullptr", RID_NULLPTR
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
534 { "operator", RID_OPERATOR
, D_CXXONLY
| D_CXXWARN
},
535 { "private", RID_PRIVATE
, D_CXX_OBJC
| D_CXXWARN
},
536 { "protected", RID_PROTECTED
, D_CXX_OBJC
| D_CXXWARN
},
537 { "public", RID_PUBLIC
, D_CXX_OBJC
| D_CXXWARN
},
538 { "register", RID_REGISTER
, 0 },
539 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
540 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
541 { "return", RID_RETURN
, 0 },
542 { "short", RID_SHORT
, 0 },
543 { "signed", RID_SIGNED
, 0 },
544 { "sizeof", RID_SIZEOF
, 0 },
545 { "static", RID_STATIC
, 0 },
546 { "static_assert", RID_STATIC_ASSERT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
547 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
548 { "struct", RID_STRUCT
, 0 },
549 { "switch", RID_SWITCH
, 0 },
550 { "template", RID_TEMPLATE
, D_CXXONLY
| D_CXXWARN
},
551 { "this", RID_THIS
, D_CXXONLY
| D_CXXWARN
},
552 { "thread_local", RID_THREAD
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
553 { "throw", RID_THROW
, D_CXX_OBJC
| D_CXXWARN
},
554 { "true", RID_TRUE
, D_CXXONLY
| D_CXXWARN
},
555 { "try", RID_TRY
, D_CXX_OBJC
| D_CXXWARN
},
556 { "typedef", RID_TYPEDEF
, 0 },
557 { "typename", RID_TYPENAME
, D_CXXONLY
| D_CXXWARN
},
558 { "typeid", RID_TYPEID
, D_CXXONLY
| D_CXXWARN
},
559 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
560 { "union", RID_UNION
, 0 },
561 { "unsigned", RID_UNSIGNED
, 0 },
562 { "using", RID_USING
, D_CXXONLY
| D_CXXWARN
},
563 { "virtual", RID_VIRTUAL
, D_CXXONLY
| D_CXXWARN
},
564 { "void", RID_VOID
, 0 },
565 { "volatile", RID_VOLATILE
, 0 },
566 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
567 { "while", RID_WHILE
, 0 },
568 /* These Objective-C keywords are recognized only immediately after
570 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
571 { "defs", RID_AT_DEFS
, D_OBJC
},
572 { "encode", RID_AT_ENCODE
, D_OBJC
},
573 { "end", RID_AT_END
, D_OBJC
},
574 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
575 { "interface", RID_AT_INTERFACE
, D_OBJC
},
576 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
577 { "selector", RID_AT_SELECTOR
, D_OBJC
},
578 { "finally", RID_AT_FINALLY
, D_OBJC
},
579 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
580 { "optional", RID_AT_OPTIONAL
, D_OBJC
},
581 { "required", RID_AT_REQUIRED
, D_OBJC
},
582 { "property", RID_AT_PROPERTY
, D_OBJC
},
583 { "package", RID_AT_PACKAGE
, D_OBJC
},
584 { "synthesize", RID_AT_SYNTHESIZE
, D_OBJC
},
585 { "dynamic", RID_AT_DYNAMIC
, D_OBJC
},
586 /* These are recognized only in protocol-qualifier context
588 { "bycopy", RID_BYCOPY
, D_OBJC
},
589 { "byref", RID_BYREF
, D_OBJC
},
590 { "in", RID_IN
, D_OBJC
},
591 { "inout", RID_INOUT
, D_OBJC
},
592 { "oneway", RID_ONEWAY
, D_OBJC
},
593 { "out", RID_OUT
, D_OBJC
},
594 /* These are recognized inside a property attribute list */
595 { "assign", RID_ASSIGN
, D_OBJC
},
596 { "copy", RID_COPY
, D_OBJC
},
597 { "getter", RID_GETTER
, D_OBJC
},
598 { "nonatomic", RID_NONATOMIC
, D_OBJC
},
599 { "readonly", RID_READONLY
, D_OBJC
},
600 { "readwrite", RID_READWRITE
, D_OBJC
},
601 { "retain", RID_RETAIN
, D_OBJC
},
602 { "setter", RID_SETTER
, D_OBJC
},
605 const unsigned int num_c_common_reswords
=
606 sizeof c_common_reswords
/ sizeof (struct c_common_resword
);
608 /* Table of machine-independent attributes common to all C-like languages. */
609 const struct attribute_spec c_common_attribute_table
[] =
611 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
612 affects_type_identity } */
613 { "packed", 0, 0, false, false, false,
614 handle_packed_attribute
, false},
615 { "nocommon", 0, 0, true, false, false,
616 handle_nocommon_attribute
, false},
617 { "common", 0, 0, true, false, false,
618 handle_common_attribute
, false },
619 /* FIXME: logically, noreturn attributes should be listed as
620 "false, true, true" and apply to function types. But implementing this
621 would require all the places in the compiler that use TREE_THIS_VOLATILE
622 on a decl to identify non-returning functions to be located and fixed
623 to check the function type instead. */
624 { "noreturn", 0, 0, true, false, false,
625 handle_noreturn_attribute
, false },
626 { "volatile", 0, 0, true, false, false,
627 handle_noreturn_attribute
, false },
628 { "noinline", 0, 0, true, false, false,
629 handle_noinline_attribute
, false },
630 { "noclone", 0, 0, true, false, false,
631 handle_noclone_attribute
, false },
632 { "leaf", 0, 0, true, false, false,
633 handle_leaf_attribute
, false },
634 { "always_inline", 0, 0, true, false, false,
635 handle_always_inline_attribute
, false },
636 { "gnu_inline", 0, 0, true, false, false,
637 handle_gnu_inline_attribute
, false },
638 { "artificial", 0, 0, true, false, false,
639 handle_artificial_attribute
, false },
640 { "flatten", 0, 0, true, false, false,
641 handle_flatten_attribute
, false },
642 { "used", 0, 0, true, false, false,
643 handle_used_attribute
, false },
644 { "unused", 0, 0, false, false, false,
645 handle_unused_attribute
, false },
646 { "externally_visible", 0, 0, true, false, false,
647 handle_externally_visible_attribute
, false },
648 /* The same comments as for noreturn attributes apply to const ones. */
649 { "const", 0, 0, true, false, false,
650 handle_const_attribute
, false },
651 { "transparent_union", 0, 0, false, false, false,
652 handle_transparent_union_attribute
, false },
653 { "constructor", 0, 1, true, false, false,
654 handle_constructor_attribute
, false },
655 { "destructor", 0, 1, true, false, false,
656 handle_destructor_attribute
, false },
657 { "mode", 1, 1, false, true, false,
658 handle_mode_attribute
, false },
659 { "section", 1, 1, true, false, false,
660 handle_section_attribute
, false },
661 { "aligned", 0, 1, false, false, false,
662 handle_aligned_attribute
, false },
663 { "weak", 0, 0, true, false, false,
664 handle_weak_attribute
, false },
665 { "ifunc", 1, 1, true, false, false,
666 handle_ifunc_attribute
, false },
667 { "alias", 1, 1, true, false, false,
668 handle_alias_attribute
, false },
669 { "weakref", 0, 1, true, false, false,
670 handle_weakref_attribute
, false },
671 { "no_instrument_function", 0, 0, true, false, false,
672 handle_no_instrument_function_attribute
,
674 { "malloc", 0, 0, true, false, false,
675 handle_malloc_attribute
, false },
676 { "returns_twice", 0, 0, true, false, false,
677 handle_returns_twice_attribute
, false },
678 { "no_stack_limit", 0, 0, true, false, false,
679 handle_no_limit_stack_attribute
, false },
680 { "pure", 0, 0, true, false, false,
681 handle_pure_attribute
, false },
682 { "transaction_callable", 0, 0, false, true, false,
683 handle_tm_attribute
, false },
684 { "transaction_unsafe", 0, 0, false, true, false,
685 handle_tm_attribute
, false },
686 { "transaction_safe", 0, 0, false, true, false,
687 handle_tm_attribute
, false },
688 { "transaction_may_cancel_outer", 0, 0, false, true, false,
689 handle_tm_attribute
, false },
690 /* ??? These two attributes didn't make the transition from the
691 Intel language document to the multi-vendor language document. */
692 { "transaction_pure", 0, 0, false, true, false,
693 handle_tm_attribute
, false },
694 { "transaction_wrap", 1, 1, true, false, false,
695 handle_tm_wrap_attribute
, false },
696 /* For internal use (marking of builtins) only. The name contains space
697 to prevent its usage in source code. */
698 { "no vops", 0, 0, true, false, false,
699 handle_novops_attribute
, false },
700 { "deprecated", 0, 1, false, false, false,
701 handle_deprecated_attribute
, false },
702 { "vector_size", 1, 1, false, true, false,
703 handle_vector_size_attribute
, false },
704 { "visibility", 1, 1, false, false, false,
705 handle_visibility_attribute
, false },
706 { "tls_model", 1, 1, true, false, false,
707 handle_tls_model_attribute
, false },
708 { "nonnull", 0, -1, false, true, true,
709 handle_nonnull_attribute
, false },
710 { "nothrow", 0, 0, true, false, false,
711 handle_nothrow_attribute
, false },
712 { "may_alias", 0, 0, false, true, false, NULL
, false },
713 { "cleanup", 1, 1, true, false, false,
714 handle_cleanup_attribute
, false },
715 { "warn_unused_result", 0, 0, false, true, true,
716 handle_warn_unused_result_attribute
, false },
717 { "sentinel", 0, 1, false, true, true,
718 handle_sentinel_attribute
, false },
719 /* For internal use (marking of builtins) only. The name contains space
720 to prevent its usage in source code. */
721 { "type generic", 0, 0, false, true, true,
722 handle_type_generic_attribute
, false },
723 { "alloc_size", 1, 2, false, true, true,
724 handle_alloc_size_attribute
, false },
725 { "cold", 0, 0, true, false, false,
726 handle_cold_attribute
, false },
727 { "hot", 0, 0, true, false, false,
728 handle_hot_attribute
, false },
729 { "no_address_safety_analysis",
730 0, 0, true, false, false,
731 handle_no_address_safety_analysis_attribute
,
733 { "no_sanitize_address", 0, 0, true, false, false,
734 handle_no_sanitize_address_attribute
,
736 { "no_sanitize_undefined", 0, 0, true, false, false,
737 handle_no_sanitize_undefined_attribute
,
739 { "warning", 1, 1, true, false, false,
740 handle_error_attribute
, false },
741 { "error", 1, 1, true, false, false,
742 handle_error_attribute
, false },
743 { "target", 1, -1, true, false, false,
744 handle_target_attribute
, false },
745 { "optimize", 1, -1, true, false, false,
746 handle_optimize_attribute
, false },
747 /* For internal use only. The leading '*' both prevents its usage in
748 source code and signals that it may be overridden by machine tables. */
749 { "*tm regparm", 0, 0, false, true, true,
750 ignore_attribute
, false },
751 { "no_split_stack", 0, 0, true, false, false,
752 handle_no_split_stack_attribute
, false },
753 /* For internal use (marking of builtins and runtime functions) only.
754 The name contains space to prevent its usage in source code. */
755 { "fn spec", 1, 1, false, true, true,
756 handle_fnspec_attribute
, false },
757 { "warn_unused", 0, 0, false, false, false,
758 handle_warn_unused_attribute
, false },
759 { "returns_nonnull", 0, 0, false, true, true,
760 handle_returns_nonnull_attribute
, false },
761 { "omp declare simd", 0, -1, true, false, false,
762 handle_omp_declare_simd_attribute
, false },
763 { "omp declare target", 0, 0, true, false, false,
764 handle_omp_declare_target_attribute
, false },
765 { "bnd_variable_size", 0, 0, true, false, false,
766 handle_bnd_variable_size_attribute
, false },
767 { "bnd_legacy", 0, 0, true, false, false,
768 handle_bnd_legacy
, false },
769 { NULL
, 0, 0, false, false, false, NULL
, false }
772 /* Give the specifications for the format attributes, used by C and all
775 const struct attribute_spec c_common_format_attribute_table
[] =
777 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
778 affects_type_identity } */
779 { "format", 3, 3, false, true, true,
780 handle_format_attribute
, false },
781 { "format_arg", 1, 1, false, true, true,
782 handle_format_arg_attribute
, false },
783 { NULL
, 0, 0, false, false, false, NULL
, false }
786 /* Return identifier for address space AS. */
789 c_addr_space_name (addr_space_t as
)
791 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
792 gcc_assert (ridpointers
[rid
]);
793 return IDENTIFIER_POINTER (ridpointers
[rid
]);
796 /* Push current bindings for the function name VAR_DECLS. */
799 start_fname_decls (void)
802 tree saved
= NULL_TREE
;
804 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
806 tree decl
= *fname_vars
[ix
].decl
;
810 saved
= tree_cons (decl
, build_int_cst (integer_type_node
, ix
),
812 *fname_vars
[ix
].decl
= NULL_TREE
;
815 if (saved
|| saved_function_name_decls
)
816 /* Normally they'll have been NULL, so only push if we've got a
817 stack, or they are non-NULL. */
818 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
819 saved_function_name_decls
);
822 /* Finish up the current bindings, adding them into the current function's
823 statement tree. This must be done _before_ finish_stmt_tree is called.
824 If there is no current function, we must be at file scope and no statements
825 are involved. Pop the previous bindings. */
828 finish_fname_decls (void)
831 tree stmts
= NULL_TREE
;
832 tree stack
= saved_function_name_decls
;
834 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
835 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
839 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
841 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
842 bodyp
= &BIND_EXPR_BODY (*bodyp
);
844 append_to_statement_list_force (*bodyp
, &stmts
);
848 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
849 *fname_vars
[ix
].decl
= NULL_TREE
;
853 /* We had saved values, restore them. */
856 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
858 tree decl
= TREE_PURPOSE (saved
);
859 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
861 *fname_vars
[ix
].decl
= decl
;
863 stack
= TREE_CHAIN (stack
);
865 saved_function_name_decls
= stack
;
868 /* Return the text name of the current function, suitably prettified
869 by PRETTY_P. Return string must be freed by caller. */
872 fname_as_string (int pretty_p
)
874 const char *name
= "top level";
877 cpp_string cstr
= { 0, 0 }, strname
;
885 if (current_function_decl
)
886 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
888 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
890 namep
= XNEWVEC (char, len
);
891 snprintf (namep
, len
, "\"%s\"", name
);
892 strname
.text
= (unsigned char *) namep
;
893 strname
.len
= len
- 1;
895 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
898 return (const char *) cstr
.text
;
904 /* Return the VAR_DECL for a const char array naming the current
905 function. If the VAR_DECL has not yet been created, create it
906 now. RID indicates how it should be formatted and IDENTIFIER_NODE
907 ID is its name (unfortunately C and C++ hold the RID values of
908 keywords in different places, so we can't derive RID from ID in
909 this language independent code. LOC is the location of the
913 fname_decl (location_t loc
, unsigned int rid
, tree id
)
916 tree decl
= NULL_TREE
;
918 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
919 if (fname_vars
[ix
].rid
== rid
)
922 decl
= *fname_vars
[ix
].decl
;
925 /* If a tree is built here, it would normally have the lineno of
926 the current statement. Later this tree will be moved to the
927 beginning of the function and this line number will be wrong.
928 To avoid this problem set the lineno to 0 here; that prevents
929 it from appearing in the RTL. */
931 location_t saved_location
= input_location
;
932 input_location
= UNKNOWN_LOCATION
;
934 stmts
= push_stmt_list ();
935 decl
= (*make_fname_decl
) (loc
, id
, fname_vars
[ix
].pretty
);
936 stmts
= pop_stmt_list (stmts
);
937 if (!IS_EMPTY_STMT (stmts
))
938 saved_function_name_decls
939 = tree_cons (decl
, stmts
, saved_function_name_decls
);
940 *fname_vars
[ix
].decl
= decl
;
941 input_location
= saved_location
;
943 if (!ix
&& !current_function_decl
)
944 pedwarn (loc
, 0, "%qD is not defined outside of function scope", decl
);
949 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
952 fix_string_type (tree value
)
954 int length
= TREE_STRING_LENGTH (value
);
956 tree e_type
, i_type
, a_type
;
958 /* Compute the number of elements, for the array type. */
959 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
962 e_type
= char_type_node
;
964 else if (TREE_TYPE (value
) == char16_array_type_node
)
966 nchars
= length
/ (TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
);
967 e_type
= char16_type_node
;
969 else if (TREE_TYPE (value
) == char32_array_type_node
)
971 nchars
= length
/ (TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
);
972 e_type
= char32_type_node
;
976 nchars
= length
/ (TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
);
977 e_type
= wchar_type_node
;
980 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
981 limit in C++98 Annex B is very large (65536) and is not normative,
982 so we do not diagnose it (warn_overlength_strings is forced off
983 in c_common_post_options). */
984 if (warn_overlength_strings
)
986 const int nchars_max
= flag_isoc99
? 4095 : 509;
987 const int relevant_std
= flag_isoc99
? 99 : 90;
988 if (nchars
- 1 > nchars_max
)
989 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
990 separate the %d from the 'C'. 'ISO' should not be
991 translated, but it may be moved after 'C%d' in languages
992 where modifiers follow nouns. */
993 pedwarn (input_location
, OPT_Woverlength_strings
,
994 "string length %qd is greater than the length %qd "
995 "ISO C%d compilers are required to support",
996 nchars
- 1, nchars_max
, relevant_std
);
999 /* Create the array type for the string constant. The ISO C++
1000 standard says that a string literal has type `const char[N]' or
1001 `const wchar_t[N]'. We use the same logic when invoked as a C
1002 front-end with -Wwrite-strings.
1003 ??? We should change the type of an expression depending on the
1004 state of a warning flag. We should just be warning -- see how
1005 this is handled in the C++ front-end for the deprecated implicit
1006 conversion from string literals to `char*' or `wchar_t*'.
1008 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1009 array type being the unqualified version of that type.
1010 Therefore, if we are constructing an array of const char, we must
1011 construct the matching unqualified array type first. The C front
1012 end does not require this, but it does no harm, so we do it
1014 i_type
= build_index_type (size_int (nchars
- 1));
1015 a_type
= build_array_type (e_type
, i_type
);
1016 if (c_dialect_cxx() || warn_write_strings
)
1017 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
1019 TREE_TYPE (value
) = a_type
;
1020 TREE_CONSTANT (value
) = 1;
1021 TREE_READONLY (value
) = 1;
1022 TREE_STATIC (value
) = 1;
1026 /* If DISABLE is true, stop issuing warnings. This is used when
1027 parsing code that we know will not be executed. This function may
1028 be called multiple times, and works as a stack. */
1031 c_disable_warnings (bool disable
)
1035 ++c_inhibit_evaluation_warnings
;
1036 fold_defer_overflow_warnings ();
1040 /* If ENABLE is true, reenable issuing warnings. */
1043 c_enable_warnings (bool enable
)
1047 --c_inhibit_evaluation_warnings
;
1048 fold_undefer_and_ignore_overflow_warnings ();
1052 /* Fully fold EXPR, an expression that was not folded (beyond integer
1053 constant expressions and null pointer constants) when being built
1054 up. If IN_INIT, this is in a static initializer and certain
1055 changes are made to the folding done. Clear *MAYBE_CONST if
1056 MAYBE_CONST is not NULL and EXPR is definitely not a constant
1057 expression because it contains an evaluated operator (in C99) or an
1058 operator outside of sizeof returning an integer constant (in C90)
1059 not permitted in constant expressions, or because it contains an
1060 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
1061 set to true by callers before calling this function.) Return the
1062 folded expression. Function arguments have already been folded
1063 before calling this function, as have the contents of SAVE_EXPR,
1064 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1065 C_MAYBE_CONST_EXPR. */
1068 c_fully_fold (tree expr
, bool in_init
, bool *maybe_const
)
1071 tree eptype
= NULL_TREE
;
1073 bool maybe_const_itself
= true;
1074 location_t loc
= EXPR_LOCATION (expr
);
1076 /* This function is not relevant to C++ because C++ folds while
1077 parsing, and may need changes to be correct for C++ when C++
1078 stops folding while parsing. */
1079 if (c_dialect_cxx ())
1083 maybe_const
= &dummy
;
1084 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
1086 eptype
= TREE_TYPE (expr
);
1087 expr
= TREE_OPERAND (expr
, 0);
1089 ret
= c_fully_fold_internal (expr
, in_init
, maybe_const
,
1090 &maybe_const_itself
);
1092 ret
= fold_convert_loc (loc
, eptype
, ret
);
1093 *maybe_const
&= maybe_const_itself
;
1097 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1098 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1099 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1100 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1101 both evaluated and unevaluated subexpressions while
1102 *MAYBE_CONST_ITSELF is carried from only evaluated
1106 c_fully_fold_internal (tree expr
, bool in_init
, bool *maybe_const_operands
,
1107 bool *maybe_const_itself
)
1110 enum tree_code code
= TREE_CODE (expr
);
1111 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
1112 location_t loc
= EXPR_LOCATION (expr
);
1113 tree op0
, op1
, op2
, op3
;
1114 tree orig_op0
, orig_op1
, orig_op2
;
1115 bool op0_const
= true, op1_const
= true, op2_const
= true;
1116 bool op0_const_self
= true, op1_const_self
= true, op2_const_self
= true;
1117 bool nowarning
= TREE_NO_WARNING (expr
);
1120 /* This function is not relevant to C++ because C++ folds while
1121 parsing, and may need changes to be correct for C++ when C++
1122 stops folding while parsing. */
1123 if (c_dialect_cxx ())
1126 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1127 anything else not counted as an expression cannot usefully be
1128 folded further at this point. */
1129 if (!IS_EXPR_CODE_CLASS (kind
)
1130 || kind
== tcc_statement
1131 || code
== SAVE_EXPR
)
1134 /* Operands of variable-length expressions (function calls) have
1135 already been folded, as have __builtin_* function calls, and such
1136 expressions cannot occur in constant expressions. */
1137 if (kind
== tcc_vl_exp
)
1139 *maybe_const_operands
= false;
1144 if (code
== C_MAYBE_CONST_EXPR
)
1146 tree pre
= C_MAYBE_CONST_EXPR_PRE (expr
);
1147 tree inner
= C_MAYBE_CONST_EXPR_EXPR (expr
);
1148 if (C_MAYBE_CONST_EXPR_NON_CONST (expr
))
1149 *maybe_const_operands
= false;
1150 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr
))
1151 *maybe_const_itself
= false;
1152 if (pre
&& !in_init
)
1153 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), pre
, inner
);
1159 /* Assignment, increment, decrement, function call and comma
1160 operators, and statement expressions, cannot occur in constant
1161 expressions if evaluated / outside of sizeof. (Function calls
1162 were handled above, though VA_ARG_EXPR is treated like a function
1163 call here, and statement expressions are handled through
1164 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1168 case PREDECREMENT_EXPR
:
1169 case PREINCREMENT_EXPR
:
1170 case POSTDECREMENT_EXPR
:
1171 case POSTINCREMENT_EXPR
:
1173 *maybe_const_operands
= false;
1180 *maybe_const_operands
= false;
1188 /* Fold individual tree codes as appropriate. */
1191 case COMPOUND_LITERAL_EXPR
:
1192 /* Any non-constancy will have been marked in a containing
1193 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1197 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1198 op1
= TREE_OPERAND (expr
, 1);
1199 op2
= TREE_OPERAND (expr
, 2);
1200 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1201 maybe_const_itself
);
1202 STRIP_TYPE_NOPS (op0
);
1203 if (op0
!= orig_op0
)
1204 ret
= build3 (COMPONENT_REF
, TREE_TYPE (expr
), op0
, op1
, op2
);
1207 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1208 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1213 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1214 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1215 op2
= TREE_OPERAND (expr
, 2);
1216 op3
= TREE_OPERAND (expr
, 3);
1217 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1218 maybe_const_itself
);
1219 STRIP_TYPE_NOPS (op0
);
1220 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1221 maybe_const_itself
);
1222 STRIP_TYPE_NOPS (op1
);
1223 op1
= decl_constant_value_for_optimization (op1
);
1224 if (op0
!= orig_op0
|| op1
!= orig_op1
)
1225 ret
= build4 (ARRAY_REF
, TREE_TYPE (expr
), op0
, op1
, op2
, op3
);
1228 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1229 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1230 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1237 case PREDECREMENT_EXPR
:
1238 case PREINCREMENT_EXPR
:
1239 case POSTDECREMENT_EXPR
:
1240 case POSTINCREMENT_EXPR
:
1244 case POINTER_PLUS_EXPR
:
1245 case TRUNC_DIV_EXPR
:
1247 case FLOOR_DIV_EXPR
:
1248 case TRUNC_MOD_EXPR
:
1250 case EXACT_DIV_EXPR
:
1263 case TRUTH_AND_EXPR
:
1265 case TRUTH_XOR_EXPR
:
1266 case UNORDERED_EXPR
:
1273 /* Binary operations evaluating both arguments (increment and
1274 decrement are binary internally in GCC). */
1275 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1276 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1277 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1278 maybe_const_itself
);
1279 STRIP_TYPE_NOPS (op0
);
1280 if (code
!= MODIFY_EXPR
1281 && code
!= PREDECREMENT_EXPR
1282 && code
!= PREINCREMENT_EXPR
1283 && code
!= POSTDECREMENT_EXPR
1284 && code
!= POSTINCREMENT_EXPR
)
1285 op0
= decl_constant_value_for_optimization (op0
);
1286 /* The RHS of a MODIFY_EXPR was fully folded when building that
1287 expression for the sake of conversion warnings. */
1288 if (code
!= MODIFY_EXPR
)
1289 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1290 maybe_const_itself
);
1291 STRIP_TYPE_NOPS (op1
);
1292 op1
= decl_constant_value_for_optimization (op1
);
1293 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1295 ? fold_build2_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
)
1296 : fold_build2_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
);
1299 if (TREE_OVERFLOW_P (ret
)
1300 && !TREE_OVERFLOW_P (op0
)
1301 && !TREE_OVERFLOW_P (op1
))
1302 overflow_warning (EXPR_LOCATION (expr
), ret
);
1303 if ((code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
1304 && TREE_CODE (orig_op1
) != INTEGER_CST
1305 && TREE_CODE (op1
) == INTEGER_CST
1306 && (TREE_CODE (TREE_TYPE (orig_op0
)) == INTEGER_TYPE
1307 || TREE_CODE (TREE_TYPE (orig_op0
)) == FIXED_POINT_TYPE
)
1308 && TREE_CODE (TREE_TYPE (orig_op1
)) == INTEGER_TYPE
1309 && c_inhibit_evaluation_warnings
== 0)
1311 if (tree_int_cst_sgn (op1
) < 0)
1312 warning_at (loc
, 0, (code
== LSHIFT_EXPR
1313 ? G_("left shift count is negative")
1314 : G_("right shift count is negative")));
1315 else if (compare_tree_int (op1
,
1316 TYPE_PRECISION (TREE_TYPE (orig_op0
)))
1318 warning_at (loc
, 0, (code
== LSHIFT_EXPR
1319 ? G_("left shift count >= width of type")
1320 : G_("right shift count >= width of type")));
1325 case FIX_TRUNC_EXPR
:
1328 case VIEW_CONVERT_EXPR
:
1329 case NON_LVALUE_EXPR
:
1332 case TRUTH_NOT_EXPR
:
1337 /* Unary operations. */
1338 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1339 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1340 maybe_const_itself
);
1341 STRIP_TYPE_NOPS (op0
);
1342 if (code
!= ADDR_EXPR
&& code
!= REALPART_EXPR
&& code
!= IMAGPART_EXPR
)
1343 op0
= decl_constant_value_for_optimization (op0
);
1344 /* ??? Cope with user tricks that amount to offsetof. The middle-end is
1345 not prepared to deal with them if they occur in initializers. */
1347 && code
== ADDR_EXPR
1348 && (op1
= get_base_address (op0
)) != NULL_TREE
1349 && TREE_CODE (op1
) == INDIRECT_REF
1350 && TREE_CONSTANT (TREE_OPERAND (op1
, 0)))
1351 ret
= fold_convert_loc (loc
, TREE_TYPE (expr
), fold_offsetof_1 (op0
));
1352 else if (op0
!= orig_op0
|| in_init
)
1354 ? fold_build1_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
)
1355 : fold_build1_loc (loc
, code
, TREE_TYPE (expr
), op0
);
1358 if (code
== INDIRECT_REF
1360 && TREE_CODE (ret
) == INDIRECT_REF
)
1362 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1363 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1364 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1368 case FIX_TRUNC_EXPR
:
1371 /* Don't warn about explicit conversions. We will already
1372 have warned about suspect implicit conversions. */
1376 if (TREE_OVERFLOW_P (ret
) && !TREE_OVERFLOW_P (op0
))
1377 overflow_warning (EXPR_LOCATION (expr
), ret
);
1382 case TRUTH_ANDIF_EXPR
:
1383 case TRUTH_ORIF_EXPR
:
1384 /* Binary operations not necessarily evaluating both
1386 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1387 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1388 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1389 STRIP_TYPE_NOPS (op0
);
1391 unused_p
= (op0
== (code
== TRUTH_ANDIF_EXPR
1392 ? truthvalue_false_node
1393 : truthvalue_true_node
));
1394 c_disable_warnings (unused_p
);
1395 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1396 STRIP_TYPE_NOPS (op1
);
1397 c_enable_warnings (unused_p
);
1399 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1401 ? fold_build2_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
)
1402 : fold_build2_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
);
1405 *maybe_const_operands
&= op0_const
;
1406 *maybe_const_itself
&= op0_const_self
;
1410 && (code
== TRUTH_ANDIF_EXPR
1411 ? op0
== truthvalue_false_node
1412 : op0
== truthvalue_true_node
)))
1413 *maybe_const_operands
&= op1_const
;
1416 && (code
== TRUTH_ANDIF_EXPR
1417 ? op0
== truthvalue_false_node
1418 : op0
== truthvalue_true_node
)))
1419 *maybe_const_itself
&= op1_const_self
;
1423 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1424 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1425 orig_op2
= op2
= TREE_OPERAND (expr
, 2);
1426 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1428 STRIP_TYPE_NOPS (op0
);
1429 c_disable_warnings (op0
== truthvalue_false_node
);
1430 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1431 STRIP_TYPE_NOPS (op1
);
1432 c_enable_warnings (op0
== truthvalue_false_node
);
1434 c_disable_warnings (op0
== truthvalue_true_node
);
1435 op2
= c_fully_fold_internal (op2
, in_init
, &op2_const
, &op2_const_self
);
1436 STRIP_TYPE_NOPS (op2
);
1437 c_enable_warnings (op0
== truthvalue_true_node
);
1439 if (op0
!= orig_op0
|| op1
!= orig_op1
|| op2
!= orig_op2
)
1440 ret
= fold_build3_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
, op2
);
1443 *maybe_const_operands
&= op0_const
;
1444 *maybe_const_itself
&= op0_const_self
;
1448 && op0
== truthvalue_false_node
))
1449 *maybe_const_operands
&= op1_const
;
1452 && op0
== truthvalue_false_node
))
1453 *maybe_const_itself
&= op1_const_self
;
1457 && op0
== truthvalue_true_node
))
1458 *maybe_const_operands
&= op2_const
;
1461 && op0
== truthvalue_true_node
))
1462 *maybe_const_itself
&= op2_const_self
;
1465 case EXCESS_PRECISION_EXPR
:
1466 /* Each case where an operand with excess precision may be
1467 encountered must remove the EXCESS_PRECISION_EXPR around
1468 inner operands and possibly put one around the whole
1469 expression or possibly convert to the semantic type (which
1470 c_fully_fold does); we cannot tell at this stage which is
1471 appropriate in any particular case. */
1475 /* Various codes may appear through folding built-in functions
1476 and their arguments. */
1481 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1482 have been done by this point, so remove them again. */
1483 nowarning
|= TREE_NO_WARNING (ret
);
1484 STRIP_TYPE_NOPS (ret
);
1485 if (nowarning
&& !TREE_NO_WARNING (ret
))
1487 if (!CAN_HAVE_LOCATION_P (ret
))
1488 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
1489 TREE_NO_WARNING (ret
) = 1;
1492 protected_set_expr_location (ret
, loc
);
1496 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1497 return EXP. Otherwise, return either EXP or its known constant
1498 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1499 Is the BLKmode test appropriate? */
1502 decl_constant_value_for_optimization (tree exp
)
1506 /* This function is only used by C, for c_fully_fold and other
1507 optimization, and may not be correct for C++. */
1508 if (c_dialect_cxx ())
1512 || TREE_CODE (exp
) != VAR_DECL
1513 || TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1514 || DECL_MODE (exp
) == BLKmode
)
1517 ret
= decl_constant_value (exp
);
1518 /* Avoid unwanted tree sharing between the initializer and current
1519 function's body where the tree can be modified e.g. by the
1521 if (ret
!= exp
&& TREE_STATIC (exp
))
1522 ret
= unshare_expr (ret
);
1526 /* Print a warning if a constant expression had overflow in folding.
1527 Invoke this function on every expression that the language
1528 requires to be a constant expression.
1529 Note the ANSI C standard says it is erroneous for a
1530 constant expression to overflow. */
1533 constant_expression_warning (tree value
)
1535 if (warn_overflow
&& pedantic
1536 && (TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1537 || TREE_CODE (value
) == FIXED_CST
1538 || TREE_CODE (value
) == VECTOR_CST
1539 || TREE_CODE (value
) == COMPLEX_CST
)
1540 && TREE_OVERFLOW (value
))
1541 pedwarn (input_location
, OPT_Woverflow
, "overflow in constant expression");
1544 /* The same as above but print an unconditional error. */
1546 constant_expression_error (tree value
)
1548 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1549 || TREE_CODE (value
) == FIXED_CST
1550 || TREE_CODE (value
) == VECTOR_CST
1551 || TREE_CODE (value
) == COMPLEX_CST
)
1552 && TREE_OVERFLOW (value
))
1553 error ("overflow in constant expression");
1556 /* Print a warning if an expression had overflow in folding and its
1559 Invoke this function on every expression that
1560 (1) appears in the source code, and
1561 (2) is a constant expression that overflowed, and
1562 (3) is not already checked by convert_and_check;
1563 however, do not invoke this function on operands of explicit casts
1564 or when the expression is the result of an operator and any operand
1565 already overflowed. */
1568 overflow_warning (location_t loc
, tree value
)
1570 if (c_inhibit_evaluation_warnings
!= 0)
1573 switch (TREE_CODE (value
))
1576 warning_at (loc
, OPT_Woverflow
, "integer overflow in expression");
1580 warning_at (loc
, OPT_Woverflow
,
1581 "floating point overflow in expression");
1585 warning_at (loc
, OPT_Woverflow
, "fixed-point overflow in expression");
1589 warning_at (loc
, OPT_Woverflow
, "vector overflow in expression");
1593 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
1594 warning_at (loc
, OPT_Woverflow
,
1595 "complex integer overflow in expression");
1596 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
1597 warning_at (loc
, OPT_Woverflow
,
1598 "complex floating point overflow in expression");
1606 /* Warn about uses of logical || / && operator in a context where it
1607 is likely that the bitwise equivalent was intended by the
1608 programmer. We have seen an expression in which CODE is a binary
1609 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1610 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1612 warn_logical_operator (location_t location
, enum tree_code code
, tree type
,
1613 enum tree_code code_left
, tree op_left
,
1614 enum tree_code
ARG_UNUSED (code_right
), tree op_right
)
1616 int or_op
= (code
== TRUTH_ORIF_EXPR
|| code
== TRUTH_OR_EXPR
);
1617 int in0_p
, in1_p
, in_p
;
1618 tree low0
, low1
, low
, high0
, high1
, high
, lhs
, rhs
, tem
;
1619 bool strict_overflow_p
= false;
1621 if (code
!= TRUTH_ANDIF_EXPR
1622 && code
!= TRUTH_AND_EXPR
1623 && code
!= TRUTH_ORIF_EXPR
1624 && code
!= TRUTH_OR_EXPR
)
1627 /* Warn if &&/|| are being used in a context where it is
1628 likely that the bitwise equivalent was intended by the
1629 programmer. That is, an expression such as op && MASK
1630 where op should not be any boolean expression, nor a
1631 constant, and mask seems to be a non-boolean integer constant. */
1632 if (!truth_value_p (code_left
)
1633 && INTEGRAL_TYPE_P (TREE_TYPE (op_left
))
1634 && !CONSTANT_CLASS_P (op_left
)
1635 && !TREE_NO_WARNING (op_left
)
1636 && TREE_CODE (op_right
) == INTEGER_CST
1637 && !integer_zerop (op_right
)
1638 && !integer_onep (op_right
))
1641 warning_at (location
, OPT_Wlogical_op
, "logical %<or%>"
1642 " applied to non-boolean constant");
1644 warning_at (location
, OPT_Wlogical_op
, "logical %<and%>"
1645 " applied to non-boolean constant");
1646 TREE_NO_WARNING (op_left
) = true;
1650 /* We do not warn for constants because they are typical of macro
1651 expansions that test for features. */
1652 if (CONSTANT_CLASS_P (op_left
) || CONSTANT_CLASS_P (op_right
))
1655 /* This warning only makes sense with logical operands. */
1656 if (!(truth_value_p (TREE_CODE (op_left
))
1657 || INTEGRAL_TYPE_P (TREE_TYPE (op_left
)))
1658 || !(truth_value_p (TREE_CODE (op_right
))
1659 || INTEGRAL_TYPE_P (TREE_TYPE (op_right
))))
1663 /* We first test whether either side separately is trivially true
1664 (with OR) or trivially false (with AND). If so, do not warn.
1665 This is a common idiom for testing ranges of data types in
1667 lhs
= make_range (op_left
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
1670 if (TREE_CODE (lhs
) == C_MAYBE_CONST_EXPR
)
1671 lhs
= C_MAYBE_CONST_EXPR_EXPR (lhs
);
1673 /* If this is an OR operation, invert both sides; now, the result
1674 should be always false to get a warning. */
1678 tem
= build_range_check (UNKNOWN_LOCATION
, type
, lhs
, in0_p
, low0
, high0
);
1679 if (tem
&& integer_zerop (tem
))
1682 rhs
= make_range (op_right
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
1685 if (TREE_CODE (rhs
) == C_MAYBE_CONST_EXPR
)
1686 rhs
= C_MAYBE_CONST_EXPR_EXPR (rhs
);
1688 /* If this is an OR operation, invert both sides; now, the result
1689 should be always false to get a warning. */
1693 tem
= build_range_check (UNKNOWN_LOCATION
, type
, rhs
, in1_p
, low1
, high1
);
1694 if (tem
&& integer_zerop (tem
))
1697 /* If both expressions have the same operand, if we can merge the
1698 ranges, and if the range test is always false, then warn. */
1699 if (operand_equal_p (lhs
, rhs
, 0)
1700 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
1702 && 0 != (tem
= build_range_check (UNKNOWN_LOCATION
,
1703 type
, lhs
, in_p
, low
, high
))
1704 && integer_zerop (tem
))
1707 warning_at (location
, OPT_Wlogical_op
,
1709 "of collectively exhaustive tests is always true");
1711 warning_at (location
, OPT_Wlogical_op
,
1713 "of mutually exclusive tests is always false");
1718 /* Warn if EXP contains any computations whose results are not used.
1719 Return true if a warning is printed; false otherwise. LOCUS is the
1720 (potential) location of the expression. */
1723 warn_if_unused_value (const_tree exp
, location_t locus
)
1726 if (TREE_USED (exp
) || TREE_NO_WARNING (exp
))
1729 /* Don't warn about void constructs. This includes casting to void,
1730 void function calls, and statement expressions with a final cast
1732 if (VOID_TYPE_P (TREE_TYPE (exp
)))
1735 if (EXPR_HAS_LOCATION (exp
))
1736 locus
= EXPR_LOCATION (exp
);
1738 switch (TREE_CODE (exp
))
1740 case PREINCREMENT_EXPR
:
1741 case POSTINCREMENT_EXPR
:
1742 case PREDECREMENT_EXPR
:
1743 case POSTDECREMENT_EXPR
:
1748 case TRY_CATCH_EXPR
:
1749 case WITH_CLEANUP_EXPR
:
1755 /* For a binding, warn if no side effect within it. */
1756 exp
= BIND_EXPR_BODY (exp
);
1760 case NON_LVALUE_EXPR
:
1762 exp
= TREE_OPERAND (exp
, 0);
1765 case TRUTH_ORIF_EXPR
:
1766 case TRUTH_ANDIF_EXPR
:
1767 /* In && or ||, warn if 2nd operand has no side effect. */
1768 exp
= TREE_OPERAND (exp
, 1);
1772 if (warn_if_unused_value (TREE_OPERAND (exp
, 0), locus
))
1774 /* Let people do `(foo (), 0)' without a warning. */
1775 if (TREE_CONSTANT (TREE_OPERAND (exp
, 1)))
1777 exp
= TREE_OPERAND (exp
, 1);
1781 /* If this is an expression with side effects, don't warn; this
1782 case commonly appears in macro expansions. */
1783 if (TREE_SIDE_EFFECTS (exp
))
1788 /* Don't warn about automatic dereferencing of references, since
1789 the user cannot control it. */
1790 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
1792 exp
= TREE_OPERAND (exp
, 0);
1798 /* Referencing a volatile value is a side effect, so don't warn. */
1799 if ((DECL_P (exp
) || REFERENCE_CLASS_P (exp
))
1800 && TREE_THIS_VOLATILE (exp
))
1803 /* If this is an expression which has no operands, there is no value
1804 to be unused. There are no such language-independent codes,
1805 but front ends may define such. */
1806 if (EXPRESSION_CLASS_P (exp
) && TREE_OPERAND_LENGTH (exp
) == 0)
1810 return warning_at (locus
, OPT_Wunused_value
, "value computed is not used");
1815 /* Print a warning about casts that might indicate violation
1816 of strict aliasing rules if -Wstrict-aliasing is used and
1817 strict aliasing mode is in effect. OTYPE is the original
1818 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1821 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
1823 /* Strip pointer conversion chains and get to the correct original type. */
1825 otype
= TREE_TYPE (expr
);
1827 if (!(flag_strict_aliasing
1828 && POINTER_TYPE_P (type
)
1829 && POINTER_TYPE_P (otype
)
1830 && !VOID_TYPE_P (TREE_TYPE (type
)))
1831 /* If the type we are casting to is a ref-all pointer
1832 dereferencing it is always valid. */
1833 || TYPE_REF_CAN_ALIAS_ALL (type
))
1836 if ((warn_strict_aliasing
> 1) && TREE_CODE (expr
) == ADDR_EXPR
1837 && (DECL_P (TREE_OPERAND (expr
, 0))
1838 || handled_component_p (TREE_OPERAND (expr
, 0))))
1840 /* Casting the address of an object to non void pointer. Warn
1841 if the cast breaks type based aliasing. */
1842 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)) && warn_strict_aliasing
== 2)
1844 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
1845 "might break strict-aliasing rules");
1850 /* warn_strict_aliasing >= 3. This includes the default (3).
1851 Only warn if the cast is dereferenced immediately. */
1852 alias_set_type set1
=
1853 get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1854 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1856 if (set1
!= set2
&& set2
!= 0
1857 && (set1
== 0 || !alias_sets_conflict_p (set1
, set2
)))
1859 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1860 "pointer will break strict-aliasing rules");
1863 else if (warn_strict_aliasing
== 2
1864 && !alias_sets_must_conflict_p (set1
, set2
))
1866 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1867 "pointer might break strict-aliasing rules");
1873 if ((warn_strict_aliasing
== 1) && !VOID_TYPE_P (TREE_TYPE (otype
)))
1875 /* At this level, warn for any conversions, even if an address is
1876 not taken in the same statement. This will likely produce many
1877 false positives, but could be useful to pinpoint problems that
1878 are not revealed at higher levels. */
1879 alias_set_type set1
= get_alias_set (TREE_TYPE (otype
));
1880 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1881 if (!COMPLETE_TYPE_P (type
)
1882 || !alias_sets_must_conflict_p (set1
, set2
))
1884 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1885 "pointer might break strict-aliasing rules");
1893 /* Warn about memset (&a, 0, sizeof (&a)); and similar mistakes with
1894 sizeof as last operand of certain builtins. */
1897 sizeof_pointer_memaccess_warning (location_t
*sizeof_arg_loc
, tree callee
,
1898 vec
<tree
, va_gc
> *params
, tree
*sizeof_arg
,
1899 bool (*comp_types
) (tree
, tree
))
1901 tree type
, dest
= NULL_TREE
, src
= NULL_TREE
, tem
;
1902 bool strop
= false, cmp
= false;
1903 unsigned int idx
= ~0;
1906 if (TREE_CODE (callee
) != FUNCTION_DECL
1907 || DECL_BUILT_IN_CLASS (callee
) != BUILT_IN_NORMAL
1908 || vec_safe_length (params
) <= 1)
1911 switch (DECL_FUNCTION_CODE (callee
))
1913 case BUILT_IN_STRNCMP
:
1914 case BUILT_IN_STRNCASECMP
:
1917 case BUILT_IN_STRNCPY
:
1918 case BUILT_IN_STRNCPY_CHK
:
1919 case BUILT_IN_STRNCAT
:
1920 case BUILT_IN_STRNCAT_CHK
:
1921 case BUILT_IN_STPNCPY
:
1922 case BUILT_IN_STPNCPY_CHK
:
1925 case BUILT_IN_MEMCPY
:
1926 case BUILT_IN_MEMCPY_CHK
:
1927 case BUILT_IN_MEMMOVE
:
1928 case BUILT_IN_MEMMOVE_CHK
:
1929 if (params
->length () < 3)
1932 dest
= (*params
)[0];
1935 case BUILT_IN_BCOPY
:
1936 if (params
->length () < 3)
1939 dest
= (*params
)[1];
1942 case BUILT_IN_MEMCMP
:
1944 if (params
->length () < 3)
1947 dest
= (*params
)[0];
1951 case BUILT_IN_MEMSET
:
1952 case BUILT_IN_MEMSET_CHK
:
1953 if (params
->length () < 3)
1955 dest
= (*params
)[0];
1958 case BUILT_IN_BZERO
:
1959 dest
= (*params
)[0];
1962 case BUILT_IN_STRNDUP
:
1967 case BUILT_IN_MEMCHR
:
1968 if (params
->length () < 3)
1973 case BUILT_IN_SNPRINTF
:
1974 case BUILT_IN_SNPRINTF_CHK
:
1975 case BUILT_IN_VSNPRINTF
:
1976 case BUILT_IN_VSNPRINTF_CHK
:
1977 dest
= (*params
)[0];
1988 if (sizeof_arg
[idx
] == NULL
|| sizeof_arg
[idx
] == error_mark_node
)
1991 type
= TYPE_P (sizeof_arg
[idx
])
1992 ? sizeof_arg
[idx
] : TREE_TYPE (sizeof_arg
[idx
]);
1993 if (!POINTER_TYPE_P (type
))
1997 && (tem
= tree_strip_nop_conversions (dest
))
1998 && POINTER_TYPE_P (TREE_TYPE (tem
))
1999 && comp_types (TREE_TYPE (TREE_TYPE (tem
)), type
))
2003 && (tem
= tree_strip_nop_conversions (src
))
2004 && POINTER_TYPE_P (TREE_TYPE (tem
))
2005 && comp_types (TREE_TYPE (TREE_TYPE (tem
)), type
))
2008 loc
= sizeof_arg_loc
[idx
];
2012 if (!TYPE_P (sizeof_arg
[idx
])
2013 && operand_equal_p (dest
, sizeof_arg
[idx
], 0)
2014 && comp_types (TREE_TYPE (dest
), type
))
2016 if (TREE_CODE (sizeof_arg
[idx
]) == ADDR_EXPR
&& !strop
)
2017 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2018 "argument to %<sizeof%> in %qD call is the same "
2019 "expression as the destination; did you mean to "
2020 "remove the addressof?", callee
);
2021 else if ((TYPE_PRECISION (TREE_TYPE (type
))
2022 == TYPE_PRECISION (char_type_node
))
2024 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2025 "argument to %<sizeof%> in %qD call is the same "
2026 "expression as the destination; did you mean to "
2027 "provide an explicit length?", callee
);
2029 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2030 "argument to %<sizeof%> in %qD call is the same "
2031 "expression as the destination; did you mean to "
2032 "dereference it?", callee
);
2036 if (POINTER_TYPE_P (TREE_TYPE (dest
))
2038 && comp_types (TREE_TYPE (dest
), type
)
2039 && !VOID_TYPE_P (TREE_TYPE (type
)))
2041 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2042 "argument to %<sizeof%> in %qD call is the same "
2043 "pointer type %qT as the destination; expected %qT "
2044 "or an explicit length", callee
, TREE_TYPE (dest
),
2045 TREE_TYPE (TREE_TYPE (dest
)));
2052 if (!TYPE_P (sizeof_arg
[idx
])
2053 && operand_equal_p (src
, sizeof_arg
[idx
], 0)
2054 && comp_types (TREE_TYPE (src
), type
))
2056 if (TREE_CODE (sizeof_arg
[idx
]) == ADDR_EXPR
&& !strop
)
2057 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2058 "argument to %<sizeof%> in %qD call is the same "
2059 "expression as the source; did you mean to "
2060 "remove the addressof?", callee
);
2061 else if ((TYPE_PRECISION (TREE_TYPE (type
))
2062 == TYPE_PRECISION (char_type_node
))
2064 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2065 "argument to %<sizeof%> in %qD call is the same "
2066 "expression as the source; did you mean to "
2067 "provide an explicit length?", callee
);
2069 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2070 "argument to %<sizeof%> in %qD call is the same "
2071 "expression as the source; did you mean to "
2072 "dereference it?", callee
);
2076 if (POINTER_TYPE_P (TREE_TYPE (src
))
2078 && comp_types (TREE_TYPE (src
), type
)
2079 && !VOID_TYPE_P (TREE_TYPE (type
)))
2081 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2082 "argument to %<sizeof%> in %qD call is the same "
2083 "pointer type %qT as the source; expected %qT "
2084 "or an explicit length", callee
, TREE_TYPE (src
),
2085 TREE_TYPE (TREE_TYPE (src
)));
2092 if (!TYPE_P (sizeof_arg
[idx
])
2093 && operand_equal_p (dest
, sizeof_arg
[idx
], 0)
2094 && comp_types (TREE_TYPE (dest
), type
))
2096 if (TREE_CODE (sizeof_arg
[idx
]) == ADDR_EXPR
&& !strop
)
2097 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2098 "argument to %<sizeof%> in %qD call is the same "
2099 "expression as the first source; did you mean to "
2100 "remove the addressof?", callee
);
2101 else if ((TYPE_PRECISION (TREE_TYPE (type
))
2102 == TYPE_PRECISION (char_type_node
))
2104 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2105 "argument to %<sizeof%> in %qD call is the same "
2106 "expression as the first source; did you mean to "
2107 "provide an explicit length?", callee
);
2109 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2110 "argument to %<sizeof%> in %qD call is the same "
2111 "expression as the first source; did you mean to "
2112 "dereference it?", callee
);
2116 if (POINTER_TYPE_P (TREE_TYPE (dest
))
2118 && comp_types (TREE_TYPE (dest
), type
)
2119 && !VOID_TYPE_P (TREE_TYPE (type
)))
2121 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2122 "argument to %<sizeof%> in %qD call is the same "
2123 "pointer type %qT as the first source; expected %qT "
2124 "or an explicit length", callee
, TREE_TYPE (dest
),
2125 TREE_TYPE (TREE_TYPE (dest
)));
2132 if (!TYPE_P (sizeof_arg
[idx
])
2133 && operand_equal_p (src
, sizeof_arg
[idx
], 0)
2134 && comp_types (TREE_TYPE (src
), type
))
2136 if (TREE_CODE (sizeof_arg
[idx
]) == ADDR_EXPR
&& !strop
)
2137 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2138 "argument to %<sizeof%> in %qD call is the same "
2139 "expression as the second source; did you mean to "
2140 "remove the addressof?", callee
);
2141 else if ((TYPE_PRECISION (TREE_TYPE (type
))
2142 == TYPE_PRECISION (char_type_node
))
2144 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2145 "argument to %<sizeof%> in %qD call is the same "
2146 "expression as the second source; did you mean to "
2147 "provide an explicit length?", callee
);
2149 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2150 "argument to %<sizeof%> in %qD call is the same "
2151 "expression as the second source; did you mean to "
2152 "dereference it?", callee
);
2156 if (POINTER_TYPE_P (TREE_TYPE (src
))
2158 && comp_types (TREE_TYPE (src
), type
)
2159 && !VOID_TYPE_P (TREE_TYPE (type
)))
2161 warning_at (loc
, OPT_Wsizeof_pointer_memaccess
,
2162 "argument to %<sizeof%> in %qD call is the same "
2163 "pointer type %qT as the second source; expected %qT "
2164 "or an explicit length", callee
, TREE_TYPE (src
),
2165 TREE_TYPE (TREE_TYPE (src
)));
2172 /* Warn for unlikely, improbable, or stupid DECL declarations
2176 check_main_parameter_types (tree decl
)
2178 function_args_iterator iter
;
2182 FOREACH_FUNCTION_ARGS (TREE_TYPE (decl
), type
, iter
)
2184 /* XXX void_type_node belies the abstraction. */
2185 if (type
== void_type_node
|| type
== error_mark_node
)
2192 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
2193 pedwarn (input_location
, OPT_Wmain
,
2194 "first argument of %q+D should be %<int%>", decl
);
2198 if (TREE_CODE (type
) != POINTER_TYPE
2199 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
2200 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
2202 pedwarn (input_location
, OPT_Wmain
,
2203 "second argument of %q+D should be %<char **%>", decl
);
2207 if (TREE_CODE (type
) != POINTER_TYPE
2208 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
2209 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
2211 pedwarn (input_location
, OPT_Wmain
,
2212 "third argument of %q+D should probably be "
2213 "%<char **%>", decl
);
2218 /* It is intentional that this message does not mention the third
2219 argument because it's only mentioned in an appendix of the
2221 if (argct
> 0 && (argct
< 2 || argct
> 3))
2222 pedwarn (input_location
, OPT_Wmain
,
2223 "%q+D takes only zero or two arguments", decl
);
2226 /* vector_targets_convertible_p is used for vector pointer types. The
2227 callers perform various checks that the qualifiers are satisfactory,
2228 while OTOH vector_targets_convertible_p ignores the number of elements
2229 in the vectors. That's fine with vector pointers as we can consider,
2230 say, a vector of 8 elements as two consecutive vectors of 4 elements,
2231 and that does not require and conversion of the pointer values.
2232 In contrast, vector_types_convertible_p and
2233 vector_types_compatible_elements_p are used for vector value types. */
2234 /* True if pointers to distinct types T1 and T2 can be converted to
2235 each other without an explicit cast. Only returns true for opaque
2238 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
2240 if (TREE_CODE (t1
) == VECTOR_TYPE
&& TREE_CODE (t2
) == VECTOR_TYPE
2241 && (TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
2242 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
2248 /* vector_types_convertible_p is used for vector value types.
2249 It could in principle call vector_targets_convertible_p as a subroutine,
2250 but then the check for vector type would be duplicated with its callers,
2251 and also the purpose of vector_targets_convertible_p would become
2253 Where vector_types_convertible_p returns true, a conversion might still be
2254 needed to make the types match.
2255 In contrast, vector_targets_convertible_p is used for vector pointer
2256 values, and vector_types_compatible_elements_p is used specifically
2257 in the context for binary operators, as a check if use is possible without
2259 /* True if vector types T1 and T2 can be converted to each other
2260 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
2261 can only be converted with -flax-vector-conversions yet that is not
2262 in effect, emit a note telling the user about that option if such
2263 a note has not previously been emitted. */
2265 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
2267 static bool emitted_lax_note
= false;
2268 bool convertible_lax
;
2270 if ((TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
2271 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
2275 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
2276 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
2277 TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
))
2278 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
2279 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
2281 if (!convertible_lax
|| flag_lax_vector_conversions
)
2282 return convertible_lax
;
2284 if (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
2285 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
2288 if (emit_lax_note
&& !emitted_lax_note
)
2290 emitted_lax_note
= true;
2291 inform (input_location
, "use -flax-vector-conversions to permit "
2292 "conversions between vectors with differing "
2293 "element types or numbers of subparts");
2299 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes
2300 and have vector types, V0 has the same type as V1, and the number of
2301 elements of V0, V1, MASK is the same.
2303 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
2304 called with two arguments. In this case implementation passes the
2305 first argument twice in order to share the same tree code. This fact
2306 could enable the mask-values being twice the vector length. This is
2307 an implementation accident and this semantics is not guaranteed to
2310 c_build_vec_perm_expr (location_t loc
, tree v0
, tree v1
, tree mask
,
2315 bool maybe_const
= false;
2316 bool two_arguments
= false;
2318 if (v1
== NULL_TREE
)
2320 two_arguments
= true;
2324 if (v0
== error_mark_node
|| v1
== error_mark_node
2325 || mask
== error_mark_node
)
2326 return error_mark_node
;
2328 if (TREE_CODE (TREE_TYPE (mask
)) != VECTOR_TYPE
2329 || TREE_CODE (TREE_TYPE (TREE_TYPE (mask
))) != INTEGER_TYPE
)
2332 error_at (loc
, "__builtin_shuffle last argument must "
2333 "be an integer vector");
2334 return error_mark_node
;
2337 if (TREE_CODE (TREE_TYPE (v0
)) != VECTOR_TYPE
2338 || TREE_CODE (TREE_TYPE (v1
)) != VECTOR_TYPE
)
2341 error_at (loc
, "__builtin_shuffle arguments must be vectors");
2342 return error_mark_node
;
2345 if (TYPE_MAIN_VARIANT (TREE_TYPE (v0
)) != TYPE_MAIN_VARIANT (TREE_TYPE (v1
)))
2348 error_at (loc
, "__builtin_shuffle argument vectors must be of "
2350 return error_mark_node
;
2353 if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v0
))
2354 != TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask
))
2355 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (v1
))
2356 != TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask
)))
2359 error_at (loc
, "__builtin_shuffle number of elements of the "
2360 "argument vector(s) and the mask vector should "
2362 return error_mark_node
;
2365 if (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (v0
))))
2366 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (mask
)))))
2369 error_at (loc
, "__builtin_shuffle argument vector(s) inner type "
2370 "must have the same size as inner type of the mask");
2371 return error_mark_node
;
2374 if (!c_dialect_cxx ())
2376 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
2377 v0
= c_fully_fold (v0
, false, &maybe_const
);
2378 wrap
&= maybe_const
;
2381 v1
= v0
= save_expr (v0
);
2384 v1
= c_fully_fold (v1
, false, &maybe_const
);
2385 wrap
&= maybe_const
;
2388 mask
= c_fully_fold (mask
, false, &maybe_const
);
2389 wrap
&= maybe_const
;
2391 else if (two_arguments
)
2392 v1
= v0
= save_expr (v0
);
2394 ret
= build3_loc (loc
, VEC_PERM_EXPR
, TREE_TYPE (v0
), v0
, v1
, mask
);
2396 if (!c_dialect_cxx () && !wrap
)
2397 ret
= c_wrap_maybe_const (ret
, true);
2402 /* Like tree.c:get_narrower, but retain conversion from C++0x scoped enum
2403 to integral type. */
2406 c_common_get_narrower (tree op
, int *unsignedp_ptr
)
2408 op
= get_narrower (op
, unsignedp_ptr
);
2410 if (TREE_CODE (TREE_TYPE (op
)) == ENUMERAL_TYPE
2411 && ENUM_IS_SCOPED (TREE_TYPE (op
)))
2413 /* C++0x scoped enumerations don't implicitly convert to integral
2414 type; if we stripped an explicit conversion to a larger type we
2415 need to replace it so common_type will still work. */
2416 tree type
= c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op
)),
2417 TYPE_UNSIGNED (TREE_TYPE (op
)));
2418 op
= fold_convert (type
, op
);
2423 /* This is a helper function of build_binary_op.
2425 For certain operations if both args were extended from the same
2426 smaller type, do the arithmetic in that type and then extend.
2428 BITWISE indicates a bitwise operation.
2429 For them, this optimization is safe only if
2430 both args are zero-extended or both are sign-extended.
2431 Otherwise, we might change the result.
2432 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2433 but calculated in (unsigned short) it would be (unsigned short)-1.
2436 shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
2438 int unsigned0
, unsigned1
;
2443 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
2444 excessive narrowing when we call get_narrower below. For
2445 example, suppose that OP0 is of unsigned int extended
2446 from signed char and that RESULT_TYPE is long long int.
2447 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
2450 (long long int) (unsigned int) signed_char
2452 which get_narrower would narrow down to
2454 (unsigned int) signed char
2456 If we do not cast OP0 first, get_narrower would return
2457 signed_char, which is inconsistent with the case of the
2459 op0
= convert (result_type
, op0
);
2460 op1
= convert (result_type
, op1
);
2462 arg0
= c_common_get_narrower (op0
, &unsigned0
);
2463 arg1
= c_common_get_narrower (op1
, &unsigned1
);
2465 /* UNS is 1 if the operation to be done is an unsigned one. */
2466 uns
= TYPE_UNSIGNED (result_type
);
2468 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2469 but it *requires* conversion to FINAL_TYPE. */
2471 if ((TYPE_PRECISION (TREE_TYPE (op0
))
2472 == TYPE_PRECISION (TREE_TYPE (arg0
)))
2473 && TREE_TYPE (op0
) != result_type
)
2474 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2475 if ((TYPE_PRECISION (TREE_TYPE (op1
))
2476 == TYPE_PRECISION (TREE_TYPE (arg1
)))
2477 && TREE_TYPE (op1
) != result_type
)
2478 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2480 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2482 /* For bitwise operations, signedness of nominal type
2483 does not matter. Consider only how operands were extended. */
2487 /* Note that in all three cases below we refrain from optimizing
2488 an unsigned operation on sign-extended args.
2489 That would not be valid. */
2491 /* Both args variable: if both extended in same way
2492 from same width, do it in that width.
2493 Do it unsigned if args were zero-extended. */
2494 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
2495 < TYPE_PRECISION (result_type
))
2496 && (TYPE_PRECISION (TREE_TYPE (arg1
))
2497 == TYPE_PRECISION (TREE_TYPE (arg0
)))
2498 && unsigned0
== unsigned1
2499 && (unsigned0
|| !uns
))
2500 return c_common_signed_or_unsigned_type
2501 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
2503 else if (TREE_CODE (arg0
) == INTEGER_CST
2504 && (unsigned1
|| !uns
)
2505 && (TYPE_PRECISION (TREE_TYPE (arg1
))
2506 < TYPE_PRECISION (result_type
))
2508 = c_common_signed_or_unsigned_type (unsigned1
,
2510 && !POINTER_TYPE_P (type
)
2511 && int_fits_type_p (arg0
, type
))
2514 else if (TREE_CODE (arg1
) == INTEGER_CST
2515 && (unsigned0
|| !uns
)
2516 && (TYPE_PRECISION (TREE_TYPE (arg0
))
2517 < TYPE_PRECISION (result_type
))
2519 = c_common_signed_or_unsigned_type (unsigned0
,
2521 && !POINTER_TYPE_P (type
)
2522 && int_fits_type_p (arg1
, type
))
2528 /* Checks if expression EXPR of real/integer type cannot be converted
2529 to the real/integer type TYPE. Function returns true when:
2530 * EXPR is a constant which cannot be exactly converted to TYPE
2531 * EXPR is not a constant and size of EXPR's type > than size of TYPE,
2532 for EXPR type and TYPE being both integers or both real.
2533 * EXPR is not a constant of real type and TYPE is an integer.
2534 * EXPR is not a constant of integer type which cannot be
2535 exactly converted to real type.
2536 Function allows conversions between types of different signedness and
2537 does not return true in that case. Function can produce signedness
2538 warnings if PRODUCE_WARNS is true. */
2540 unsafe_conversion_p (tree type
, tree expr
, bool produce_warns
)
2542 bool give_warning
= false;
2543 tree expr_type
= TREE_TYPE (expr
);
2544 location_t loc
= EXPR_LOC_OR_HERE (expr
);
2546 if (TREE_CODE (expr
) == REAL_CST
|| TREE_CODE (expr
) == INTEGER_CST
)
2548 /* Warn for real constant that is not an exact integer converted
2550 if (TREE_CODE (expr_type
) == REAL_TYPE
2551 && TREE_CODE (type
) == INTEGER_TYPE
)
2553 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (expr_type
)))
2554 give_warning
= true;
2556 /* Warn for an integer constant that does not fit into integer type. */
2557 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2558 && TREE_CODE (type
) == INTEGER_TYPE
2559 && !int_fits_type_p (expr
, type
))
2561 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)
2562 && tree_int_cst_sgn (expr
) < 0)
2565 warning_at (loc
, OPT_Wsign_conversion
, "negative integer"
2566 " implicitly converted to unsigned type");
2568 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (expr_type
))
2571 warning_at (loc
, OPT_Wsign_conversion
, "conversion of unsigned"
2572 " constant value to negative integer");
2575 give_warning
= true;
2577 else if (TREE_CODE (type
) == REAL_TYPE
)
2579 /* Warn for an integer constant that does not fit into real type. */
2580 if (TREE_CODE (expr_type
) == INTEGER_TYPE
)
2582 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
2583 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
2584 give_warning
= true;
2586 /* Warn for a real constant that does not fit into a smaller
2588 else if (TREE_CODE (expr_type
) == REAL_TYPE
2589 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2591 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
2592 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
2593 give_warning
= true;
2599 /* Warn for real types converted to integer types. */
2600 if (TREE_CODE (expr_type
) == REAL_TYPE
2601 && TREE_CODE (type
) == INTEGER_TYPE
)
2602 give_warning
= true;
2604 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2605 && TREE_CODE (type
) == INTEGER_TYPE
)
2607 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2608 expr
= get_unwidened (expr
, 0);
2609 expr_type
= TREE_TYPE (expr
);
2611 /* Don't warn for short y; short x = ((int)y & 0xff); */
2612 if (TREE_CODE (expr
) == BIT_AND_EXPR
2613 || TREE_CODE (expr
) == BIT_IOR_EXPR
2614 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
2616 /* If both args were extended from a shortest type,
2617 use that type if that is safe. */
2618 expr_type
= shorten_binary_op (expr_type
,
2619 TREE_OPERAND (expr
, 0),
2620 TREE_OPERAND (expr
, 1),
2623 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
2625 tree op0
= TREE_OPERAND (expr
, 0);
2626 tree op1
= TREE_OPERAND (expr
, 1);
2627 bool unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2628 bool unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2630 /* If one of the operands is a non-negative constant
2631 that fits in the target type, then the type of the
2632 other operand does not matter. */
2633 if ((TREE_CODE (op0
) == INTEGER_CST
2634 && int_fits_type_p (op0
, c_common_signed_type (type
))
2635 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
2636 || (TREE_CODE (op1
) == INTEGER_CST
2637 && int_fits_type_p (op1
, c_common_signed_type (type
))
2638 && int_fits_type_p (op1
,
2639 c_common_unsigned_type (type
))))
2641 /* If constant is unsigned and fits in the target
2642 type, then the result will also fit. */
2643 else if ((TREE_CODE (op0
) == INTEGER_CST
2645 && int_fits_type_p (op0
, type
))
2646 || (TREE_CODE (op1
) == INTEGER_CST
2648 && int_fits_type_p (op1
, type
)))
2652 /* Warn for integer types converted to smaller integer types. */
2653 if (TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2654 give_warning
= true;
2656 /* When they are the same width but different signedness,
2657 then the value may change. */
2658 else if (((TYPE_PRECISION (type
) == TYPE_PRECISION (expr_type
)
2659 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
2660 /* Even when converted to a bigger type, if the type is
2661 unsigned but expr is signed, then negative values
2663 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
2665 warning_at (loc
, OPT_Wsign_conversion
, "conversion to %qT from %qT "
2666 "may change the sign of the result",
2670 /* Warn for integer types converted to real types if and only if
2671 all the range of values of the integer type cannot be
2672 represented by the real type. */
2673 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2674 && TREE_CODE (type
) == REAL_TYPE
)
2676 tree type_low_bound
, type_high_bound
;
2677 REAL_VALUE_TYPE real_low_bound
, real_high_bound
;
2679 /* Don't warn about char y = 0xff; float x = (int) y; */
2680 expr
= get_unwidened (expr
, 0);
2681 expr_type
= TREE_TYPE (expr
);
2683 type_low_bound
= TYPE_MIN_VALUE (expr_type
);
2684 type_high_bound
= TYPE_MAX_VALUE (expr_type
);
2685 real_low_bound
= real_value_from_int_cst (0, type_low_bound
);
2686 real_high_bound
= real_value_from_int_cst (0, type_high_bound
);
2688 if (!exact_real_truncate (TYPE_MODE (type
), &real_low_bound
)
2689 || !exact_real_truncate (TYPE_MODE (type
), &real_high_bound
))
2690 give_warning
= true;
2693 /* Warn for real types converted to smaller real types. */
2694 else if (TREE_CODE (expr_type
) == REAL_TYPE
2695 && TREE_CODE (type
) == REAL_TYPE
2696 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2697 give_warning
= true;
2700 return give_warning
;
2703 /* Warns if the conversion of EXPR to TYPE may alter a value.
2704 This is a helper function for warnings_for_convert_and_check. */
2707 conversion_warning (tree type
, tree expr
)
2709 tree expr_type
= TREE_TYPE (expr
);
2710 location_t loc
= EXPR_LOC_OR_HERE (expr
);
2712 if (!warn_conversion
&& !warn_sign_conversion
)
2715 switch (TREE_CODE (expr
))
2723 case TRUTH_ANDIF_EXPR
:
2724 case TRUTH_ORIF_EXPR
:
2725 case TRUTH_AND_EXPR
:
2727 case TRUTH_XOR_EXPR
:
2728 case TRUTH_NOT_EXPR
:
2729 /* Conversion from boolean to a signed:1 bit-field (which only
2730 can hold the values 0 and -1) doesn't lose information - but
2731 it does change the value. */
2732 if (TYPE_PRECISION (type
) == 1 && !TYPE_UNSIGNED (type
))
2733 warning_at (loc
, OPT_Wconversion
,
2734 "conversion to %qT from boolean expression", type
);
2739 if (unsafe_conversion_p (type
, expr
, true))
2740 warning_at (loc
, OPT_Wconversion
,
2741 "conversion to %qT alters %qT constant value",
2747 /* In case of COND_EXPR, we do not care about the type of
2748 COND_EXPR, only about the conversion of each operand. */
2749 tree op1
= TREE_OPERAND (expr
, 1);
2750 tree op2
= TREE_OPERAND (expr
, 2);
2752 conversion_warning (type
, op1
);
2753 conversion_warning (type
, op2
);
2757 default: /* 'expr' is not a constant. */
2758 if (unsafe_conversion_p (type
, expr
, true))
2759 warning_at (loc
, OPT_Wconversion
,
2760 "conversion to %qT from %qT may alter its value",
2765 /* Produce warnings after a conversion. RESULT is the result of
2766 converting EXPR to TYPE. This is a helper function for
2767 convert_and_check and cp_convert_and_check. */
2770 warnings_for_convert_and_check (tree type
, tree expr
, tree result
)
2772 location_t loc
= EXPR_LOC_OR_HERE (expr
);
2774 if (TREE_CODE (expr
) == INTEGER_CST
2775 && (TREE_CODE (type
) == INTEGER_TYPE
2776 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2777 && !int_fits_type_p (expr
, type
))
2779 /* Do not diagnose overflow in a constant expression merely
2780 because a conversion overflowed. */
2781 if (TREE_OVERFLOW (result
))
2782 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
2784 if (TYPE_UNSIGNED (type
))
2786 /* This detects cases like converting -129 or 256 to
2788 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
2789 warning_at (loc
, OPT_Woverflow
,
2790 "large integer implicitly truncated to unsigned type");
2792 conversion_warning (type
, expr
);
2794 else if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
2795 warning (OPT_Woverflow
,
2796 "overflow in implicit constant conversion");
2797 /* No warning for converting 0x80000000 to int. */
2799 && (TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
2800 || TYPE_PRECISION (TREE_TYPE (expr
))
2801 != TYPE_PRECISION (type
)))
2802 warning_at (loc
, OPT_Woverflow
,
2803 "overflow in implicit constant conversion");
2806 conversion_warning (type
, expr
);
2808 else if ((TREE_CODE (result
) == INTEGER_CST
2809 || TREE_CODE (result
) == FIXED_CST
) && TREE_OVERFLOW (result
))
2810 warning_at (loc
, OPT_Woverflow
,
2811 "overflow in implicit constant conversion");
2813 conversion_warning (type
, expr
);
2817 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2818 Invoke this function on every expression that is converted implicitly,
2819 i.e. because of language rules and not because of an explicit cast. */
2822 convert_and_check (tree type
, tree expr
)
2825 tree expr_for_warning
;
2827 /* Convert from a value with possible excess precision rather than
2828 via the semantic type, but do not warn about values not fitting
2829 exactly in the semantic type. */
2830 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
2832 tree orig_type
= TREE_TYPE (expr
);
2833 expr
= TREE_OPERAND (expr
, 0);
2834 expr_for_warning
= convert (orig_type
, expr
);
2835 if (orig_type
== type
)
2836 return expr_for_warning
;
2839 expr_for_warning
= expr
;
2841 if (TREE_TYPE (expr
) == type
)
2844 result
= convert (type
, expr
);
2846 if (c_inhibit_evaluation_warnings
== 0
2847 && !TREE_OVERFLOW_P (expr
)
2848 && result
!= error_mark_node
)
2849 warnings_for_convert_and_check (type
, expr_for_warning
, result
);
2854 /* A node in a list that describes references to variables (EXPR), which are
2855 either read accesses if WRITER is zero, or write accesses, in which case
2856 WRITER is the parent of EXPR. */
2863 /* Used to implement a cache the results of a call to verify_tree. We only
2864 use this for SAVE_EXPRs. */
2867 struct tlist_cache
*next
;
2868 struct tlist
*cache_before_sp
;
2869 struct tlist
*cache_after_sp
;
2873 /* Obstack to use when allocating tlist structures, and corresponding
2875 static struct obstack tlist_obstack
;
2876 static char *tlist_firstobj
= 0;
2878 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2880 static struct tlist
*warned_ids
;
2881 /* SAVE_EXPRs need special treatment. We process them only once and then
2882 cache the results. */
2883 static struct tlist_cache
*save_expr_cache
;
2885 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
2886 static void merge_tlist (struct tlist
**, struct tlist
*, int);
2887 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
2888 static int warning_candidate_p (tree
);
2889 static bool candidate_equal_p (const_tree
, const_tree
);
2890 static void warn_for_collisions (struct tlist
*);
2891 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
2892 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
2894 /* Create a new struct tlist and fill in its fields. */
2895 static struct tlist
*
2896 new_tlist (struct tlist
*next
, tree t
, tree writer
)
2899 l
= XOBNEW (&tlist_obstack
, struct tlist
);
2906 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2907 is nonnull, we ignore any node we find which has a writer equal to it. */
2910 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
2914 struct tlist
*next
= add
->next
;
2917 if (!exclude_writer
|| !candidate_equal_p (add
->writer
, exclude_writer
))
2918 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
2923 /* Merge the nodes of ADD into TO. This merging process is done so that for
2924 each variable that already exists in TO, no new node is added; however if
2925 there is a write access recorded in ADD, and an occurrence on TO is only
2926 a read access, then the occurrence in TO will be modified to record the
2930 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
2932 struct tlist
**end
= to
;
2935 end
= &(*end
)->next
;
2941 struct tlist
*next
= add
->next
;
2943 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
2944 if (candidate_equal_p (tmp2
->expr
, add
->expr
))
2948 tmp2
->writer
= add
->writer
;
2952 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
2953 end
= &(*end
)->next
;
2960 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2961 references in list LIST conflict with it, excluding reads if ONLY writers
2965 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
2970 /* Avoid duplicate warnings. */
2971 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
2972 if (candidate_equal_p (tmp
->expr
, written
))
2977 if (candidate_equal_p (list
->expr
, written
)
2978 && !candidate_equal_p (list
->writer
, writer
)
2979 && (!only_writes
|| list
->writer
))
2981 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
2982 warning_at (EXPR_LOC_OR_HERE (writer
),
2983 OPT_Wsequence_point
, "operation on %qE may be undefined",
2990 /* Given a list LIST of references to variables, find whether any of these
2991 can cause conflicts due to missing sequence points. */
2994 warn_for_collisions (struct tlist
*list
)
2998 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
3001 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
3005 /* Return nonzero if X is a tree that can be verified by the sequence point
3008 warning_candidate_p (tree x
)
3010 if (DECL_P (x
) && DECL_ARTIFICIAL (x
))
3013 if (TREE_CODE (x
) == BLOCK
)
3016 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
3017 (lvalue_p) crash on TRY/CATCH. */
3018 if (TREE_TYPE (x
) == NULL_TREE
|| VOID_TYPE_P (TREE_TYPE (x
)))
3024 /* No point to track non-const calls, they will never satisfy
3026 if (TREE_CODE (x
) == CALL_EXPR
&& (call_expr_flags (x
) & ECF_CONST
) == 0)
3029 if (TREE_CODE (x
) == STRING_CST
)
3035 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
3037 candidate_equal_p (const_tree x
, const_tree y
)
3039 return (x
== y
) || (x
&& y
&& operand_equal_p (x
, y
, 0));
3042 /* Walk the tree X, and record accesses to variables. If X is written by the
3043 parent tree, WRITER is the parent.
3044 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
3045 expression or its only operand forces a sequence point, then everything up
3046 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
3048 Once we return, we will have emitted warnings if any subexpression before
3049 such a sequence point could be undefined. On a higher level, however, the
3050 sequence point may not be relevant, and we'll merge the two lists.
3052 Example: (b++, a) + b;
3053 The call that processes the COMPOUND_EXPR will store the increment of B
3054 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
3055 processes the PLUS_EXPR will need to merge the two lists so that
3056 eventually, all accesses end up on the same list (and we'll warn about the
3057 unordered subexpressions b++ and b.
3059 A note on merging. If we modify the former example so that our expression
3062 care must be taken not simply to add all three expressions into the final
3063 PNO_SP list. The function merge_tlist takes care of that by merging the
3064 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
3065 way, so that no more than one access to B is recorded. */
3068 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
3071 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
3072 enum tree_code code
;
3073 enum tree_code_class cl
;
3075 /* X may be NULL if it is the operand of an empty statement expression
3081 code
= TREE_CODE (x
);
3082 cl
= TREE_CODE_CLASS (code
);
3084 if (warning_candidate_p (x
))
3085 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
3094 case TRUTH_ANDIF_EXPR
:
3095 case TRUTH_ORIF_EXPR
:
3096 tmp_before
= tmp_nosp
= tmp_list3
= 0;
3097 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
3098 warn_for_collisions (tmp_nosp
);
3099 merge_tlist (pbefore_sp
, tmp_before
, 0);
3100 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
3101 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
3102 merge_tlist (pbefore_sp
, tmp_list3
, 0);
3106 tmp_before
= tmp_list2
= 0;
3107 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
3108 warn_for_collisions (tmp_list2
);
3109 merge_tlist (pbefore_sp
, tmp_before
, 0);
3110 merge_tlist (pbefore_sp
, tmp_list2
, 1);
3112 tmp_list3
= tmp_nosp
= 0;
3113 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
3114 warn_for_collisions (tmp_nosp
);
3115 merge_tlist (pbefore_sp
, tmp_list3
, 0);
3117 tmp_list3
= tmp_list2
= 0;
3118 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
3119 warn_for_collisions (tmp_list2
);
3120 merge_tlist (pbefore_sp
, tmp_list3
, 0);
3121 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
3122 two first, to avoid warning for (a ? b++ : b++). */
3123 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
3124 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
3127 case PREDECREMENT_EXPR
:
3128 case PREINCREMENT_EXPR
:
3129 case POSTDECREMENT_EXPR
:
3130 case POSTINCREMENT_EXPR
:
3131 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
3135 tmp_before
= tmp_nosp
= tmp_list3
= 0;
3136 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
3137 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
3138 /* Expressions inside the LHS are not ordered wrt. the sequence points
3139 in the RHS. Example:
3141 Despite the fact that the modification of "a" is in the before_sp
3142 list (tmp_before), it conflicts with the use of "a" in the LHS.
3143 We can handle this by adding the contents of tmp_list3
3144 to those of tmp_before, and redoing the collision warnings for that
3146 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
3147 warn_for_collisions (tmp_before
);
3148 /* Exclude the LHS itself here; we first have to merge it into the
3149 tmp_nosp list. This is done to avoid warning for "a = a"; if we
3150 didn't exclude the LHS, we'd get it twice, once as a read and once
3152 add_tlist (pno_sp
, tmp_list3
, x
, 0);
3153 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
3155 merge_tlist (pbefore_sp
, tmp_before
, 0);
3156 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
3157 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
3158 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
3162 /* We need to warn about conflicts among arguments and conflicts between
3163 args and the function address. Side effects of the function address,
3164 however, are not ordered by the sequence point of the call. */
3166 call_expr_arg_iterator iter
;
3168 tmp_before
= tmp_nosp
= 0;
3169 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
3170 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
3172 tmp_list2
= tmp_list3
= 0;
3173 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
3174 merge_tlist (&tmp_list3
, tmp_list2
, 0);
3175 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
3177 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
3178 warn_for_collisions (tmp_before
);
3179 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
3184 /* Scan all the list, e.g. indices of multi dimensional array. */
3187 tmp_before
= tmp_nosp
= 0;
3188 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
3189 merge_tlist (&tmp_nosp
, tmp_before
, 0);
3190 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
3197 struct tlist_cache
*t
;
3198 for (t
= save_expr_cache
; t
; t
= t
->next
)
3199 if (candidate_equal_p (t
->expr
, x
))
3204 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
3205 t
->next
= save_expr_cache
;
3207 save_expr_cache
= t
;
3209 tmp_before
= tmp_nosp
= 0;
3210 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
3211 warn_for_collisions (tmp_nosp
);
3216 struct tlist
*t
= tmp_nosp
;
3218 merge_tlist (&tmp_list3
, t
, 0);
3220 t
->cache_before_sp
= tmp_before
;
3221 t
->cache_after_sp
= tmp_list3
;
3223 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
3224 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
3229 x
= TREE_OPERAND (x
, 0);
3236 /* For other expressions, simply recurse on their operands.
3237 Manual tail recursion for unary expressions.
3238 Other non-expressions need not be processed. */
3239 if (cl
== tcc_unary
)
3241 x
= TREE_OPERAND (x
, 0);
3245 else if (IS_EXPR_CODE_CLASS (cl
))
3248 int max
= TREE_OPERAND_LENGTH (x
);
3249 for (lp
= 0; lp
< max
; lp
++)
3251 tmp_before
= tmp_nosp
= 0;
3252 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
3253 merge_tlist (&tmp_nosp
, tmp_before
, 0);
3254 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
3261 /* Try to warn for undefined behavior in EXPR due to missing sequence
3265 verify_sequence_points (tree expr
)
3267 struct tlist
*before_sp
= 0, *after_sp
= 0;
3270 save_expr_cache
= 0;
3271 if (tlist_firstobj
== 0)
3273 gcc_obstack_init (&tlist_obstack
);
3274 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
3277 verify_tree (expr
, &before_sp
, &after_sp
, 0);
3278 warn_for_collisions (after_sp
);
3279 obstack_free (&tlist_obstack
, tlist_firstobj
);
3282 /* Validate the expression after `case' and apply default promotions. */
3285 check_case_value (tree value
)
3287 if (value
== NULL_TREE
)
3290 if (TREE_CODE (value
) == INTEGER_CST
)
3291 /* Promote char or short to int. */
3292 value
= perform_integral_promotions (value
);
3293 else if (value
!= error_mark_node
)
3295 error ("case label does not reduce to an integer constant");
3296 value
= error_mark_node
;
3299 constant_expression_warning (value
);
3304 /* See if the case values LOW and HIGH are in the range of the original
3305 type (i.e. before the default conversion to int) of the switch testing
3307 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
3308 the type before promoting it. CASE_LOW_P is a pointer to the lower
3309 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
3310 if the case is not a case range.
3311 The caller has to make sure that we are not called with NULL for
3312 CASE_LOW_P (i.e. the default case).
3313 Returns true if the case label is in range of ORIG_TYPE (saturated or
3314 untouched) or false if the label is out of range. */
3317 check_case_bounds (tree type
, tree orig_type
,
3318 tree
*case_low_p
, tree
*case_high_p
)
3320 tree min_value
, max_value
;
3321 tree case_low
= *case_low_p
;
3322 tree case_high
= case_high_p
? *case_high_p
: case_low
;
3324 /* If there was a problem with the original type, do nothing. */
3325 if (orig_type
== error_mark_node
)
3328 min_value
= TYPE_MIN_VALUE (orig_type
);
3329 max_value
= TYPE_MAX_VALUE (orig_type
);
3331 /* Case label is less than minimum for type. */
3332 if (tree_int_cst_compare (case_low
, min_value
) < 0
3333 && tree_int_cst_compare (case_high
, min_value
) < 0)
3335 warning (0, "case label value is less than minimum value for type");
3339 /* Case value is greater than maximum for type. */
3340 if (tree_int_cst_compare (case_low
, max_value
) > 0
3341 && tree_int_cst_compare (case_high
, max_value
) > 0)
3343 warning (0, "case label value exceeds maximum value for type");
3347 /* Saturate lower case label value to minimum. */
3348 if (tree_int_cst_compare (case_high
, min_value
) >= 0
3349 && tree_int_cst_compare (case_low
, min_value
) < 0)
3351 warning (0, "lower value in case label range"
3352 " less than minimum value for type");
3353 case_low
= min_value
;
3356 /* Saturate upper case label value to maximum. */
3357 if (tree_int_cst_compare (case_low
, max_value
) <= 0
3358 && tree_int_cst_compare (case_high
, max_value
) > 0)
3360 warning (0, "upper value in case label range"
3361 " exceeds maximum value for type");
3362 case_high
= max_value
;
3365 if (*case_low_p
!= case_low
)
3366 *case_low_p
= convert (type
, case_low
);
3367 if (case_high_p
&& *case_high_p
!= case_high
)
3368 *case_high_p
= convert (type
, case_high
);
3373 /* Return an integer type with BITS bits of precision,
3374 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
3377 c_common_type_for_size (unsigned int bits
, int unsignedp
)
3379 if (bits
== TYPE_PRECISION (integer_type_node
))
3380 return unsignedp
? unsigned_type_node
: integer_type_node
;
3382 if (bits
== TYPE_PRECISION (signed_char_type_node
))
3383 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3385 if (bits
== TYPE_PRECISION (short_integer_type_node
))
3386 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3388 if (bits
== TYPE_PRECISION (long_integer_type_node
))
3389 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3391 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
3392 return (unsignedp
? long_long_unsigned_type_node
3393 : long_long_integer_type_node
);
3395 if (int128_integer_type_node
3396 && bits
== TYPE_PRECISION (int128_integer_type_node
))
3397 return (unsignedp
? int128_unsigned_type_node
3398 : int128_integer_type_node
);
3400 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
3401 return (unsignedp
? widest_unsigned_literal_type_node
3402 : widest_integer_literal_type_node
);
3404 if (bits
<= TYPE_PRECISION (intQI_type_node
))
3405 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3407 if (bits
<= TYPE_PRECISION (intHI_type_node
))
3408 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3410 if (bits
<= TYPE_PRECISION (intSI_type_node
))
3411 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3413 if (bits
<= TYPE_PRECISION (intDI_type_node
))
3414 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3419 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
3420 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
3421 and saturating if SATP is nonzero, otherwise not saturating. */
3424 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
3425 int unsignedp
, int satp
)
3427 enum machine_mode mode
;
3429 mode
= unsignedp
? UQQmode
: QQmode
;
3431 mode
= unsignedp
? UHAmode
: HAmode
;
3433 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
3434 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
3437 if (mode
== VOIDmode
|| !targetm
.scalar_mode_supported_p (mode
))
3439 sorry ("GCC cannot support operators with integer types and "
3440 "fixed-point types that have too many integral and "
3441 "fractional bits together");
3445 return c_common_type_for_mode (mode
, satp
);
3448 /* Used for communication between c_common_type_for_mode and
3449 c_register_builtin_type. */
3450 static GTY(()) tree registered_builtin_types
;
3452 /* Return a data type that has machine mode MODE.
3453 If the mode is an integer,
3454 then UNSIGNEDP selects between signed and unsigned types.
3455 If the mode is a fixed-point mode,
3456 then UNSIGNEDP selects between saturating and nonsaturating types. */
3459 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
3463 if (mode
== TYPE_MODE (integer_type_node
))
3464 return unsignedp
? unsigned_type_node
: integer_type_node
;
3466 if (mode
== TYPE_MODE (signed_char_type_node
))
3467 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3469 if (mode
== TYPE_MODE (short_integer_type_node
))
3470 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3472 if (mode
== TYPE_MODE (long_integer_type_node
))
3473 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3475 if (mode
== TYPE_MODE (long_long_integer_type_node
))
3476 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
3478 if (int128_integer_type_node
3479 && mode
== TYPE_MODE (int128_integer_type_node
))
3480 return unsignedp
? int128_unsigned_type_node
: int128_integer_type_node
;
3482 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
3483 return unsignedp
? widest_unsigned_literal_type_node
3484 : widest_integer_literal_type_node
;
3487 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3490 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3493 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3496 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3498 #if HOST_BITS_PER_WIDE_INT >= 64
3499 if (mode
== TYPE_MODE (intTI_type_node
))
3500 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3503 if (mode
== TYPE_MODE (float_type_node
))
3504 return float_type_node
;
3506 if (mode
== TYPE_MODE (double_type_node
))
3507 return double_type_node
;
3509 if (mode
== TYPE_MODE (long_double_type_node
))
3510 return long_double_type_node
;
3512 if (mode
== TYPE_MODE (void_type_node
))
3513 return void_type_node
;
3515 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
3517 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
3518 : make_signed_type (GET_MODE_PRECISION (mode
)));
3520 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
3522 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
3523 : make_signed_type (GET_MODE_PRECISION (mode
)));
3525 if (COMPLEX_MODE_P (mode
))
3527 enum machine_mode inner_mode
;
3530 if (mode
== TYPE_MODE (complex_float_type_node
))
3531 return complex_float_type_node
;
3532 if (mode
== TYPE_MODE (complex_double_type_node
))
3533 return complex_double_type_node
;
3534 if (mode
== TYPE_MODE (complex_long_double_type_node
))
3535 return complex_long_double_type_node
;
3537 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
3538 return complex_integer_type_node
;
3540 inner_mode
= GET_MODE_INNER (mode
);
3541 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
3542 if (inner_type
!= NULL_TREE
)
3543 return build_complex_type (inner_type
);
3545 else if (VECTOR_MODE_P (mode
))
3547 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
3548 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
3549 if (inner_type
!= NULL_TREE
)
3550 return build_vector_type_for_mode (inner_type
, mode
);
3553 if (mode
== TYPE_MODE (dfloat32_type_node
))
3554 return dfloat32_type_node
;
3555 if (mode
== TYPE_MODE (dfloat64_type_node
))
3556 return dfloat64_type_node
;
3557 if (mode
== TYPE_MODE (dfloat128_type_node
))
3558 return dfloat128_type_node
;
3560 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
3562 if (mode
== TYPE_MODE (short_fract_type_node
))
3563 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
3564 if (mode
== TYPE_MODE (fract_type_node
))
3565 return unsignedp
? sat_fract_type_node
: fract_type_node
;
3566 if (mode
== TYPE_MODE (long_fract_type_node
))
3567 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
3568 if (mode
== TYPE_MODE (long_long_fract_type_node
))
3569 return unsignedp
? sat_long_long_fract_type_node
3570 : long_long_fract_type_node
;
3572 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
3573 return unsignedp
? sat_unsigned_short_fract_type_node
3574 : unsigned_short_fract_type_node
;
3575 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
3576 return unsignedp
? sat_unsigned_fract_type_node
3577 : unsigned_fract_type_node
;
3578 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
3579 return unsignedp
? sat_unsigned_long_fract_type_node
3580 : unsigned_long_fract_type_node
;
3581 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
3582 return unsignedp
? sat_unsigned_long_long_fract_type_node
3583 : unsigned_long_long_fract_type_node
;
3585 if (mode
== TYPE_MODE (short_accum_type_node
))
3586 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
3587 if (mode
== TYPE_MODE (accum_type_node
))
3588 return unsignedp
? sat_accum_type_node
: accum_type_node
;
3589 if (mode
== TYPE_MODE (long_accum_type_node
))
3590 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
3591 if (mode
== TYPE_MODE (long_long_accum_type_node
))
3592 return unsignedp
? sat_long_long_accum_type_node
3593 : long_long_accum_type_node
;
3595 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
3596 return unsignedp
? sat_unsigned_short_accum_type_node
3597 : unsigned_short_accum_type_node
;
3598 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
3599 return unsignedp
? sat_unsigned_accum_type_node
3600 : unsigned_accum_type_node
;
3601 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
3602 return unsignedp
? sat_unsigned_long_accum_type_node
3603 : unsigned_long_accum_type_node
;
3604 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
3605 return unsignedp
? sat_unsigned_long_long_accum_type_node
3606 : unsigned_long_long_accum_type_node
;
3609 return unsignedp
? sat_qq_type_node
: qq_type_node
;
3611 return unsignedp
? sat_hq_type_node
: hq_type_node
;
3613 return unsignedp
? sat_sq_type_node
: sq_type_node
;
3615 return unsignedp
? sat_dq_type_node
: dq_type_node
;
3617 return unsignedp
? sat_tq_type_node
: tq_type_node
;
3619 if (mode
== UQQmode
)
3620 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
3621 if (mode
== UHQmode
)
3622 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
3623 if (mode
== USQmode
)
3624 return unsignedp
? sat_usq_type_node
: usq_type_node
;
3625 if (mode
== UDQmode
)
3626 return unsignedp
? sat_udq_type_node
: udq_type_node
;
3627 if (mode
== UTQmode
)
3628 return unsignedp
? sat_utq_type_node
: utq_type_node
;
3631 return unsignedp
? sat_ha_type_node
: ha_type_node
;
3633 return unsignedp
? sat_sa_type_node
: sa_type_node
;
3635 return unsignedp
? sat_da_type_node
: da_type_node
;
3637 return unsignedp
? sat_ta_type_node
: ta_type_node
;
3639 if (mode
== UHAmode
)
3640 return unsignedp
? sat_uha_type_node
: uha_type_node
;
3641 if (mode
== USAmode
)
3642 return unsignedp
? sat_usa_type_node
: usa_type_node
;
3643 if (mode
== UDAmode
)
3644 return unsignedp
? sat_uda_type_node
: uda_type_node
;
3645 if (mode
== UTAmode
)
3646 return unsignedp
? sat_uta_type_node
: uta_type_node
;
3649 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
3650 if (TYPE_MODE (TREE_VALUE (t
)) == mode
3651 && !!unsignedp
== !!TYPE_UNSIGNED (TREE_VALUE (t
)))
3652 return TREE_VALUE (t
);
3658 c_common_unsigned_type (tree type
)
3660 return c_common_signed_or_unsigned_type (1, type
);
3663 /* Return a signed type the same as TYPE in other respects. */
3666 c_common_signed_type (tree type
)
3668 return c_common_signed_or_unsigned_type (0, type
);
3671 /* Return a type the same as TYPE except unsigned or
3672 signed according to UNSIGNEDP. */
3675 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
3679 /* This block of code emulates the behavior of the old
3680 c_common_unsigned_type. In particular, it returns
3681 long_unsigned_type_node if passed a long, even when a int would
3682 have the same size. This is necessary for warnings to work
3683 correctly in archs where sizeof(int) == sizeof(long) */
3685 type1
= TYPE_MAIN_VARIANT (type
);
3686 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
3687 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3688 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
3689 return unsignedp
? unsigned_type_node
: integer_type_node
;
3690 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
3691 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3692 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
3693 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3694 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
3695 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
3696 if (int128_integer_type_node
3697 && (type1
== int128_integer_type_node
3698 || type1
== int128_unsigned_type_node
))
3699 return unsignedp
? int128_unsigned_type_node
: int128_integer_type_node
;
3700 if (type1
== widest_integer_literal_type_node
|| type1
== widest_unsigned_literal_type_node
)
3701 return unsignedp
? widest_unsigned_literal_type_node
: widest_integer_literal_type_node
;
3702 #if HOST_BITS_PER_WIDE_INT >= 64
3703 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
3704 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3706 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
3707 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3708 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
3709 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3710 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
3711 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3712 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
3713 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3715 #define C_COMMON_FIXED_TYPES(NAME) \
3716 if (type1 == short_ ## NAME ## _type_node \
3717 || type1 == unsigned_short_ ## NAME ## _type_node) \
3718 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3719 : short_ ## NAME ## _type_node; \
3720 if (type1 == NAME ## _type_node \
3721 || type1 == unsigned_ ## NAME ## _type_node) \
3722 return unsignedp ? unsigned_ ## NAME ## _type_node \
3723 : NAME ## _type_node; \
3724 if (type1 == long_ ## NAME ## _type_node \
3725 || type1 == unsigned_long_ ## NAME ## _type_node) \
3726 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3727 : long_ ## NAME ## _type_node; \
3728 if (type1 == long_long_ ## NAME ## _type_node \
3729 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3730 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3731 : long_long_ ## NAME ## _type_node;
3733 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3734 if (type1 == NAME ## _type_node \
3735 || type1 == u ## NAME ## _type_node) \
3736 return unsignedp ? u ## NAME ## _type_node \
3737 : NAME ## _type_node;
3739 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3740 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3741 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3742 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3743 : sat_ ## short_ ## NAME ## _type_node; \
3744 if (type1 == sat_ ## NAME ## _type_node \
3745 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3746 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3747 : sat_ ## NAME ## _type_node; \
3748 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3749 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3750 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3751 : sat_ ## long_ ## NAME ## _type_node; \
3752 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3753 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3754 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3755 : sat_ ## long_long_ ## NAME ## _type_node;
3757 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3758 if (type1 == sat_ ## NAME ## _type_node \
3759 || type1 == sat_ ## u ## NAME ## _type_node) \
3760 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3761 : sat_ ## NAME ## _type_node;
3763 C_COMMON_FIXED_TYPES (fract
);
3764 C_COMMON_FIXED_TYPES_SAT (fract
);
3765 C_COMMON_FIXED_TYPES (accum
);
3766 C_COMMON_FIXED_TYPES_SAT (accum
);
3768 C_COMMON_FIXED_MODE_TYPES (qq
);
3769 C_COMMON_FIXED_MODE_TYPES (hq
);
3770 C_COMMON_FIXED_MODE_TYPES (sq
);
3771 C_COMMON_FIXED_MODE_TYPES (dq
);
3772 C_COMMON_FIXED_MODE_TYPES (tq
);
3773 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
3774 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
3775 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
3776 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
3777 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
3778 C_COMMON_FIXED_MODE_TYPES (ha
);
3779 C_COMMON_FIXED_MODE_TYPES (sa
);
3780 C_COMMON_FIXED_MODE_TYPES (da
);
3781 C_COMMON_FIXED_MODE_TYPES (ta
);
3782 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
3783 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
3784 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
3785 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
3787 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3788 the precision; they have precision set to match their range, but
3789 may use a wider mode to match an ABI. If we change modes, we may
3790 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3791 the precision as well, so as to yield correct results for
3792 bit-field types. C++ does not have these separate bit-field
3793 types, and producing a signed or unsigned variant of an
3794 ENUMERAL_TYPE may cause other problems as well. */
3796 if (!INTEGRAL_TYPE_P (type
)
3797 || TYPE_UNSIGNED (type
) == unsignedp
)
3800 #define TYPE_OK(node) \
3801 (TYPE_MODE (type) == TYPE_MODE (node) \
3802 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3803 if (TYPE_OK (signed_char_type_node
))
3804 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3805 if (TYPE_OK (integer_type_node
))
3806 return unsignedp
? unsigned_type_node
: integer_type_node
;
3807 if (TYPE_OK (short_integer_type_node
))
3808 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3809 if (TYPE_OK (long_integer_type_node
))
3810 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3811 if (TYPE_OK (long_long_integer_type_node
))
3812 return (unsignedp
? long_long_unsigned_type_node
3813 : long_long_integer_type_node
);
3814 if (int128_integer_type_node
&& TYPE_OK (int128_integer_type_node
))
3815 return (unsignedp
? int128_unsigned_type_node
3816 : int128_integer_type_node
);
3817 if (TYPE_OK (widest_integer_literal_type_node
))
3818 return (unsignedp
? widest_unsigned_literal_type_node
3819 : widest_integer_literal_type_node
);
3821 #if HOST_BITS_PER_WIDE_INT >= 64
3822 if (TYPE_OK (intTI_type_node
))
3823 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3825 if (TYPE_OK (intDI_type_node
))
3826 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3827 if (TYPE_OK (intSI_type_node
))
3828 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3829 if (TYPE_OK (intHI_type_node
))
3830 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3831 if (TYPE_OK (intQI_type_node
))
3832 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3835 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
3838 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3841 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
3843 /* Extended integer types of the same width as a standard type have
3844 lesser rank, so those of the same width as int promote to int or
3845 unsigned int and are valid for printf formats expecting int or
3846 unsigned int. To avoid such special cases, avoid creating
3847 extended integer types for bit-fields if a standard integer type
3849 if (width
== TYPE_PRECISION (integer_type_node
))
3850 return unsignedp
? unsigned_type_node
: integer_type_node
;
3851 if (width
== TYPE_PRECISION (signed_char_type_node
))
3852 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3853 if (width
== TYPE_PRECISION (short_integer_type_node
))
3854 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3855 if (width
== TYPE_PRECISION (long_integer_type_node
))
3856 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3857 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
3858 return (unsignedp
? long_long_unsigned_type_node
3859 : long_long_integer_type_node
);
3860 if (int128_integer_type_node
3861 && width
== TYPE_PRECISION (int128_integer_type_node
))
3862 return (unsignedp
? int128_unsigned_type_node
3863 : int128_integer_type_node
);
3864 return build_nonstandard_integer_type (width
, unsignedp
);
3867 /* The C version of the register_builtin_type langhook. */
3870 c_register_builtin_type (tree type
, const char* name
)
3874 decl
= build_decl (UNKNOWN_LOCATION
,
3875 TYPE_DECL
, get_identifier (name
), type
);
3876 DECL_ARTIFICIAL (decl
) = 1;
3877 if (!TYPE_NAME (type
))
3878 TYPE_NAME (type
) = decl
;
3881 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
3884 /* Print an error message for invalid operands to arith operation
3885 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3886 LOCATION is the location of the message. */
3889 binary_op_error (location_t location
, enum tree_code code
,
3890 tree type0
, tree type1
)
3897 opname
= "+"; break;
3899 opname
= "-"; break;
3901 opname
= "*"; break;
3903 opname
= "max"; break;
3905 opname
= "min"; break;
3907 opname
= "=="; break;
3909 opname
= "!="; break;
3911 opname
= "<="; break;
3913 opname
= ">="; break;
3915 opname
= "<"; break;
3917 opname
= ">"; break;
3919 opname
= "<<"; break;
3921 opname
= ">>"; break;
3922 case TRUNC_MOD_EXPR
:
3923 case FLOOR_MOD_EXPR
:
3924 opname
= "%"; break;
3925 case TRUNC_DIV_EXPR
:
3926 case FLOOR_DIV_EXPR
:
3927 opname
= "/"; break;
3929 opname
= "&"; break;
3931 opname
= "|"; break;
3932 case TRUTH_ANDIF_EXPR
:
3933 opname
= "&&"; break;
3934 case TRUTH_ORIF_EXPR
:
3935 opname
= "||"; break;
3937 opname
= "^"; break;
3942 "invalid operands to binary %s (have %qT and %qT)", opname
,
3946 /* Given an expression as a tree, return its original type. Do this
3947 by stripping any conversion that preserves the sign and precision. */
3949 expr_original_type (tree expr
)
3951 STRIP_SIGN_NOPS (expr
);
3952 return TREE_TYPE (expr
);
3955 /* Subroutine of build_binary_op, used for comparison operations.
3956 See if the operands have both been converted from subword integer types
3957 and, if so, perhaps change them both back to their original type.
3958 This function is also responsible for converting the two operands
3959 to the proper common type for comparison.
3961 The arguments of this function are all pointers to local variables
3962 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3963 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3965 If this function returns nonzero, it means that the comparison has
3966 a constant value. What this function returns is an expression for
3970 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
3971 enum tree_code
*rescode_ptr
)
3974 tree op0
= *op0_ptr
;
3975 tree op1
= *op1_ptr
;
3976 int unsignedp0
, unsignedp1
;
3978 tree primop0
, primop1
;
3979 enum tree_code code
= *rescode_ptr
;
3980 location_t loc
= EXPR_LOC_OR_HERE (op0
);
3982 /* Throw away any conversions to wider types
3983 already present in the operands. */
3985 primop0
= c_common_get_narrower (op0
, &unsignedp0
);
3986 primop1
= c_common_get_narrower (op1
, &unsignedp1
);
3988 /* If primopN is first sign-extended from primopN's precision to opN's
3989 precision, then zero-extended from opN's precision to
3990 *restype_ptr precision, shortenings might be invalid. */
3991 if (TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (TREE_TYPE (op0
))
3992 && TYPE_PRECISION (TREE_TYPE (op0
)) < TYPE_PRECISION (*restype_ptr
)
3994 && TYPE_UNSIGNED (TREE_TYPE (op0
)))
3996 if (TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (TREE_TYPE (op1
))
3997 && TYPE_PRECISION (TREE_TYPE (op1
)) < TYPE_PRECISION (*restype_ptr
)
3999 && TYPE_UNSIGNED (TREE_TYPE (op1
)))
4002 /* Handle the case that OP0 does not *contain* a conversion
4003 but it *requires* conversion to FINAL_TYPE. */
4005 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
4006 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
4007 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
4008 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
4010 /* If one of the operands must be floated, we cannot optimize. */
4011 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
4012 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
4014 /* If first arg is constant, swap the args (changing operation
4015 so value is preserved), for canonicalization. Don't do this if
4016 the second arg is 0. */
4018 if (TREE_CONSTANT (primop0
)
4019 && !integer_zerop (primop1
) && !real_zerop (primop1
)
4020 && !fixed_zerop (primop1
))
4023 int temi
= unsignedp0
;
4031 unsignedp0
= unsignedp1
;
4054 *rescode_ptr
= code
;
4057 /* If comparing an integer against a constant more bits wide,
4058 maybe we can deduce a value of 1 or 0 independent of the data.
4059 Or else truncate the constant now
4060 rather than extend the variable at run time.
4062 This is only interesting if the constant is the wider arg.
4063 Also, it is not safe if the constant is unsigned and the
4064 variable arg is signed, since in this case the variable
4065 would be sign-extended and then regarded as unsigned.
4066 Our technique fails in this case because the lowest/highest
4067 possible unsigned results don't follow naturally from the
4068 lowest/highest possible values of the variable operand.
4069 For just EQ_EXPR and NE_EXPR there is another technique that
4070 could be used: see if the constant can be faithfully represented
4071 in the other operand's type, by truncating it and reextending it
4072 and see if that preserves the constant's value. */
4074 if (!real1
&& !real2
4075 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
4076 && TREE_CODE (primop1
) == INTEGER_CST
4077 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
4079 int min_gt
, max_gt
, min_lt
, max_lt
;
4080 tree maxval
, minval
;
4081 /* 1 if comparison is nominally unsigned. */
4082 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
4085 type
= c_common_signed_or_unsigned_type (unsignedp0
,
4086 TREE_TYPE (primop0
));
4088 maxval
= TYPE_MAX_VALUE (type
);
4089 minval
= TYPE_MIN_VALUE (type
);
4091 if (unsignedp
&& !unsignedp0
)
4092 *restype_ptr
= c_common_signed_type (*restype_ptr
);
4094 if (TREE_TYPE (primop1
) != *restype_ptr
)
4096 /* Convert primop1 to target type, but do not introduce
4097 additional overflow. We know primop1 is an int_cst. */
4098 primop1
= force_fit_type_double (*restype_ptr
,
4099 tree_to_double_int (primop1
),
4100 0, TREE_OVERFLOW (primop1
));
4102 if (type
!= *restype_ptr
)
4104 minval
= convert (*restype_ptr
, minval
);
4105 maxval
= convert (*restype_ptr
, maxval
);
4108 if (unsignedp
&& unsignedp0
)
4110 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
4111 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
4112 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
4113 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
4117 min_gt
= INT_CST_LT (primop1
, minval
);
4118 max_gt
= INT_CST_LT (primop1
, maxval
);
4119 min_lt
= INT_CST_LT (minval
, primop1
);
4120 max_lt
= INT_CST_LT (maxval
, primop1
);
4124 /* This used to be a switch, but Genix compiler can't handle that. */
4125 if (code
== NE_EXPR
)
4127 if (max_lt
|| min_gt
)
4128 val
= truthvalue_true_node
;
4130 else if (code
== EQ_EXPR
)
4132 if (max_lt
|| min_gt
)
4133 val
= truthvalue_false_node
;
4135 else if (code
== LT_EXPR
)
4138 val
= truthvalue_true_node
;
4140 val
= truthvalue_false_node
;
4142 else if (code
== GT_EXPR
)
4145 val
= truthvalue_true_node
;
4147 val
= truthvalue_false_node
;
4149 else if (code
== LE_EXPR
)
4152 val
= truthvalue_true_node
;
4154 val
= truthvalue_false_node
;
4156 else if (code
== GE_EXPR
)
4159 val
= truthvalue_true_node
;
4161 val
= truthvalue_false_node
;
4164 /* If primop0 was sign-extended and unsigned comparison specd,
4165 we did a signed comparison above using the signed type bounds.
4166 But the comparison we output must be unsigned.
4168 Also, for inequalities, VAL is no good; but if the signed
4169 comparison had *any* fixed result, it follows that the
4170 unsigned comparison just tests the sign in reverse
4171 (positive values are LE, negative ones GE).
4172 So we can generate an unsigned comparison
4173 against an extreme value of the signed type. */
4175 if (unsignedp
&& !unsignedp0
)
4182 primop1
= TYPE_MIN_VALUE (type
);
4188 primop1
= TYPE_MAX_VALUE (type
);
4195 type
= c_common_unsigned_type (type
);
4198 if (TREE_CODE (primop0
) != INTEGER_CST
4199 && c_inhibit_evaluation_warnings
== 0)
4201 if (val
== truthvalue_false_node
)
4202 warning_at (loc
, OPT_Wtype_limits
,
4203 "comparison is always false due to limited range of data type");
4204 if (val
== truthvalue_true_node
)
4205 warning_at (loc
, OPT_Wtype_limits
,
4206 "comparison is always true due to limited range of data type");
4211 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4212 if (TREE_SIDE_EFFECTS (primop0
))
4213 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
4217 /* Value is not predetermined, but do the comparison
4218 in the type of the operand that is not constant.
4219 TYPE is already properly set. */
4222 /* If either arg is decimal float and the other is float, find the
4223 proper common type to use for comparison. */
4224 else if (real1
&& real2
4225 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
4226 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
4227 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
4229 else if (real1
&& real2
4230 && (TYPE_PRECISION (TREE_TYPE (primop0
))
4231 == TYPE_PRECISION (TREE_TYPE (primop1
))))
4232 type
= TREE_TYPE (primop0
);
4234 /* If args' natural types are both narrower than nominal type
4235 and both extend in the same manner, compare them
4236 in the type of the wider arg.
4237 Otherwise must actually extend both to the nominal
4238 common type lest different ways of extending
4240 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
4242 else if (unsignedp0
== unsignedp1
&& real1
== real2
4243 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
4244 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
4246 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
4247 type
= c_common_signed_or_unsigned_type (unsignedp0
4248 || TYPE_UNSIGNED (*restype_ptr
),
4250 /* Make sure shorter operand is extended the right way
4251 to match the longer operand. */
4253 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
4254 TREE_TYPE (primop0
)),
4257 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
4258 TREE_TYPE (primop1
)),
4263 /* Here we must do the comparison on the nominal type
4264 using the args exactly as we received them. */
4265 type
= *restype_ptr
;
4269 if (!real1
&& !real2
&& integer_zerop (primop1
)
4270 && TYPE_UNSIGNED (*restype_ptr
))
4273 /* All unsigned values are >= 0, so we warn. However,
4274 if OP0 is a constant that is >= 0, the signedness of
4275 the comparison isn't an issue, so suppress the
4278 warn_type_limits
&& !in_system_header
4279 && c_inhibit_evaluation_warnings
== 0
4280 && !(TREE_CODE (primop0
) == INTEGER_CST
4281 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
4283 /* Do not warn for enumeration types. */
4284 && (TREE_CODE (expr_original_type (primop0
)) != ENUMERAL_TYPE
);
4290 warning_at (loc
, OPT_Wtype_limits
,
4291 "comparison of unsigned expression >= 0 is always true");
4292 value
= truthvalue_true_node
;
4297 warning_at (loc
, OPT_Wtype_limits
,
4298 "comparison of unsigned expression < 0 is always false");
4299 value
= truthvalue_false_node
;
4308 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4309 if (TREE_SIDE_EFFECTS (primop0
))
4310 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
4317 *op0_ptr
= convert (type
, primop0
);
4318 *op1_ptr
= convert (type
, primop1
);
4320 *restype_ptr
= truthvalue_type_node
;
4325 /* Return a tree for the sum or difference (RESULTCODE says which)
4326 of pointer PTROP and integer INTOP. */
4329 pointer_int_sum (location_t loc
, enum tree_code resultcode
,
4330 tree ptrop
, tree intop
, bool complain
)
4334 /* The result is a pointer of the same type that is being added. */
4335 tree result_type
= TREE_TYPE (ptrop
);
4337 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
4339 if (complain
&& warn_pointer_arith
)
4340 pedwarn (loc
, OPT_Wpointer_arith
,
4341 "pointer of type %<void *%> used in arithmetic");
4343 return error_mark_node
;
4344 size_exp
= integer_one_node
;
4346 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
4348 if (complain
&& warn_pointer_arith
)
4349 pedwarn (loc
, OPT_Wpointer_arith
,
4350 "pointer to a function used in arithmetic");
4352 return error_mark_node
;
4353 size_exp
= integer_one_node
;
4356 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
4358 /* We are manipulating pointer values, so we don't need to warn
4359 about relying on undefined signed overflow. We disable the
4360 warning here because we use integer types so fold won't know that
4361 they are really pointers. */
4362 fold_defer_overflow_warnings ();
4364 /* If what we are about to multiply by the size of the elements
4365 contains a constant term, apply distributive law
4366 and multiply that constant term separately.
4367 This helps produce common subexpressions. */
4368 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
4369 && !TREE_CONSTANT (intop
)
4370 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
4371 && TREE_CONSTANT (size_exp
)
4372 /* If the constant comes from pointer subtraction,
4373 skip this optimization--it would cause an error. */
4374 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
4375 /* If the constant is unsigned, and smaller than the pointer size,
4376 then we must skip this optimization. This is because it could cause
4377 an overflow error if the constant is negative but INTOP is not. */
4378 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
4379 || (TYPE_PRECISION (TREE_TYPE (intop
))
4380 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
4382 enum tree_code subcode
= resultcode
;
4383 tree int_type
= TREE_TYPE (intop
);
4384 if (TREE_CODE (intop
) == MINUS_EXPR
)
4385 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
4386 /* Convert both subexpression types to the type of intop,
4387 because weird cases involving pointer arithmetic
4388 can result in a sum or difference with different type args. */
4389 ptrop
= build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop
, 1)),
4391 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
4392 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
4395 /* Convert the integer argument to a type the same size as sizetype
4396 so the multiply won't overflow spuriously. */
4397 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
4398 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
4399 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
4400 TYPE_UNSIGNED (sizetype
)), intop
);
4402 /* Replace the integer argument with a suitable product by the object size.
4403 Do this multiplication as signed, then convert to the appropriate type
4404 for the pointer operation and disregard an overflow that occurred only
4405 because of the sign-extension change in the latter conversion. */
4407 tree t
= build_binary_op (loc
,
4409 convert (TREE_TYPE (intop
), size_exp
), 1);
4410 intop
= convert (sizetype
, t
);
4411 if (TREE_OVERFLOW_P (intop
) && !TREE_OVERFLOW (t
))
4412 intop
= build_int_cst_wide (TREE_TYPE (intop
), TREE_INT_CST_LOW (intop
),
4413 TREE_INT_CST_HIGH (intop
));
4416 /* Create the sum or difference. */
4417 if (resultcode
== MINUS_EXPR
)
4418 intop
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, intop
);
4420 ret
= fold_build_pointer_plus_loc (loc
, ptrop
, intop
);
4422 fold_undefer_and_ignore_overflow_warnings ();
4427 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
4428 and if NON_CONST is known not to be permitted in an evaluated part
4429 of a constant expression. */
4432 c_wrap_maybe_const (tree expr
, bool non_const
)
4434 bool nowarning
= TREE_NO_WARNING (expr
);
4435 location_t loc
= EXPR_LOCATION (expr
);
4437 /* This should never be called for C++. */
4438 if (c_dialect_cxx ())
4441 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
4442 STRIP_TYPE_NOPS (expr
);
4443 expr
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL
, expr
);
4444 C_MAYBE_CONST_EXPR_NON_CONST (expr
) = non_const
;
4446 TREE_NO_WARNING (expr
) = 1;
4447 protected_set_expr_location (expr
, loc
);
4452 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
4453 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
4454 around the SAVE_EXPR if needed so that c_fully_fold does not need
4455 to look inside SAVE_EXPRs. */
4458 c_save_expr (tree expr
)
4460 bool maybe_const
= true;
4461 if (c_dialect_cxx ())
4462 return save_expr (expr
);
4463 expr
= c_fully_fold (expr
, false, &maybe_const
);
4464 expr
= save_expr (expr
);
4466 expr
= c_wrap_maybe_const (expr
, true);
4470 /* Return whether EXPR is a declaration whose address can never be
4474 decl_with_nonnull_addr_p (const_tree expr
)
4476 return (DECL_P (expr
)
4477 && (TREE_CODE (expr
) == PARM_DECL
4478 || TREE_CODE (expr
) == LABEL_DECL
4479 || !DECL_WEAK (expr
)));
4482 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
4483 or for an `if' or `while' statement or ?..: exp. It should already
4484 have been validated to be of suitable type; otherwise, a bad
4485 diagnostic may result.
4487 The EXPR is located at LOCATION.
4489 This preparation consists of taking the ordinary
4490 representation of an expression expr and producing a valid tree
4491 boolean expression describing whether expr is nonzero. We could
4492 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
4493 but we optimize comparisons, &&, ||, and !.
4495 The resulting type should always be `truthvalue_type_node'. */
4498 c_common_truthvalue_conversion (location_t location
, tree expr
)
4500 switch (TREE_CODE (expr
))
4502 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
4503 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
4504 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
4505 case ORDERED_EXPR
: case UNORDERED_EXPR
:
4506 if (TREE_TYPE (expr
) == truthvalue_type_node
)
4508 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
4509 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
4512 case TRUTH_ANDIF_EXPR
:
4513 case TRUTH_ORIF_EXPR
:
4514 case TRUTH_AND_EXPR
:
4516 case TRUTH_XOR_EXPR
:
4517 if (TREE_TYPE (expr
) == truthvalue_type_node
)
4519 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
4520 c_common_truthvalue_conversion (location
,
4521 TREE_OPERAND (expr
, 0)),
4522 c_common_truthvalue_conversion (location
,
4523 TREE_OPERAND (expr
, 1)));
4526 case TRUTH_NOT_EXPR
:
4527 if (TREE_TYPE (expr
) == truthvalue_type_node
)
4529 expr
= build1 (TREE_CODE (expr
), truthvalue_type_node
,
4530 c_common_truthvalue_conversion (location
,
4531 TREE_OPERAND (expr
, 0)));
4538 return integer_zerop (expr
) ? truthvalue_false_node
4539 : truthvalue_true_node
;
4542 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
4543 ? truthvalue_true_node
4544 : truthvalue_false_node
;
4547 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
4548 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
4549 ? truthvalue_true_node
4550 : truthvalue_false_node
;
4553 expr
= build_unary_op (location
, ADDR_EXPR
, expr
, 0);
4558 tree inner
= TREE_OPERAND (expr
, 0);
4559 if (decl_with_nonnull_addr_p (inner
))
4561 /* Common Ada/Pascal programmer's mistake. */
4562 warning_at (location
,
4564 "the address of %qD will always evaluate as %<true%>",
4566 return truthvalue_true_node
;
4572 expr
= build_binary_op (EXPR_LOCATION (expr
),
4573 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
4574 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
4575 c_common_truthvalue_conversion (location
,
4576 TREE_OPERAND (expr
, 0)),
4577 c_common_truthvalue_conversion (location
,
4578 TREE_OPERAND (expr
, 1)),
4585 case EXCESS_PRECISION_EXPR
:
4586 /* These don't change whether an object is nonzero or zero. */
4587 return c_common_truthvalue_conversion (location
, TREE_OPERAND (expr
, 0));
4591 /* These don't change whether an object is zero or nonzero, but
4592 we can't ignore them if their second arg has side-effects. */
4593 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
4595 expr
= build2 (COMPOUND_EXPR
, truthvalue_type_node
,
4596 TREE_OPERAND (expr
, 1),
4597 c_common_truthvalue_conversion
4598 (location
, TREE_OPERAND (expr
, 0)));
4602 return c_common_truthvalue_conversion (location
,
4603 TREE_OPERAND (expr
, 0));
4606 /* Distribute the conversion into the arms of a COND_EXPR. */
4607 if (c_dialect_cxx ())
4609 tree op1
= TREE_OPERAND (expr
, 1);
4610 tree op2
= TREE_OPERAND (expr
, 2);
4611 /* In C++ one of the arms might have void type if it is throw. */
4612 if (!VOID_TYPE_P (TREE_TYPE (op1
)))
4613 op1
= c_common_truthvalue_conversion (location
, op1
);
4614 if (!VOID_TYPE_P (TREE_TYPE (op2
)))
4615 op2
= c_common_truthvalue_conversion (location
, op2
);
4616 expr
= fold_build3_loc (location
, COND_EXPR
, truthvalue_type_node
,
4617 TREE_OPERAND (expr
, 0), op1
, op2
);
4622 /* Folding will happen later for C. */
4623 expr
= build3 (COND_EXPR
, truthvalue_type_node
,
4624 TREE_OPERAND (expr
, 0),
4625 c_common_truthvalue_conversion (location
,
4626 TREE_OPERAND (expr
, 1)),
4627 c_common_truthvalue_conversion (location
,
4628 TREE_OPERAND (expr
, 2)));
4634 tree totype
= TREE_TYPE (expr
);
4635 tree fromtype
= TREE_TYPE (TREE_OPERAND (expr
, 0));
4637 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4638 since that affects how `default_conversion' will behave. */
4639 if (TREE_CODE (totype
) == REFERENCE_TYPE
4640 || TREE_CODE (fromtype
) == REFERENCE_TYPE
)
4642 /* Don't strip a conversion from C++0x scoped enum, since they
4643 don't implicitly convert to other types. */
4644 if (TREE_CODE (fromtype
) == ENUMERAL_TYPE
4645 && ENUM_IS_SCOPED (fromtype
))
4647 /* If this isn't narrowing the argument, we can ignore it. */
4648 if (TYPE_PRECISION (totype
) >= TYPE_PRECISION (fromtype
))
4649 return c_common_truthvalue_conversion (location
,
4650 TREE_OPERAND (expr
, 0));
4655 if (!TREE_NO_WARNING (expr
)
4656 && warn_parentheses
)
4658 warning (OPT_Wparentheses
,
4659 "suggest parentheses around assignment used as truth value");
4660 TREE_NO_WARNING (expr
) = 1;
4668 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
4670 tree t
= (in_late_binary_op
? save_expr (expr
) : c_save_expr (expr
));
4671 expr
= (build_binary_op
4672 (EXPR_LOCATION (expr
),
4673 (TREE_SIDE_EFFECTS (expr
)
4674 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
4675 c_common_truthvalue_conversion
4677 build_unary_op (location
, REALPART_EXPR
, t
, 0)),
4678 c_common_truthvalue_conversion
4680 build_unary_op (location
, IMAGPART_EXPR
, t
, 0)),
4685 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
4687 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
4689 (TREE_TYPE (expr
))));
4690 return build_binary_op (location
, NE_EXPR
, expr
, fixed_zero_node
, 1);
4693 return build_binary_op (location
, NE_EXPR
, expr
, integer_zero_node
, 1);
4696 protected_set_expr_location (expr
, location
);
4700 static void def_builtin_1 (enum built_in_function fncode
,
4702 enum built_in_class fnclass
,
4703 tree fntype
, tree libtype
,
4704 bool both_p
, bool fallback_p
, bool nonansi_p
,
4705 tree fnattrs
, bool implicit_p
);
4708 /* Apply the TYPE_QUALS to the new DECL. */
4711 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
4713 tree type
= TREE_TYPE (decl
);
4715 if (type
== error_mark_node
)
4718 if ((type_quals
& TYPE_QUAL_CONST
)
4719 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
4720 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
4721 constructor can produce constant init, so rely on cp_finish_decl to
4722 clear TREE_READONLY if the variable has non-constant init. */
4723 TREE_READONLY (decl
) = 1;
4724 if (type_quals
& TYPE_QUAL_VOLATILE
)
4726 TREE_SIDE_EFFECTS (decl
) = 1;
4727 TREE_THIS_VOLATILE (decl
) = 1;
4729 if (type_quals
& TYPE_QUAL_RESTRICT
)
4731 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
4732 /* Allow 'restrict' on arrays of pointers.
4733 FIXME currently we just ignore it. */
4734 type
= TREE_TYPE (type
);
4736 || !POINTER_TYPE_P (type
)
4737 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
4738 error ("invalid use of %<restrict%>");
4742 /* Hash function for the problem of multiple type definitions in
4743 different files. This must hash all types that will compare
4744 equal via comptypes to the same value. In practice it hashes
4745 on some of the simple stuff and leaves the details to comptypes. */
4748 c_type_hash (const void *p
)
4752 const_tree
const t
= (const_tree
) p
;
4754 switch (TREE_CODE (t
))
4756 /* For pointers, hash on pointee type plus some swizzling. */
4758 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
4759 /* Hash on number of elements and total size. */
4762 t2
= TYPE_VALUES (t
);
4766 t2
= TYPE_FIELDS (t
);
4768 case QUAL_UNION_TYPE
:
4770 t2
= TYPE_FIELDS (t
);
4774 t2
= TYPE_FIELDS (t
);
4779 /* FIXME: We want to use a DECL_CHAIN iteration method here, but
4780 TYPE_VALUES of ENUMERAL_TYPEs is stored as a TREE_LIST. */
4781 n_elements
= list_length (t2
);
4782 /* We might have a VLA here. */
4783 if (TREE_CODE (TYPE_SIZE (t
)) != INTEGER_CST
)
4786 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
4787 return ((size
<< 24) | (n_elements
<< shift
));
4790 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
4792 /* Return the typed-based alias set for T, which may be an expression
4793 or a type. Return -1 if we don't do anything special. */
4796 c_common_get_alias_set (tree t
)
4801 /* For VLAs, use the alias set of the element type rather than the
4802 default of alias set 0 for types compared structurally. */
4803 if (TYPE_P (t
) && TYPE_STRUCTURAL_EQUALITY_P (t
))
4805 if (TREE_CODE (t
) == ARRAY_TYPE
)
4806 return get_alias_set (TREE_TYPE (t
));
4810 /* Permit type-punning when accessing a union, provided the access
4811 is directly through the union. For example, this code does not
4812 permit taking the address of a union member and then storing
4813 through it. Even the type-punning allowed here is a GCC
4814 extension, albeit a common and useful one; the C standard says
4815 that such accesses have implementation-defined behavior. */
4817 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
4818 u
= TREE_OPERAND (u
, 0))
4819 if (TREE_CODE (u
) == COMPONENT_REF
4820 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
4823 /* That's all the expressions we handle specially. */
4827 /* The C standard guarantees that any object may be accessed via an
4828 lvalue that has character type. */
4829 if (t
== char_type_node
4830 || t
== signed_char_type_node
4831 || t
== unsigned_char_type_node
)
4834 /* The C standard specifically allows aliasing between signed and
4835 unsigned variants of the same type. We treat the signed
4836 variant as canonical. */
4837 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
4839 tree t1
= c_common_signed_type (t
);
4841 /* t1 == t can happen for boolean nodes which are always unsigned. */
4843 return get_alias_set (t1
);
4846 /* Handle the case of multiple type nodes referring to "the same" type,
4847 which occurs with IMA. These share an alias set. FIXME: Currently only
4848 C90 is handled. (In C99 type compatibility is not transitive, which
4849 complicates things mightily. The alias set splay trees can theoretically
4850 represent this, but insertion is tricky when you consider all the
4851 different orders things might arrive in.) */
4853 if (c_language
!= clk_c
|| flag_isoc99
)
4856 /* Save time if there's only one input file. */
4857 if (num_in_fnames
== 1)
4860 /* Pointers need special handling if they point to any type that
4861 needs special handling (below). */
4862 if (TREE_CODE (t
) == POINTER_TYPE
)
4865 /* Find bottom type under any nested POINTERs. */
4866 for (t2
= TREE_TYPE (t
);
4867 TREE_CODE (t2
) == POINTER_TYPE
;
4868 t2
= TREE_TYPE (t2
))
4870 if (TREE_CODE (t2
) != RECORD_TYPE
4871 && TREE_CODE (t2
) != ENUMERAL_TYPE
4872 && TREE_CODE (t2
) != QUAL_UNION_TYPE
4873 && TREE_CODE (t2
) != UNION_TYPE
)
4875 if (TYPE_SIZE (t2
) == 0)
4878 /* These are the only cases that need special handling. */
4879 if (TREE_CODE (t
) != RECORD_TYPE
4880 && TREE_CODE (t
) != ENUMERAL_TYPE
4881 && TREE_CODE (t
) != QUAL_UNION_TYPE
4882 && TREE_CODE (t
) != UNION_TYPE
4883 && TREE_CODE (t
) != POINTER_TYPE
)
4886 if (TYPE_SIZE (t
) == 0)
4889 /* Look up t in hash table. Only one of the compatible types within each
4890 alias set is recorded in the table. */
4891 if (!type_hash_table
)
4892 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
4893 (htab_eq
) lang_hooks
.types_compatible_p
,
4895 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
4898 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
4899 return TYPE_ALIAS_SET ((tree
)*slot
);
4902 /* Our caller will assign and record (in t) a new alias set; all we need
4903 to do is remember t in the hash table. */
4909 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4910 the second parameter indicates which OPERATOR is being applied.
4911 The COMPLAIN flag controls whether we should diagnose possibly
4912 ill-formed constructs or not. LOC is the location of the SIZEOF or
4916 c_sizeof_or_alignof_type (location_t loc
,
4917 tree type
, bool is_sizeof
, int complain
)
4919 const char *op_name
;
4921 enum tree_code type_code
= TREE_CODE (type
);
4923 op_name
= is_sizeof
? "sizeof" : "__alignof__";
4925 if (type_code
== FUNCTION_TYPE
)
4929 if (complain
&& warn_pointer_arith
)
4930 pedwarn (loc
, OPT_Wpointer_arith
,
4931 "invalid application of %<sizeof%> to a function type");
4933 return error_mark_node
;
4934 value
= size_one_node
;
4940 if (c_dialect_cxx ())
4941 pedwarn (loc
, OPT_Wpedantic
, "ISO C++ does not permit "
4942 "%<alignof%> applied to a function type");
4944 pedwarn (loc
, OPT_Wpedantic
, "ISO C does not permit "
4945 "%<_Alignof%> applied to a function type");
4947 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
4950 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
4952 if (type_code
== VOID_TYPE
4953 && complain
&& warn_pointer_arith
)
4954 pedwarn (loc
, OPT_Wpointer_arith
,
4955 "invalid application of %qs to a void type", op_name
);
4957 return error_mark_node
;
4958 value
= size_one_node
;
4960 else if (!COMPLETE_TYPE_P (type
)
4961 && (!c_dialect_cxx () || is_sizeof
|| type_code
!= ARRAY_TYPE
))
4964 error_at (loc
, "invalid application of %qs to incomplete type %qT",
4966 return error_mark_node
;
4968 else if (c_dialect_cxx () && type_code
== ARRAY_TYPE
4969 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
4972 error_at (loc
, "invalid application of %qs to array type %qT of "
4973 "incomplete element type", op_name
, type
);
4974 return error_mark_node
;
4979 /* Convert in case a char is more than one unit. */
4980 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
4981 size_int (TYPE_PRECISION (char_type_node
)
4984 value
= size_int (TYPE_ALIGN_UNIT (type
));
4987 /* VALUE will have the middle-end integer type sizetype.
4988 However, we should really return a value of type `size_t',
4989 which is just a typedef for an ordinary integer type. */
4990 value
= fold_convert_loc (loc
, size_type_node
, value
);
4995 /* Implement the __alignof keyword: Return the minimum required
4996 alignment of EXPR, measured in bytes. For VAR_DECLs,
4997 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4998 from an "aligned" __attribute__ specification). LOC is the
4999 location of the ALIGNOF operator. */
5002 c_alignof_expr (location_t loc
, tree expr
)
5006 if (VAR_OR_FUNCTION_DECL_P (expr
))
5007 t
= size_int (DECL_ALIGN_UNIT (expr
));
5009 else if (TREE_CODE (expr
) == COMPONENT_REF
5010 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
5012 error_at (loc
, "%<__alignof%> applied to a bit-field");
5015 else if (TREE_CODE (expr
) == COMPONENT_REF
5016 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
5017 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
5019 else if (TREE_CODE (expr
) == INDIRECT_REF
)
5021 tree t
= TREE_OPERAND (expr
, 0);
5023 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
5025 while (CONVERT_EXPR_P (t
)
5026 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
5030 t
= TREE_OPERAND (t
, 0);
5031 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
5032 if (thisalign
> bestalign
)
5033 best
= t
, bestalign
= thisalign
;
5035 return c_alignof (loc
, TREE_TYPE (TREE_TYPE (best
)));
5038 return c_alignof (loc
, TREE_TYPE (expr
));
5040 return fold_convert_loc (loc
, size_type_node
, t
);
5043 /* Handle C and C++ default attributes. */
5045 enum built_in_attribute
5047 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
5048 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
5049 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
5050 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
5051 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
5052 #include "builtin-attrs.def"
5053 #undef DEF_ATTR_NULL_TREE
5055 #undef DEF_ATTR_STRING
5056 #undef DEF_ATTR_IDENT
5057 #undef DEF_ATTR_TREE_LIST
5061 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
5063 static void c_init_attributes (void);
5067 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
5068 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
5069 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
5070 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
5071 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5072 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5073 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
5074 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
5075 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
5076 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7, ARG8) NAME,
5077 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
5078 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
5079 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
5080 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5081 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5082 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
5084 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
5085 #include "builtin-types.def"
5086 #undef DEF_PRIMITIVE_TYPE
5087 #undef DEF_FUNCTION_TYPE_0
5088 #undef DEF_FUNCTION_TYPE_1
5089 #undef DEF_FUNCTION_TYPE_2
5090 #undef DEF_FUNCTION_TYPE_3
5091 #undef DEF_FUNCTION_TYPE_4
5092 #undef DEF_FUNCTION_TYPE_5
5093 #undef DEF_FUNCTION_TYPE_6
5094 #undef DEF_FUNCTION_TYPE_7
5095 #undef DEF_FUNCTION_TYPE_8
5096 #undef DEF_FUNCTION_TYPE_VAR_0
5097 #undef DEF_FUNCTION_TYPE_VAR_1
5098 #undef DEF_FUNCTION_TYPE_VAR_2
5099 #undef DEF_FUNCTION_TYPE_VAR_3
5100 #undef DEF_FUNCTION_TYPE_VAR_4
5101 #undef DEF_FUNCTION_TYPE_VAR_5
5102 #undef DEF_POINTER_TYPE
5106 typedef enum c_builtin_type builtin_type
;
5108 /* A temporary array for c_common_nodes_and_builtins. Used in
5109 communication with def_fn_type. */
5110 static tree builtin_types
[(int) BT_LAST
+ 1];
5112 /* A helper function for c_common_nodes_and_builtins. Build function type
5113 for DEF with return type RET and N arguments. If VAR is true, then the
5114 function should be variadic after those N arguments.
5116 Takes special care not to ICE if any of the types involved are
5117 error_mark_node, which indicates that said type is not in fact available
5118 (see builtin_type_for_size). In which case the function type as a whole
5119 should be error_mark_node. */
5122 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
5125 tree
*args
= XALLOCAVEC (tree
, n
);
5130 for (i
= 0; i
< n
; ++i
)
5132 builtin_type a
= (builtin_type
) va_arg (list
, int);
5133 t
= builtin_types
[a
];
5134 if (t
== error_mark_node
)
5139 t
= builtin_types
[ret
];
5140 if (t
== error_mark_node
)
5143 t
= build_varargs_function_type_array (t
, n
, args
);
5145 t
= build_function_type_array (t
, n
, args
);
5148 builtin_types
[def
] = t
;
5152 /* Build builtin functions common to both C and C++ language
5156 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
5158 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
5159 builtin_types[ENUM] = VALUE;
5160 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
5161 def_fn_type (ENUM, RETURN, 0, 0);
5162 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
5163 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
5164 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
5165 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
5166 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5167 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
5168 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5169 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
5170 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5171 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5172 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5174 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
5175 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5177 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5178 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5180 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5182 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
5183 def_fn_type (ENUM, RETURN, 1, 0);
5184 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
5185 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
5186 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
5187 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
5188 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5189 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
5190 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5191 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
5192 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5193 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5194 #define DEF_POINTER_TYPE(ENUM, TYPE) \
5195 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
5197 #include "builtin-types.def"
5199 #undef DEF_PRIMITIVE_TYPE
5200 #undef DEF_FUNCTION_TYPE_1
5201 #undef DEF_FUNCTION_TYPE_2
5202 #undef DEF_FUNCTION_TYPE_3
5203 #undef DEF_FUNCTION_TYPE_4
5204 #undef DEF_FUNCTION_TYPE_5
5205 #undef DEF_FUNCTION_TYPE_6
5206 #undef DEF_FUNCTION_TYPE_VAR_0
5207 #undef DEF_FUNCTION_TYPE_VAR_1
5208 #undef DEF_FUNCTION_TYPE_VAR_2
5209 #undef DEF_FUNCTION_TYPE_VAR_3
5210 #undef DEF_FUNCTION_TYPE_VAR_4
5211 #undef DEF_FUNCTION_TYPE_VAR_5
5212 #undef DEF_POINTER_TYPE
5213 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
5215 c_init_attributes ();
5217 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
5218 NONANSI_P, ATTRS, IMPLICIT, COND) \
5220 def_builtin_1 (ENUM, NAME, CLASS, \
5221 builtin_types[(int) TYPE], \
5222 builtin_types[(int) LIBTYPE], \
5223 BOTH_P, FALLBACK_P, NONANSI_P, \
5224 built_in_attributes[(int) ATTRS], IMPLICIT);
5225 #include "builtins.def"
5228 targetm
.init_builtins ();
5230 build_common_builtin_nodes ();
5232 if (flag_enable_cilkplus
)
5233 cilk_init_builtins ();
5236 /* Like get_identifier, but avoid warnings about null arguments when
5237 the argument may be NULL for targets where GCC lacks stdint.h type
5241 c_get_ident (const char *id
)
5243 return get_identifier (id
);
5246 /* Build tree nodes and builtin functions common to both C and C++ language
5250 c_common_nodes_and_builtins (void)
5252 int char16_type_size
;
5253 int char32_type_size
;
5254 int wchar_type_size
;
5255 tree array_domain_type
;
5256 tree va_list_ref_type_node
;
5257 tree va_list_arg_type_node
;
5259 build_common_tree_nodes (flag_signed_char
, flag_short_double
);
5261 /* Define `int' and `char' first so that dbx will output them first. */
5262 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
5263 record_builtin_type (RID_CHAR
, "char", char_type_node
);
5265 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
5266 "unsigned long", "long long unsigned" and "unsigned short" were in C++
5267 but not C. Are the conditionals here needed? */
5268 if (c_dialect_cxx ())
5269 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
5270 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
5271 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
5272 record_builtin_type (RID_MAX
, "long unsigned int",
5273 long_unsigned_type_node
);
5274 if (int128_integer_type_node
!= NULL_TREE
)
5276 record_builtin_type (RID_INT128
, "__int128",
5277 int128_integer_type_node
);
5278 record_builtin_type (RID_MAX
, "__int128 unsigned",
5279 int128_unsigned_type_node
);
5281 if (c_dialect_cxx ())
5282 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
5283 record_builtin_type (RID_MAX
, "long long int",
5284 long_long_integer_type_node
);
5285 record_builtin_type (RID_MAX
, "long long unsigned int",
5286 long_long_unsigned_type_node
);
5287 if (c_dialect_cxx ())
5288 record_builtin_type (RID_MAX
, "long long unsigned",
5289 long_long_unsigned_type_node
);
5290 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
5291 record_builtin_type (RID_MAX
, "short unsigned int",
5292 short_unsigned_type_node
);
5293 if (c_dialect_cxx ())
5294 record_builtin_type (RID_MAX
, "unsigned short",
5295 short_unsigned_type_node
);
5297 /* Define both `signed char' and `unsigned char'. */
5298 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
5299 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
5301 /* These are types that c_common_type_for_size and
5302 c_common_type_for_mode use. */
5303 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5304 TYPE_DECL
, NULL_TREE
,
5306 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5307 TYPE_DECL
, NULL_TREE
,
5309 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5310 TYPE_DECL
, NULL_TREE
,
5312 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5313 TYPE_DECL
, NULL_TREE
,
5315 #if HOST_BITS_PER_WIDE_INT >= 64
5316 if (targetm
.scalar_mode_supported_p (TImode
))
5317 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5319 get_identifier ("__int128_t"),
5322 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5323 TYPE_DECL
, NULL_TREE
,
5324 unsigned_intQI_type_node
));
5325 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5326 TYPE_DECL
, NULL_TREE
,
5327 unsigned_intHI_type_node
));
5328 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5329 TYPE_DECL
, NULL_TREE
,
5330 unsigned_intSI_type_node
));
5331 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5332 TYPE_DECL
, NULL_TREE
,
5333 unsigned_intDI_type_node
));
5334 #if HOST_BITS_PER_WIDE_INT >= 64
5335 if (targetm
.scalar_mode_supported_p (TImode
))
5336 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5338 get_identifier ("__uint128_t"),
5339 unsigned_intTI_type_node
));
5342 /* Create the widest literal types. */
5343 widest_integer_literal_type_node
5344 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
5345 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5346 TYPE_DECL
, NULL_TREE
,
5347 widest_integer_literal_type_node
));
5349 widest_unsigned_literal_type_node
5350 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
5351 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5352 TYPE_DECL
, NULL_TREE
,
5353 widest_unsigned_literal_type_node
));
5355 signed_size_type_node
= c_common_signed_type (size_type_node
);
5358 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
5360 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
5361 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
5362 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
5364 /* Only supported decimal floating point extension if the target
5365 actually supports underlying modes. */
5366 if (targetm
.scalar_mode_supported_p (SDmode
)
5367 && targetm
.scalar_mode_supported_p (DDmode
)
5368 && targetm
.scalar_mode_supported_p (TDmode
))
5370 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
5371 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
5372 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
5375 if (targetm
.fixed_point_supported_p ())
5377 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
5378 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
5379 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
5380 record_builtin_type (RID_MAX
, "long long _Fract",
5381 long_long_fract_type_node
);
5382 record_builtin_type (RID_MAX
, "unsigned short _Fract",
5383 unsigned_short_fract_type_node
);
5384 record_builtin_type (RID_MAX
, "unsigned _Fract",
5385 unsigned_fract_type_node
);
5386 record_builtin_type (RID_MAX
, "unsigned long _Fract",
5387 unsigned_long_fract_type_node
);
5388 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
5389 unsigned_long_long_fract_type_node
);
5390 record_builtin_type (RID_MAX
, "_Sat short _Fract",
5391 sat_short_fract_type_node
);
5392 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
5393 record_builtin_type (RID_MAX
, "_Sat long _Fract",
5394 sat_long_fract_type_node
);
5395 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
5396 sat_long_long_fract_type_node
);
5397 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
5398 sat_unsigned_short_fract_type_node
);
5399 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
5400 sat_unsigned_fract_type_node
);
5401 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
5402 sat_unsigned_long_fract_type_node
);
5403 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
5404 sat_unsigned_long_long_fract_type_node
);
5405 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
5406 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
5407 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
5408 record_builtin_type (RID_MAX
, "long long _Accum",
5409 long_long_accum_type_node
);
5410 record_builtin_type (RID_MAX
, "unsigned short _Accum",
5411 unsigned_short_accum_type_node
);
5412 record_builtin_type (RID_MAX
, "unsigned _Accum",
5413 unsigned_accum_type_node
);
5414 record_builtin_type (RID_MAX
, "unsigned long _Accum",
5415 unsigned_long_accum_type_node
);
5416 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
5417 unsigned_long_long_accum_type_node
);
5418 record_builtin_type (RID_MAX
, "_Sat short _Accum",
5419 sat_short_accum_type_node
);
5420 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
5421 record_builtin_type (RID_MAX
, "_Sat long _Accum",
5422 sat_long_accum_type_node
);
5423 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
5424 sat_long_long_accum_type_node
);
5425 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
5426 sat_unsigned_short_accum_type_node
);
5427 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
5428 sat_unsigned_accum_type_node
);
5429 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
5430 sat_unsigned_long_accum_type_node
);
5431 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
5432 sat_unsigned_long_long_accum_type_node
);
5436 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5438 get_identifier ("complex int"),
5439 complex_integer_type_node
));
5440 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5442 get_identifier ("complex float"),
5443 complex_float_type_node
));
5444 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
5446 get_identifier ("complex double"),
5447 complex_double_type_node
));
5448 lang_hooks
.decls
.pushdecl
5449 (build_decl (UNKNOWN_LOCATION
,
5450 TYPE_DECL
, get_identifier ("complex long double"),
5451 complex_long_double_type_node
));
5453 if (c_dialect_cxx ())
5454 /* For C++, make fileptr_type_node a distinct void * type until
5455 FILE type is defined. */
5456 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
5458 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
5460 /* Set the TYPE_NAME for any variants that were built before
5461 record_builtin_type gave names to the built-in types. */
5463 tree void_name
= TYPE_NAME (void_type_node
);
5464 TYPE_NAME (void_type_node
) = NULL_TREE
;
5465 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
5467 TYPE_NAME (void_type_node
) = void_name
;
5470 /* This node must not be shared. */
5471 void_zero_node
= make_node (INTEGER_CST
);
5472 TREE_TYPE (void_zero_node
) = void_type_node
;
5474 void_list_node
= build_void_list_node ();
5476 /* Make a type to be the domain of a few array types
5477 whose domains don't really matter.
5478 200 is small enough that it always fits in size_t
5479 and large enough that it can hold most function names for the
5480 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5481 array_domain_type
= build_index_type (size_int (200));
5483 /* Make a type for arrays of characters.
5484 With luck nothing will ever really depend on the length of this
5486 char_array_type_node
5487 = build_array_type (char_type_node
, array_domain_type
);
5489 /* Likewise for arrays of ints. */
5491 = build_array_type (integer_type_node
, array_domain_type
);
5493 string_type_node
= build_pointer_type (char_type_node
);
5494 const_string_type_node
5495 = build_pointer_type (build_qualified_type
5496 (char_type_node
, TYPE_QUAL_CONST
));
5498 /* This is special for C++ so functions can be overloaded. */
5499 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
5500 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
5501 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
5502 underlying_wchar_type_node
= wchar_type_node
;
5503 if (c_dialect_cxx ())
5505 if (TYPE_UNSIGNED (wchar_type_node
))
5506 wchar_type_node
= make_unsigned_type (wchar_type_size
);
5508 wchar_type_node
= make_signed_type (wchar_type_size
);
5509 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
5512 /* This is for wide string constants. */
5513 wchar_array_type_node
5514 = build_array_type (wchar_type_node
, array_domain_type
);
5516 /* Define 'char16_t'. */
5517 char16_type_node
= get_identifier (CHAR16_TYPE
);
5518 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
5519 char16_type_size
= TYPE_PRECISION (char16_type_node
);
5520 if (c_dialect_cxx ())
5522 char16_type_node
= make_unsigned_type (char16_type_size
);
5524 if (cxx_dialect
>= cxx11
)
5525 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
5528 /* This is for UTF-16 string constants. */
5529 char16_array_type_node
5530 = build_array_type (char16_type_node
, array_domain_type
);
5532 /* Define 'char32_t'. */
5533 char32_type_node
= get_identifier (CHAR32_TYPE
);
5534 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
5535 char32_type_size
= TYPE_PRECISION (char32_type_node
);
5536 if (c_dialect_cxx ())
5538 char32_type_node
= make_unsigned_type (char32_type_size
);
5540 if (cxx_dialect
>= cxx11
)
5541 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
5544 /* This is for UTF-32 string constants. */
5545 char32_array_type_node
5546 = build_array_type (char32_type_node
, array_domain_type
);
5549 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
5552 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
5554 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
5556 if (SIG_ATOMIC_TYPE
)
5557 sig_atomic_type_node
=
5558 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE
)));
5561 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE
)));
5564 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE
)));
5567 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE
)));
5570 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE
)));
5573 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE
)));
5575 c_uint16_type_node
=
5576 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE
)));
5578 c_uint32_type_node
=
5579 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE
)));
5581 c_uint64_type_node
=
5582 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE
)));
5583 if (INT_LEAST8_TYPE
)
5584 int_least8_type_node
=
5585 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE
)));
5586 if (INT_LEAST16_TYPE
)
5587 int_least16_type_node
=
5588 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE
)));
5589 if (INT_LEAST32_TYPE
)
5590 int_least32_type_node
=
5591 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE
)));
5592 if (INT_LEAST64_TYPE
)
5593 int_least64_type_node
=
5594 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE
)));
5595 if (UINT_LEAST8_TYPE
)
5596 uint_least8_type_node
=
5597 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE
)));
5598 if (UINT_LEAST16_TYPE
)
5599 uint_least16_type_node
=
5600 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE
)));
5601 if (UINT_LEAST32_TYPE
)
5602 uint_least32_type_node
=
5603 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE
)));
5604 if (UINT_LEAST64_TYPE
)
5605 uint_least64_type_node
=
5606 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE
)));
5608 int_fast8_type_node
=
5609 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE
)));
5610 if (INT_FAST16_TYPE
)
5611 int_fast16_type_node
=
5612 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE
)));
5613 if (INT_FAST32_TYPE
)
5614 int_fast32_type_node
=
5615 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE
)));
5616 if (INT_FAST64_TYPE
)
5617 int_fast64_type_node
=
5618 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE
)));
5619 if (UINT_FAST8_TYPE
)
5620 uint_fast8_type_node
=
5621 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE
)));
5622 if (UINT_FAST16_TYPE
)
5623 uint_fast16_type_node
=
5624 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE
)));
5625 if (UINT_FAST32_TYPE
)
5626 uint_fast32_type_node
=
5627 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE
)));
5628 if (UINT_FAST64_TYPE
)
5629 uint_fast64_type_node
=
5630 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE
)));
5633 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE
)));
5636 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE
)));
5638 default_function_type
5639 = build_varargs_function_type_list (integer_type_node
, NULL_TREE
);
5641 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
5642 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
5644 lang_hooks
.decls
.pushdecl
5645 (build_decl (UNKNOWN_LOCATION
,
5646 TYPE_DECL
, get_identifier ("__builtin_va_list"),
5647 va_list_type_node
));
5648 if (targetm
.enum_va_list_p
)
5654 for (l
= 0; targetm
.enum_va_list_p (l
, &pname
, &ptype
); ++l
)
5656 lang_hooks
.decls
.pushdecl
5657 (build_decl (UNKNOWN_LOCATION
,
5658 TYPE_DECL
, get_identifier (pname
),
5664 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
5666 va_list_arg_type_node
= va_list_ref_type_node
=
5667 build_pointer_type (TREE_TYPE (va_list_type_node
));
5671 va_list_arg_type_node
= va_list_type_node
;
5672 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
5675 if (!flag_preprocess_only
)
5676 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
5678 main_identifier_node
= get_identifier ("main");
5680 /* Create the built-in __null node. It is important that this is
5682 null_node
= make_node (INTEGER_CST
);
5683 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
5685 /* Since builtin_types isn't gc'ed, don't export these nodes. */
5686 memset (builtin_types
, 0, sizeof (builtin_types
));
5689 /* The number of named compound-literals generated thus far. */
5690 static GTY(()) int compound_literal_number
;
5692 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
5695 set_compound_literal_name (tree decl
)
5698 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
5699 compound_literal_number
);
5700 compound_literal_number
++;
5701 DECL_NAME (decl
) = get_identifier (name
);
5705 build_va_arg (location_t loc
, tree expr
, tree type
)
5707 expr
= build1 (VA_ARG_EXPR
, type
, expr
);
5708 SET_EXPR_LOCATION (expr
, loc
);
5713 /* Linked list of disabled built-in functions. */
5715 typedef struct disabled_builtin
5718 struct disabled_builtin
*next
;
5720 static disabled_builtin
*disabled_builtins
= NULL
;
5722 static bool builtin_function_disabled_p (const char *);
5724 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5725 begins with "__builtin_", give an error. */
5728 disable_builtin_function (const char *name
)
5730 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
5731 error ("cannot disable built-in function %qs", name
);
5734 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
5735 new_disabled_builtin
->name
= name
;
5736 new_disabled_builtin
->next
= disabled_builtins
;
5737 disabled_builtins
= new_disabled_builtin
;
5742 /* Return true if the built-in function NAME has been disabled, false
5746 builtin_function_disabled_p (const char *name
)
5748 disabled_builtin
*p
;
5749 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
5751 if (strcmp (name
, p
->name
) == 0)
5758 /* Worker for DEF_BUILTIN.
5759 Possibly define a builtin function with one or two names.
5760 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5761 nonansi_p and flag_no_nonansi_builtin. */
5764 def_builtin_1 (enum built_in_function fncode
,
5766 enum built_in_class fnclass
,
5767 tree fntype
, tree libtype
,
5768 bool both_p
, bool fallback_p
, bool nonansi_p
,
5769 tree fnattrs
, bool implicit_p
)
5772 const char *libname
;
5774 if (fntype
== error_mark_node
)
5777 gcc_assert ((!both_p
&& !fallback_p
)
5778 || !strncmp (name
, "__builtin_",
5779 strlen ("__builtin_")));
5781 libname
= name
+ strlen ("__builtin_");
5782 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
5783 (fallback_p
? libname
: NULL
),
5786 set_builtin_decl (fncode
, decl
, implicit_p
);
5789 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
5790 && !(nonansi_p
&& flag_no_nonansi_builtin
))
5791 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
5795 /* Nonzero if the type T promotes to int. This is (nearly) the
5796 integral promotions defined in ISO C99 6.3.1.1/2. */
5799 c_promoting_integer_type_p (const_tree t
)
5801 switch (TREE_CODE (t
))
5804 return (TYPE_MAIN_VARIANT (t
) == char_type_node
5805 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
5806 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
5807 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
5808 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
5809 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
5812 /* ??? Technically all enumerations not larger than an int
5813 promote to an int. But this is used along code paths
5814 that only want to notice a size change. */
5815 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
5825 /* Return 1 if PARMS specifies a fixed number of parameters
5826 and none of their types is affected by default promotions. */
5829 self_promoting_args_p (const_tree parms
)
5832 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
5834 tree type
= TREE_VALUE (t
);
5836 if (type
== error_mark_node
)
5839 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
5845 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
5848 if (c_promoting_integer_type_p (type
))
5854 /* Recursively remove any '*' or '&' operator from TYPE. */
5856 strip_pointer_operator (tree t
)
5858 while (POINTER_TYPE_P (t
))
5863 /* Recursively remove pointer or array type from TYPE. */
5865 strip_pointer_or_array_types (tree t
)
5867 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
5872 /* Used to compare case labels. K1 and K2 are actually tree nodes
5873 representing case labels, or NULL_TREE for a `default' label.
5874 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5875 K2, and 0 if K1 and K2 are equal. */
5878 case_compare (splay_tree_key k1
, splay_tree_key k2
)
5880 /* Consider a NULL key (such as arises with a `default' label) to be
5881 smaller than anything else. */
5887 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5890 /* Process a case label, located at LOC, for the range LOW_VALUE
5891 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5892 then this case label is actually a `default' label. If only
5893 HIGH_VALUE is NULL_TREE, then case label was declared using the
5894 usual C/C++ syntax, rather than the GNU case range extension.
5895 CASES is a tree containing all the case ranges processed so far;
5896 COND is the condition for the switch-statement itself. Returns the
5897 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5901 c_add_case_label (location_t loc
, splay_tree cases
, tree cond
, tree orig_type
,
5902 tree low_value
, tree high_value
)
5907 splay_tree_node node
;
5909 /* Create the LABEL_DECL itself. */
5910 label
= create_artificial_label (loc
);
5912 /* If there was an error processing the switch condition, bail now
5913 before we get more confused. */
5914 if (!cond
|| cond
== error_mark_node
)
5917 if ((low_value
&& TREE_TYPE (low_value
)
5918 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
5919 || (high_value
&& TREE_TYPE (high_value
)
5920 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
5922 error_at (loc
, "pointers are not permitted as case values");
5926 /* Case ranges are a GNU extension. */
5928 pedwarn (loc
, OPT_Wpedantic
,
5929 "range expressions in switch statements are non-standard");
5931 type
= TREE_TYPE (cond
);
5934 low_value
= check_case_value (low_value
);
5935 low_value
= convert_and_check (type
, low_value
);
5936 if (low_value
== error_mark_node
)
5941 high_value
= check_case_value (high_value
);
5942 high_value
= convert_and_check (type
, high_value
);
5943 if (high_value
== error_mark_node
)
5947 if (low_value
&& high_value
)
5949 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5950 really a case range, even though it was written that way.
5951 Remove the HIGH_VALUE to simplify later processing. */
5952 if (tree_int_cst_equal (low_value
, high_value
))
5953 high_value
= NULL_TREE
;
5954 else if (!tree_int_cst_lt (low_value
, high_value
))
5955 warning_at (loc
, 0, "empty range specified");
5958 /* See if the case is in range of the type of the original testing
5959 expression. If both low_value and high_value are out of range,
5960 don't insert the case label and return NULL_TREE. */
5962 && !check_case_bounds (type
, orig_type
,
5963 &low_value
, high_value
? &high_value
: NULL
))
5966 /* Look up the LOW_VALUE in the table of case labels we already
5968 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
5969 /* If there was not an exact match, check for overlapping ranges.
5970 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5971 that's a `default' label and the only overlap is an exact match. */
5972 if (!node
&& (low_value
|| high_value
))
5974 splay_tree_node low_bound
;
5975 splay_tree_node high_bound
;
5977 /* Even though there wasn't an exact match, there might be an
5978 overlap between this case range and another case range.
5979 Since we've (inductively) not allowed any overlapping case
5980 ranges, we simply need to find the greatest low case label
5981 that is smaller that LOW_VALUE, and the smallest low case
5982 label that is greater than LOW_VALUE. If there is an overlap
5983 it will occur in one of these two ranges. */
5984 low_bound
= splay_tree_predecessor (cases
,
5985 (splay_tree_key
) low_value
);
5986 high_bound
= splay_tree_successor (cases
,
5987 (splay_tree_key
) low_value
);
5989 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5990 the LOW_VALUE, so there is no need to check unless the
5991 LOW_BOUND is in fact itself a case range. */
5993 && CASE_HIGH ((tree
) low_bound
->value
)
5994 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
5997 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5998 range is bigger than the low end of the current range, so we
5999 are only interested if the current range is a real range, and
6000 not an ordinary case label. */
6003 && (tree_int_cst_compare ((tree
) high_bound
->key
,
6008 /* If there was an overlap, issue an error. */
6011 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
6015 error_at (loc
, "duplicate (or overlapping) case value");
6016 error_at (DECL_SOURCE_LOCATION (duplicate
),
6017 "this is the first entry overlapping that value");
6021 error_at (loc
, "duplicate case value") ;
6022 error_at (DECL_SOURCE_LOCATION (duplicate
), "previously used here");
6026 error_at (loc
, "multiple default labels in one switch");
6027 error_at (DECL_SOURCE_LOCATION (duplicate
),
6028 "this is the first default label");
6033 /* Add a CASE_LABEL to the statement-tree. */
6034 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
6035 /* Register this case label in the splay tree. */
6036 splay_tree_insert (cases
,
6037 (splay_tree_key
) low_value
,
6038 (splay_tree_value
) case_label
);
6043 /* Add a label so that the back-end doesn't think that the beginning of
6044 the switch is unreachable. Note that we do not add a case label, as
6045 that just leads to duplicates and thence to failure later on. */
6048 tree t
= create_artificial_label (loc
);
6049 add_stmt (build_stmt (loc
, LABEL_EXPR
, t
));
6051 return error_mark_node
;
6054 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
6055 Used to verify that case values match up with enumerator values. */
6058 match_case_to_enum_1 (tree key
, tree type
, tree label
)
6060 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
6062 /* ??? Not working too hard to print the double-word value.
6063 Should perhaps be done with %lwd in the diagnostic routines? */
6064 if (TREE_INT_CST_HIGH (key
) == 0)
6065 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
6066 TREE_INT_CST_LOW (key
));
6067 else if (!TYPE_UNSIGNED (type
)
6068 && TREE_INT_CST_HIGH (key
) == -1
6069 && TREE_INT_CST_LOW (key
) != 0)
6070 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
6071 -TREE_INT_CST_LOW (key
));
6073 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
6074 (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (key
),
6075 (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (key
));
6077 if (TYPE_NAME (type
) == 0)
6078 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
6079 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
6080 "case value %qs not in enumerated type",
6083 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
6084 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
6085 "case value %qs not in enumerated type %qT",
6089 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
6090 Used to verify that case values match up with enumerator values. */
6093 match_case_to_enum (splay_tree_node node
, void *data
)
6095 tree label
= (tree
) node
->value
;
6096 tree type
= (tree
) data
;
6098 /* Skip default case. */
6099 if (!CASE_LOW (label
))
6102 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
6103 when we did our enum->case scan. Reset our scratch bit after. */
6104 if (!CASE_LOW_SEEN (label
))
6105 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
6107 CASE_LOW_SEEN (label
) = 0;
6109 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
6110 not set, that means that CASE_HIGH did not appear when we did our
6111 enum->case scan. Reset our scratch bit after. */
6112 if (CASE_HIGH (label
))
6114 if (!CASE_HIGH_SEEN (label
))
6115 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
6117 CASE_HIGH_SEEN (label
) = 0;
6123 /* Handle -Wswitch*. Called from the front end after parsing the
6124 switch construct. */
6125 /* ??? Should probably be somewhere generic, since other languages
6126 besides C and C++ would want this. At the moment, however, C/C++
6127 are the only tree-ssa languages that support enumerations at all,
6128 so the point is moot. */
6131 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
6132 tree type
, tree cond
)
6134 splay_tree_node default_node
;
6135 splay_tree_node node
;
6138 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
6141 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
6143 warning_at (switch_location
, OPT_Wswitch_default
,
6144 "switch missing default case");
6146 /* From here on, we only care about about enumerated types. */
6147 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
6150 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
6151 if (!warn_switch_enum
&& !warn_switch
)
6154 /* Check the cases. Warn about case values which are not members of
6155 the enumerated type. For -Wswitch-enum, or for -Wswitch when
6156 there is no default case, check that exactly all enumeration
6157 literals are covered by the cases. */
6159 /* Clearing COND if it is not an integer constant simplifies
6160 the tests inside the loop below. */
6161 if (TREE_CODE (cond
) != INTEGER_CST
)
6164 /* The time complexity here is O(N*lg(N)) worst case, but for the
6165 common case of monotonically increasing enumerators, it is
6166 O(N), since the nature of the splay tree will keep the next
6167 element adjacent to the root at all times. */
6169 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
6171 tree value
= TREE_VALUE (chain
);
6172 if (TREE_CODE (value
) == CONST_DECL
)
6173 value
= DECL_INITIAL (value
);
6174 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
6177 /* Mark the CASE_LOW part of the case entry as seen. */
6178 tree label
= (tree
) node
->value
;
6179 CASE_LOW_SEEN (label
) = 1;
6183 /* Even though there wasn't an exact match, there might be a
6184 case range which includes the enumerator's value. */
6185 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
6186 if (node
&& CASE_HIGH ((tree
) node
->value
))
6188 tree label
= (tree
) node
->value
;
6189 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
6192 /* If we match the upper bound exactly, mark the CASE_HIGH
6193 part of the case entry as seen. */
6195 CASE_HIGH_SEEN (label
) = 1;
6200 /* We've now determined that this enumerated literal isn't
6201 handled by the case labels of the switch statement. */
6203 /* If the switch expression is a constant, we only really care
6204 about whether that constant is handled by the switch. */
6205 if (cond
&& tree_int_cst_compare (cond
, value
))
6208 /* If there is a default_node, the only relevant option is
6209 Wswitch-enum. Otherwise, if both are enabled then we prefer
6210 to warn using -Wswitch because -Wswitch is enabled by -Wall
6211 while -Wswitch-enum is explicit. */
6212 warning_at (switch_location
,
6213 (default_node
|| !warn_switch
6216 "enumeration value %qE not handled in switch",
6217 TREE_PURPOSE (chain
));
6220 /* Warn if there are case expressions that don't correspond to
6221 enumerators. This can occur since C and C++ don't enforce
6222 type-checking of assignments to enumeration variables.
6224 The time complexity here is now always O(N) worst case, since
6225 we should have marked both the lower bound and upper bound of
6226 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
6227 above. This scan also resets those fields. */
6229 splay_tree_foreach (cases
, match_case_to_enum
, type
);
6232 /* Finish an expression taking the address of LABEL (an
6233 IDENTIFIER_NODE). Returns an expression for the address.
6235 LOC is the location for the expression returned. */
6238 finish_label_address_expr (tree label
, location_t loc
)
6242 pedwarn (input_location
, OPT_Wpedantic
, "taking the address of a label is non-standard");
6244 if (label
== error_mark_node
)
6245 return error_mark_node
;
6247 label
= lookup_label (label
);
6248 if (label
== NULL_TREE
)
6249 result
= null_pointer_node
;
6252 TREE_USED (label
) = 1;
6253 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
6254 /* The current function is not necessarily uninlinable.
6255 Computed gotos are incompatible with inlining, but the value
6256 here could be used only in a diagnostic, for example. */
6257 protected_set_expr_location (result
, loc
);
6264 /* Given a boolean expression ARG, return a tree representing an increment
6265 or decrement (as indicated by CODE) of ARG. The front end must check for
6266 invalid cases (e.g., decrement in C++). */
6268 boolean_increment (enum tree_code code
, tree arg
)
6271 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
6273 arg
= stabilize_reference (arg
);
6276 case PREINCREMENT_EXPR
:
6277 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
6279 case POSTINCREMENT_EXPR
:
6280 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
6281 arg
= save_expr (arg
);
6282 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
6283 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
6285 case PREDECREMENT_EXPR
:
6286 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
6287 invert_truthvalue_loc (input_location
, arg
));
6289 case POSTDECREMENT_EXPR
:
6290 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
6291 invert_truthvalue_loc (input_location
, arg
));
6292 arg
= save_expr (arg
);
6293 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
6294 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
6299 TREE_SIDE_EFFECTS (val
) = 1;
6303 /* Built-in macros for stddef.h and stdint.h, that require macros
6304 defined in this file. */
6306 c_stddef_cpp_builtins(void)
6308 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
6309 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
6310 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
6311 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
6312 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
6313 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
6314 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
6315 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
6316 if (SIG_ATOMIC_TYPE
)
6317 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE
, 0);
6319 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE
, 0);
6321 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE
, 0);
6323 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE
, 0);
6325 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE
, 0);
6327 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE
, 0);
6329 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE
, 0);
6331 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE
, 0);
6333 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE
, 0);
6334 if (INT_LEAST8_TYPE
)
6335 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE
, 0);
6336 if (INT_LEAST16_TYPE
)
6337 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE
, 0);
6338 if (INT_LEAST32_TYPE
)
6339 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE
, 0);
6340 if (INT_LEAST64_TYPE
)
6341 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE
, 0);
6342 if (UINT_LEAST8_TYPE
)
6343 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE
, 0);
6344 if (UINT_LEAST16_TYPE
)
6345 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE
, 0);
6346 if (UINT_LEAST32_TYPE
)
6347 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE
, 0);
6348 if (UINT_LEAST64_TYPE
)
6349 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE
, 0);
6351 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE
, 0);
6352 if (INT_FAST16_TYPE
)
6353 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE
, 0);
6354 if (INT_FAST32_TYPE
)
6355 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE
, 0);
6356 if (INT_FAST64_TYPE
)
6357 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE
, 0);
6358 if (UINT_FAST8_TYPE
)
6359 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE
, 0);
6360 if (UINT_FAST16_TYPE
)
6361 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE
, 0);
6362 if (UINT_FAST32_TYPE
)
6363 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE
, 0);
6364 if (UINT_FAST64_TYPE
)
6365 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE
, 0);
6367 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE
, 0);
6369 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE
, 0);
6373 c_init_attributes (void)
6375 /* Fill in the built_in_attributes array. */
6376 #define DEF_ATTR_NULL_TREE(ENUM) \
6377 built_in_attributes[(int) ENUM] = NULL_TREE;
6378 #define DEF_ATTR_INT(ENUM, VALUE) \
6379 built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE);
6380 #define DEF_ATTR_STRING(ENUM, VALUE) \
6381 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
6382 #define DEF_ATTR_IDENT(ENUM, STRING) \
6383 built_in_attributes[(int) ENUM] = get_identifier (STRING);
6384 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
6385 built_in_attributes[(int) ENUM] \
6386 = tree_cons (built_in_attributes[(int) PURPOSE], \
6387 built_in_attributes[(int) VALUE], \
6388 built_in_attributes[(int) CHAIN]);
6389 #include "builtin-attrs.def"
6390 #undef DEF_ATTR_NULL_TREE
6392 #undef DEF_ATTR_IDENT
6393 #undef DEF_ATTR_TREE_LIST
6396 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
6397 identifier as an argument, so the front end shouldn't look it up. */
6400 attribute_takes_identifier_p (const_tree attr_id
)
6402 const struct attribute_spec
*spec
= lookup_attribute_spec (attr_id
);
6404 /* Unknown attribute that we'll end up ignoring, return true so we
6405 don't complain about an identifier argument. */
6407 else if (!strcmp ("mode", spec
->name
)
6408 || !strcmp ("format", spec
->name
)
6409 || !strcmp ("cleanup", spec
->name
))
6412 return targetm
.attribute_takes_identifier_p (attr_id
);
6415 /* Attribute handlers common to C front ends. */
6417 /* Handle a "packed" attribute; arguments as in
6418 struct attribute_spec.handler. */
6421 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6422 int flags
, bool *no_add_attrs
)
6426 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6427 *node
= build_variant_type_copy (*node
);
6428 TYPE_PACKED (*node
) = 1;
6430 else if (TREE_CODE (*node
) == FIELD_DECL
)
6432 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
6433 /* Still pack bitfields. */
6434 && ! DECL_INITIAL (*node
))
6435 warning (OPT_Wattributes
,
6436 "%qE attribute ignored for field of type %qT",
6437 name
, TREE_TYPE (*node
));
6439 DECL_PACKED (*node
) = 1;
6441 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
6442 used for DECL_REGISTER. It wouldn't mean anything anyway.
6443 We can't set DECL_PACKED on the type of a TYPE_DECL, because
6444 that changes what the typedef is typing. */
6447 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6448 *no_add_attrs
= true;
6454 /* Handle a "nocommon" attribute; arguments as in
6455 struct attribute_spec.handler. */
6458 handle_nocommon_attribute (tree
*node
, tree name
,
6459 tree
ARG_UNUSED (args
),
6460 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6462 if (TREE_CODE (*node
) == VAR_DECL
)
6463 DECL_COMMON (*node
) = 0;
6466 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6467 *no_add_attrs
= true;
6473 /* Handle a "common" attribute; arguments as in
6474 struct attribute_spec.handler. */
6477 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6478 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6480 if (TREE_CODE (*node
) == VAR_DECL
)
6481 DECL_COMMON (*node
) = 1;
6484 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6485 *no_add_attrs
= true;
6491 /* Handle a "noreturn" attribute; arguments as in
6492 struct attribute_spec.handler. */
6495 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6496 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6498 tree type
= TREE_TYPE (*node
);
6500 /* See FIXME comment in c_common_attribute_table. */
6501 if (TREE_CODE (*node
) == FUNCTION_DECL
6502 || objc_method_decl (TREE_CODE (*node
)))
6503 TREE_THIS_VOLATILE (*node
) = 1;
6504 else if (TREE_CODE (type
) == POINTER_TYPE
6505 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
6507 = build_pointer_type
6508 (build_type_variant (TREE_TYPE (type
),
6509 TYPE_READONLY (TREE_TYPE (type
)), 1));
6512 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6513 *no_add_attrs
= true;
6519 /* Handle a "hot" and attribute; arguments as in
6520 struct attribute_spec.handler. */
6523 handle_hot_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6524 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6526 if (TREE_CODE (*node
) == FUNCTION_DECL
6527 || TREE_CODE (*node
) == LABEL_DECL
)
6529 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node
)) != NULL
)
6531 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
6533 *no_add_attrs
= true;
6535 /* Most of the rest of the hot processing is done later with
6536 lookup_attribute. */
6540 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6541 *no_add_attrs
= true;
6547 /* Handle a "cold" and attribute; arguments as in
6548 struct attribute_spec.handler. */
6551 handle_cold_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6552 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6554 if (TREE_CODE (*node
) == FUNCTION_DECL
6555 || TREE_CODE (*node
) == LABEL_DECL
)
6557 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node
)) != NULL
)
6559 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
6561 *no_add_attrs
= true;
6563 /* Most of the rest of the cold processing is done later with
6564 lookup_attribute. */
6568 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6569 *no_add_attrs
= true;
6575 /* Handle a "no_sanitize_address" attribute; arguments as in
6576 struct attribute_spec.handler. */
6579 handle_no_sanitize_address_attribute (tree
*node
, tree name
, tree
, int,
6582 if (TREE_CODE (*node
) != FUNCTION_DECL
)
6584 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6585 *no_add_attrs
= true;
6591 /* Handle a "no_address_safety_analysis" attribute; arguments as in
6592 struct attribute_spec.handler. */
6595 handle_no_address_safety_analysis_attribute (tree
*node
, tree name
, tree
, int,
6598 if (TREE_CODE (*node
) != FUNCTION_DECL
)
6599 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6600 else if (!lookup_attribute ("no_sanitize_address", DECL_ATTRIBUTES (*node
)))
6601 DECL_ATTRIBUTES (*node
)
6602 = tree_cons (get_identifier ("no_sanitize_address"),
6603 NULL_TREE
, DECL_ATTRIBUTES (*node
));
6604 *no_add_attrs
= true;
6608 /* Handle a "no_sanitize_undefined" attribute; arguments as in
6609 struct attribute_spec.handler. */
6612 handle_no_sanitize_undefined_attribute (tree
*node
, tree name
, tree
, int,
6615 if (TREE_CODE (*node
) != FUNCTION_DECL
)
6617 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6618 *no_add_attrs
= true;
6624 /* Handle a "noinline" attribute; arguments as in
6625 struct attribute_spec.handler. */
6628 handle_noinline_attribute (tree
*node
, tree name
,
6629 tree
ARG_UNUSED (args
),
6630 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6632 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6633 DECL_UNINLINABLE (*node
) = 1;
6636 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6637 *no_add_attrs
= true;
6643 /* Handle a "noclone" attribute; arguments as in
6644 struct attribute_spec.handler. */
6647 handle_noclone_attribute (tree
*node
, tree name
,
6648 tree
ARG_UNUSED (args
),
6649 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6651 if (TREE_CODE (*node
) != FUNCTION_DECL
)
6653 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6654 *no_add_attrs
= true;
6660 /* Handle a "always_inline" attribute; arguments as in
6661 struct attribute_spec.handler. */
6664 handle_always_inline_attribute (tree
*node
, tree name
,
6665 tree
ARG_UNUSED (args
),
6666 int ARG_UNUSED (flags
),
6669 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6671 /* Set the attribute and mark it for disregarding inline
6673 DECL_DISREGARD_INLINE_LIMITS (*node
) = 1;
6677 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6678 *no_add_attrs
= true;
6684 /* Handle a "gnu_inline" attribute; arguments as in
6685 struct attribute_spec.handler. */
6688 handle_gnu_inline_attribute (tree
*node
, tree name
,
6689 tree
ARG_UNUSED (args
),
6690 int ARG_UNUSED (flags
),
6693 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
6695 /* Do nothing else, just set the attribute. We'll get at
6696 it later with lookup_attribute. */
6700 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6701 *no_add_attrs
= true;
6707 /* Handle a "leaf" attribute; arguments as in
6708 struct attribute_spec.handler. */
6711 handle_leaf_attribute (tree
*node
, tree name
,
6712 tree
ARG_UNUSED (args
),
6713 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6715 if (TREE_CODE (*node
) != FUNCTION_DECL
)
6717 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6718 *no_add_attrs
= true;
6720 if (!TREE_PUBLIC (*node
))
6722 warning (OPT_Wattributes
, "%qE attribute has no effect on unit local functions", name
);
6723 *no_add_attrs
= true;
6729 /* Handle an "artificial" attribute; arguments as in
6730 struct attribute_spec.handler. */
6733 handle_artificial_attribute (tree
*node
, tree name
,
6734 tree
ARG_UNUSED (args
),
6735 int ARG_UNUSED (flags
),
6738 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
6740 /* Do nothing else, just set the attribute. We'll get at
6741 it later with lookup_attribute. */
6745 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6746 *no_add_attrs
= true;
6752 /* Handle a "flatten" attribute; arguments as in
6753 struct attribute_spec.handler. */
6756 handle_flatten_attribute (tree
*node
, tree name
,
6757 tree args ATTRIBUTE_UNUSED
,
6758 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
6760 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6761 /* Do nothing else, just set the attribute. We'll get at
6762 it later with lookup_attribute. */
6766 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6767 *no_add_attrs
= true;
6773 /* Handle a "warning" or "error" attribute; arguments as in
6774 struct attribute_spec.handler. */
6777 handle_error_attribute (tree
*node
, tree name
, tree args
,
6778 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6780 if (TREE_CODE (*node
) == FUNCTION_DECL
6781 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
6782 /* Do nothing else, just set the attribute. We'll get at
6783 it later with lookup_attribute. */
6787 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6788 *no_add_attrs
= true;
6794 /* Handle a "used" attribute; arguments as in
6795 struct attribute_spec.handler. */
6798 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
6799 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6803 if (TREE_CODE (node
) == FUNCTION_DECL
6804 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
))
6805 || (TREE_CODE (node
) == TYPE_DECL
))
6807 TREE_USED (node
) = 1;
6808 DECL_PRESERVE_P (node
) = 1;
6809 if (TREE_CODE (node
) == VAR_DECL
)
6810 DECL_READ_P (node
) = 1;
6814 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6815 *no_add_attrs
= true;
6821 /* Handle a "unused" attribute; arguments as in
6822 struct attribute_spec.handler. */
6825 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6826 int flags
, bool *no_add_attrs
)
6832 if (TREE_CODE (decl
) == PARM_DECL
6833 || TREE_CODE (decl
) == VAR_DECL
6834 || TREE_CODE (decl
) == FUNCTION_DECL
6835 || TREE_CODE (decl
) == LABEL_DECL
6836 || TREE_CODE (decl
) == TYPE_DECL
)
6838 TREE_USED (decl
) = 1;
6839 if (TREE_CODE (decl
) == VAR_DECL
6840 || TREE_CODE (decl
) == PARM_DECL
)
6841 DECL_READ_P (decl
) = 1;
6845 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6846 *no_add_attrs
= true;
6851 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6852 *node
= build_variant_type_copy (*node
);
6853 TREE_USED (*node
) = 1;
6859 /* Handle a "externally_visible" attribute; arguments as in
6860 struct attribute_spec.handler. */
6863 handle_externally_visible_attribute (tree
*pnode
, tree name
,
6864 tree
ARG_UNUSED (args
),
6865 int ARG_UNUSED (flags
),
6870 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
6872 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
6873 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
6875 warning (OPT_Wattributes
,
6876 "%qE attribute have effect only on public objects", name
);
6877 *no_add_attrs
= true;
6882 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6883 *no_add_attrs
= true;
6889 /* Handle a "const" attribute; arguments as in
6890 struct attribute_spec.handler. */
6893 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6894 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6896 tree type
= TREE_TYPE (*node
);
6898 /* See FIXME comment on noreturn in c_common_attribute_table. */
6899 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6900 TREE_READONLY (*node
) = 1;
6901 else if (TREE_CODE (type
) == POINTER_TYPE
6902 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
6904 = build_pointer_type
6905 (build_type_variant (TREE_TYPE (type
), 1,
6906 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
6909 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6910 *no_add_attrs
= true;
6916 /* Handle a "transparent_union" attribute; arguments as in
6917 struct attribute_spec.handler. */
6920 handle_transparent_union_attribute (tree
*node
, tree name
,
6921 tree
ARG_UNUSED (args
), int flags
,
6926 *no_add_attrs
= true;
6929 if (TREE_CODE (*node
) == TYPE_DECL
6930 && ! (flags
& ATTR_FLAG_CXX11
))
6931 node
= &TREE_TYPE (*node
);
6934 if (TREE_CODE (type
) == UNION_TYPE
)
6936 /* Make sure that the first field will work for a transparent union.
6937 If the type isn't complete yet, leave the check to the code in
6939 if (TYPE_SIZE (type
))
6941 tree first
= first_field (type
);
6942 if (first
== NULL_TREE
6943 || DECL_ARTIFICIAL (first
)
6944 || TYPE_MODE (type
) != DECL_MODE (first
))
6948 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6950 /* If the type isn't complete yet, setting the flag
6951 on a variant wouldn't ever be checked. */
6952 if (!TYPE_SIZE (type
))
6955 /* build_duplicate_type doesn't work for C++. */
6956 if (c_dialect_cxx ())
6959 /* A type variant isn't good enough, since we don't a cast
6960 to such a type removed as a no-op. */
6961 *node
= type
= build_duplicate_type (type
);
6964 TYPE_TRANSPARENT_AGGR (type
) = 1;
6969 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6973 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6974 get the requested priority for a constructor or destructor,
6975 possibly issuing diagnostics for invalid or reserved
6978 static priority_type
6979 get_priority (tree args
, bool is_destructor
)
6985 return DEFAULT_INIT_PRIORITY
;
6987 if (!SUPPORTS_INIT_PRIORITY
)
6990 error ("destructor priorities are not supported");
6992 error ("constructor priorities are not supported");
6993 return DEFAULT_INIT_PRIORITY
;
6996 arg
= TREE_VALUE (args
);
6997 arg
= default_conversion (arg
);
6998 if (!host_integerp (arg
, /*pos=*/0)
6999 || !INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
7002 pri
= tree_low_cst (arg
, /*pos=*/0);
7003 if (pri
< 0 || pri
> MAX_INIT_PRIORITY
)
7006 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
7010 "destructor priorities from 0 to %d are reserved "
7011 "for the implementation",
7012 MAX_RESERVED_INIT_PRIORITY
);
7015 "constructor priorities from 0 to %d are reserved "
7016 "for the implementation",
7017 MAX_RESERVED_INIT_PRIORITY
);
7023 error ("destructor priorities must be integers from 0 to %d inclusive",
7026 error ("constructor priorities must be integers from 0 to %d inclusive",
7028 return DEFAULT_INIT_PRIORITY
;
7031 /* Handle a "constructor" attribute; arguments as in
7032 struct attribute_spec.handler. */
7035 handle_constructor_attribute (tree
*node
, tree name
, tree args
,
7036 int ARG_UNUSED (flags
),
7040 tree type
= TREE_TYPE (decl
);
7042 if (TREE_CODE (decl
) == FUNCTION_DECL
7043 && TREE_CODE (type
) == FUNCTION_TYPE
7044 && decl_function_context (decl
) == 0)
7046 priority_type priority
;
7047 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
7048 priority
= get_priority (args
, /*is_destructor=*/false);
7049 SET_DECL_INIT_PRIORITY (decl
, priority
);
7050 TREE_USED (decl
) = 1;
7054 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7055 *no_add_attrs
= true;
7061 /* Handle a "destructor" attribute; arguments as in
7062 struct attribute_spec.handler. */
7065 handle_destructor_attribute (tree
*node
, tree name
, tree args
,
7066 int ARG_UNUSED (flags
),
7070 tree type
= TREE_TYPE (decl
);
7072 if (TREE_CODE (decl
) == FUNCTION_DECL
7073 && TREE_CODE (type
) == FUNCTION_TYPE
7074 && decl_function_context (decl
) == 0)
7076 priority_type priority
;
7077 DECL_STATIC_DESTRUCTOR (decl
) = 1;
7078 priority
= get_priority (args
, /*is_destructor=*/true);
7079 SET_DECL_FINI_PRIORITY (decl
, priority
);
7080 TREE_USED (decl
) = 1;
7084 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7085 *no_add_attrs
= true;
7091 /* Nonzero if the mode is a valid vector mode for this architecture.
7092 This returns nonzero even if there is no hardware support for the
7093 vector mode, but we can emulate with narrower modes. */
7096 vector_mode_valid_p (enum machine_mode mode
)
7098 enum mode_class mclass
= GET_MODE_CLASS (mode
);
7099 enum machine_mode innermode
;
7101 /* Doh! What's going on? */
7102 if (mclass
!= MODE_VECTOR_INT
7103 && mclass
!= MODE_VECTOR_FLOAT
7104 && mclass
!= MODE_VECTOR_FRACT
7105 && mclass
!= MODE_VECTOR_UFRACT
7106 && mclass
!= MODE_VECTOR_ACCUM
7107 && mclass
!= MODE_VECTOR_UACCUM
)
7110 /* Hardware support. Woo hoo! */
7111 if (targetm
.vector_mode_supported_p (mode
))
7114 innermode
= GET_MODE_INNER (mode
);
7116 /* We should probably return 1 if requesting V4DI and we have no DI,
7117 but we have V2DI, but this is probably very unlikely. */
7119 /* If we have support for the inner mode, we can safely emulate it.
7120 We may not have V2DI, but me can emulate with a pair of DIs. */
7121 return targetm
.scalar_mode_supported_p (innermode
);
7125 /* Handle a "mode" attribute; arguments as in
7126 struct attribute_spec.handler. */
7129 handle_mode_attribute (tree
*node
, tree name
, tree args
,
7130 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7133 tree ident
= TREE_VALUE (args
);
7135 *no_add_attrs
= true;
7137 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
7138 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7142 const char *p
= IDENTIFIER_POINTER (ident
);
7143 int len
= strlen (p
);
7144 enum machine_mode mode
= VOIDmode
;
7148 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
7149 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
7151 char *newp
= (char *) alloca (len
- 1);
7153 strcpy (newp
, &p
[2]);
7154 newp
[len
- 4] = '\0';
7158 /* Change this type to have a type with the specified mode.
7159 First check for the special modes. */
7160 if (!strcmp (p
, "byte"))
7162 else if (!strcmp (p
, "word"))
7164 else if (!strcmp (p
, "pointer"))
7166 else if (!strcmp (p
, "libgcc_cmp_return"))
7167 mode
= targetm
.libgcc_cmp_return_mode ();
7168 else if (!strcmp (p
, "libgcc_shift_count"))
7169 mode
= targetm
.libgcc_shift_count_mode ();
7170 else if (!strcmp (p
, "unwind_word"))
7171 mode
= targetm
.unwind_word_mode ();
7173 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
7174 if (!strcmp (p
, GET_MODE_NAME (j
)))
7176 mode
= (enum machine_mode
) j
;
7180 if (mode
== VOIDmode
)
7182 error ("unknown machine mode %qE", ident
);
7187 switch (GET_MODE_CLASS (mode
))
7190 case MODE_PARTIAL_INT
:
7192 case MODE_DECIMAL_FLOAT
:
7197 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
7200 case MODE_COMPLEX_INT
:
7201 case MODE_COMPLEX_FLOAT
:
7202 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
7205 case MODE_VECTOR_INT
:
7206 case MODE_VECTOR_FLOAT
:
7207 case MODE_VECTOR_FRACT
:
7208 case MODE_VECTOR_UFRACT
:
7209 case MODE_VECTOR_ACCUM
:
7210 case MODE_VECTOR_UACCUM
:
7211 warning (OPT_Wattributes
, "specifying vector types with "
7212 "__attribute__ ((mode)) is deprecated");
7213 warning (OPT_Wattributes
,
7214 "use __attribute__ ((vector_size)) instead");
7215 valid_mode
= vector_mode_valid_p (mode
);
7223 error ("unable to emulate %qs", p
);
7227 if (POINTER_TYPE_P (type
))
7229 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
7230 tree (*fn
)(tree
, enum machine_mode
, bool);
7232 if (!targetm
.addr_space
.valid_pointer_mode (mode
, as
))
7234 error ("invalid pointer mode %qs", p
);
7238 if (TREE_CODE (type
) == POINTER_TYPE
)
7239 fn
= build_pointer_type_for_mode
;
7241 fn
= build_reference_type_for_mode
;
7242 typefm
= fn (TREE_TYPE (type
), mode
, false);
7246 /* For fixed-point modes, we need to test if the signness of type
7247 and the machine mode are consistent. */
7248 if (ALL_FIXED_POINT_MODE_P (mode
)
7249 && TYPE_UNSIGNED (type
) != UNSIGNED_FIXED_POINT_MODE_P (mode
))
7251 error ("signedness of type and machine mode %qs don%'t match", p
);
7254 /* For fixed-point modes, we need to pass saturating info. */
7255 typefm
= lang_hooks
.types
.type_for_mode (mode
,
7256 ALL_FIXED_POINT_MODE_P (mode
) ? TYPE_SATURATING (type
)
7257 : TYPE_UNSIGNED (type
));
7260 if (typefm
== NULL_TREE
)
7262 error ("no data type for mode %qs", p
);
7265 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
7267 /* For enumeral types, copy the precision from the integer
7268 type returned above. If not an INTEGER_TYPE, we can't use
7269 this mode for this type. */
7270 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
7272 error ("cannot use mode %qs for enumeral types", p
);
7276 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
7278 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
7283 /* We cannot build a type variant, as there's code that assumes
7284 that TYPE_MAIN_VARIANT has the same mode. This includes the
7285 debug generators. Instead, create a subrange type. This
7286 results in all of the enumeral values being emitted only once
7287 in the original, and the subtype gets them by reference. */
7288 if (TYPE_UNSIGNED (type
))
7289 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
7291 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
7292 TREE_TYPE (typefm
) = type
;
7295 else if (VECTOR_MODE_P (mode
)
7296 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
7297 : TREE_CODE (type
) != TREE_CODE (typefm
))
7299 error ("mode %qs applied to inappropriate type", p
);
7309 /* Handle a "section" attribute; arguments as in
7310 struct attribute_spec.handler. */
7313 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
7314 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7318 if (targetm_common
.have_named_sections
)
7320 user_defined_section_attribute
= true;
7322 if ((TREE_CODE (decl
) == FUNCTION_DECL
7323 || TREE_CODE (decl
) == VAR_DECL
)
7324 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
7326 if (TREE_CODE (decl
) == VAR_DECL
7327 && current_function_decl
!= NULL_TREE
7328 && !TREE_STATIC (decl
))
7330 error_at (DECL_SOURCE_LOCATION (decl
),
7331 "section attribute cannot be specified for "
7333 *no_add_attrs
= true;
7336 /* The decl may have already been given a section attribute
7337 from a previous declaration. Ensure they match. */
7338 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
7339 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
7340 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
7342 error ("section of %q+D conflicts with previous declaration",
7344 *no_add_attrs
= true;
7346 else if (TREE_CODE (decl
) == VAR_DECL
7347 && !targetm
.have_tls
&& targetm
.emutls
.tmpl_section
7348 && DECL_THREAD_LOCAL_P (decl
))
7350 error ("section of %q+D cannot be overridden", *node
);
7351 *no_add_attrs
= true;
7354 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
7358 error ("section attribute not allowed for %q+D", *node
);
7359 *no_add_attrs
= true;
7364 error_at (DECL_SOURCE_LOCATION (*node
),
7365 "section attributes are not supported for this target");
7366 *no_add_attrs
= true;
7372 /* Check whether ALIGN is a valid user-specified alignment. If so,
7373 return its base-2 log; if not, output an error and return -1. If
7374 ALLOW_ZERO then 0 is valid and should result in a return of -1 with
7377 check_user_alignment (const_tree align
, bool allow_zero
)
7381 if (TREE_CODE (align
) != INTEGER_CST
7382 || !INTEGRAL_TYPE_P (TREE_TYPE (align
)))
7384 error ("requested alignment is not an integer constant");
7387 else if (allow_zero
&& integer_zerop (align
))
7389 else if (tree_int_cst_sgn (align
) == -1
7390 || (i
= tree_log2 (align
)) == -1)
7392 error ("requested alignment is not a positive power of 2");
7395 else if (i
>= HOST_BITS_PER_INT
- BITS_PER_UNIT_LOG
)
7397 error ("requested alignment is too large");
7404 If in c++-11, check if the c++-11 alignment constraint with respect
7405 to fundamental alignment (in [dcl.align]) are satisfied. If not in
7406 c++-11 mode, does nothing.
7410 [* if the constant expression evaluates to a fundamental alignment,
7411 the alignment requirement of the declared entity shall be the
7412 specified fundamental alignment.
7414 * if the constant expression evaluates to an extended alignment
7415 and the implementation supports that alignment in the context
7416 of the declaration, the alignment of the declared entity shall
7419 * if the constant expression evaluates to an extended alignment
7420 and the implementation does not support that alignment in the
7421 context of the declaration, the program is ill-formed]. */
7424 check_cxx_fundamental_alignment_constraints (tree node
,
7428 bool alignment_too_large_p
= false;
7429 unsigned requested_alignment
= 1U << align_log
;
7430 unsigned max_align
= 0;
7432 if ((!(flags
& ATTR_FLAG_CXX11
) && !warn_cxx_compat
)
7433 || (node
== NULL_TREE
|| node
== error_mark_node
))
7436 if (cxx_fundamental_alignment_p (requested_alignment
))
7441 if (TREE_STATIC (node
))
7443 /* For file scope variables and static members, the target
7444 supports alignments that are at most
7445 MAX_OFILE_ALIGNMENT. */
7446 if (requested_alignment
> (max_align
= MAX_OFILE_ALIGNMENT
))
7447 alignment_too_large_p
= true;
7451 #ifdef BIGGEST_FIELD_ALIGNMENT
7452 #define MAX_TARGET_FIELD_ALIGNMENT BIGGEST_FIELD_ALIGNMENT
7454 #define MAX_TARGET_FIELD_ALIGNMENT BIGGEST_ALIGNMENT
7456 /* For non-static members, the target supports either
7457 alignments that at most either BIGGEST_FIELD_ALIGNMENT
7458 if it is defined or BIGGEST_ALIGNMENT. */
7459 max_align
= MAX_TARGET_FIELD_ALIGNMENT
;
7460 if (TREE_CODE (node
) == FIELD_DECL
7461 && requested_alignment
> (max_align
= MAX_TARGET_FIELD_ALIGNMENT
))
7462 alignment_too_large_p
= true;
7463 #undef MAX_TARGET_FIELD_ALIGNMENT
7464 /* For stack variables, the target supports at most
7465 MAX_STACK_ALIGNMENT. */
7466 else if (decl_function_context (node
) != NULL
7467 && requested_alignment
> (max_align
= MAX_STACK_ALIGNMENT
))
7468 alignment_too_large_p
= true;
7471 else if (TYPE_P (node
))
7473 /* Let's be liberal for types. */
7474 if (requested_alignment
> (max_align
= BIGGEST_ALIGNMENT
))
7475 alignment_too_large_p
= true;
7478 if (alignment_too_large_p
)
7479 pedwarn (input_location
, OPT_Wattributes
,
7480 "requested alignment %d is larger than %d",
7481 requested_alignment
, max_align
);
7483 return !alignment_too_large_p
;
7486 /* Handle a "aligned" attribute; arguments as in
7487 struct attribute_spec.handler. */
7490 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
7491 int flags
, bool *no_add_attrs
)
7493 tree decl
= NULL_TREE
;
7496 tree align_expr
= (args
? TREE_VALUE (args
)
7497 : size_int (ATTRIBUTE_ALIGNED_VALUE
/ BITS_PER_UNIT
));
7503 type
= &TREE_TYPE (decl
);
7504 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
7506 else if (TYPE_P (*node
))
7507 type
= node
, is_type
= 1;
7509 if ((i
= check_user_alignment (align_expr
, false)) == -1
7510 || !check_cxx_fundamental_alignment_constraints (*node
, i
, flags
))
7511 *no_add_attrs
= true;
7514 if ((flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
7515 /* OK, modify the type in place. */;
7516 /* If we have a TYPE_DECL, then copy the type, so that we
7517 don't accidentally modify a builtin type. See pushdecl. */
7518 else if (decl
&& TREE_TYPE (decl
) != error_mark_node
7519 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
7521 tree tt
= TREE_TYPE (decl
);
7522 *type
= build_variant_type_copy (*type
);
7523 DECL_ORIGINAL_TYPE (decl
) = tt
;
7524 TYPE_NAME (*type
) = decl
;
7525 TREE_USED (*type
) = TREE_USED (decl
);
7526 TREE_TYPE (decl
) = *type
;
7529 *type
= build_variant_type_copy (*type
);
7531 TYPE_ALIGN (*type
) = (1U << i
) * BITS_PER_UNIT
;
7532 TYPE_USER_ALIGN (*type
) = 1;
7534 else if (! VAR_OR_FUNCTION_DECL_P (decl
)
7535 && TREE_CODE (decl
) != FIELD_DECL
)
7537 error ("alignment may not be specified for %q+D", decl
);
7538 *no_add_attrs
= true;
7540 else if (DECL_USER_ALIGN (decl
)
7541 && DECL_ALIGN (decl
) > (1U << i
) * BITS_PER_UNIT
)
7542 /* C++-11 [dcl.align/4]:
7544 When multiple alignment-specifiers are specified for an
7545 entity, the alignment requirement shall be set to the
7546 strictest specified alignment.
7548 This formally comes from the c++11 specification but we are
7549 doing it for the GNU attribute syntax as well. */
7550 *no_add_attrs
= true;
7551 else if (TREE_CODE (decl
) == FUNCTION_DECL
7552 && DECL_ALIGN (decl
) > (1U << i
) * BITS_PER_UNIT
)
7554 if (DECL_USER_ALIGN (decl
))
7555 error ("alignment for %q+D was previously specified as %d "
7556 "and may not be decreased", decl
,
7557 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
7559 error ("alignment for %q+D must be at least %d", decl
,
7560 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
7561 *no_add_attrs
= true;
7565 DECL_ALIGN (decl
) = (1U << i
) * BITS_PER_UNIT
;
7566 DECL_USER_ALIGN (decl
) = 1;
7572 /* Handle a "weak" attribute; arguments as in
7573 struct attribute_spec.handler. */
7576 handle_weak_attribute (tree
*node
, tree name
,
7577 tree
ARG_UNUSED (args
),
7578 int ARG_UNUSED (flags
),
7579 bool * ARG_UNUSED (no_add_attrs
))
7581 if (TREE_CODE (*node
) == FUNCTION_DECL
7582 && DECL_DECLARED_INLINE_P (*node
))
7584 warning (OPT_Wattributes
, "inline function %q+D declared weak", *node
);
7585 *no_add_attrs
= true;
7587 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node
)))
7589 error ("indirect function %q+D cannot be declared weak", *node
);
7590 *no_add_attrs
= true;
7593 else if (TREE_CODE (*node
) == FUNCTION_DECL
7594 || TREE_CODE (*node
) == VAR_DECL
)
7595 declare_weak (*node
);
7597 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7602 /* Handle an "alias" or "ifunc" attribute; arguments as in
7603 struct attribute_spec.handler, except that IS_ALIAS tells us
7604 whether this is an alias as opposed to ifunc attribute. */
7607 handle_alias_ifunc_attribute (bool is_alias
, tree
*node
, tree name
, tree args
,
7612 if (TREE_CODE (decl
) != FUNCTION_DECL
7613 && (!is_alias
|| TREE_CODE (decl
) != VAR_DECL
))
7615 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7616 *no_add_attrs
= true;
7618 else if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
7619 || (TREE_CODE (decl
) != FUNCTION_DECL
7620 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
7621 /* A static variable declaration is always a tentative definition,
7622 but the alias is a non-tentative definition which overrides. */
7623 || (TREE_CODE (decl
) != FUNCTION_DECL
7624 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
7626 error ("%q+D defined both normally and as %qE attribute", decl
, name
);
7627 *no_add_attrs
= true;
7631 && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl
))
7632 || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))))
7634 error ("weak %q+D cannot be defined %qE", decl
, name
);
7635 *no_add_attrs
= true;
7639 /* Note that the very first time we process a nested declaration,
7640 decl_function_context will not be set. Indeed, *would* never
7641 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
7642 we do below. After such frobbery, pushdecl would set the context.
7643 In any case, this is never what we want. */
7644 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
7648 id
= TREE_VALUE (args
);
7649 if (TREE_CODE (id
) != STRING_CST
)
7651 error ("attribute %qE argument not a string", name
);
7652 *no_add_attrs
= true;
7655 id
= get_identifier (TREE_STRING_POINTER (id
));
7656 /* This counts as a use of the object pointed to. */
7659 if (TREE_CODE (decl
) == FUNCTION_DECL
)
7660 DECL_INITIAL (decl
) = error_mark_node
;
7662 TREE_STATIC (decl
) = 1;
7665 /* ifuncs are also aliases, so set that attribute too. */
7666 DECL_ATTRIBUTES (decl
)
7667 = tree_cons (get_identifier ("alias"), args
, DECL_ATTRIBUTES (decl
));
7671 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7672 *no_add_attrs
= true;
7678 /* Handle an "alias" or "ifunc" attribute; arguments as in
7679 struct attribute_spec.handler. */
7682 handle_ifunc_attribute (tree
*node
, tree name
, tree args
,
7683 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7685 return handle_alias_ifunc_attribute (false, node
, name
, args
, no_add_attrs
);
7688 /* Handle an "alias" or "ifunc" attribute; arguments as in
7689 struct attribute_spec.handler. */
7692 handle_alias_attribute (tree
*node
, tree name
, tree args
,
7693 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7695 return handle_alias_ifunc_attribute (true, node
, name
, args
, no_add_attrs
);
7698 /* Handle a "weakref" attribute; arguments as in struct
7699 attribute_spec.handler. */
7702 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
7703 int flags
, bool *no_add_attrs
)
7705 tree attr
= NULL_TREE
;
7707 /* We must ignore the attribute when it is associated with
7708 local-scoped decls, since attribute alias is ignored and many
7709 such symbols do not even have a DECL_WEAK field. */
7710 if (decl_function_context (*node
)
7711 || current_function_decl
7712 || (TREE_CODE (*node
) != VAR_DECL
&& TREE_CODE (*node
) != FUNCTION_DECL
))
7714 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7715 *no_add_attrs
= true;
7719 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node
)))
7721 error ("indirect function %q+D cannot be declared weakref", *node
);
7722 *no_add_attrs
= true;
7726 /* The idea here is that `weakref("name")' mutates into `weakref,
7727 alias("name")', and weakref without arguments, in turn,
7728 implicitly adds weak. */
7732 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
7733 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
7735 *no_add_attrs
= true;
7737 decl_attributes (node
, attr
, flags
);
7741 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
7742 error_at (DECL_SOURCE_LOCATION (*node
),
7743 "weakref attribute must appear before alias attribute");
7745 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
7746 and that isn't supported; and because it wants to add it to
7747 the list of weak decls, which isn't helpful. */
7748 DECL_WEAK (*node
) = 1;
7754 /* Handle an "visibility" attribute; arguments as in
7755 struct attribute_spec.handler. */
7758 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
7759 int ARG_UNUSED (flags
),
7760 bool *ARG_UNUSED (no_add_attrs
))
7763 tree id
= TREE_VALUE (args
);
7764 enum symbol_visibility vis
;
7768 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
7770 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
7772 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
7776 else if (TYPE_FIELDS (*node
))
7778 error ("%qE attribute ignored because %qT is already defined",
7783 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
7785 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7789 if (TREE_CODE (id
) != STRING_CST
)
7791 error ("visibility argument not a string");
7795 /* If this is a type, set the visibility on the type decl. */
7798 decl
= TYPE_NAME (decl
);
7801 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
7803 warning (OPT_Wattributes
, "%qE attribute ignored on types",
7809 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
7810 vis
= VISIBILITY_DEFAULT
;
7811 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
7812 vis
= VISIBILITY_INTERNAL
;
7813 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
7814 vis
= VISIBILITY_HIDDEN
;
7815 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
7816 vis
= VISIBILITY_PROTECTED
;
7819 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
7820 vis
= VISIBILITY_DEFAULT
;
7823 if (DECL_VISIBILITY_SPECIFIED (decl
)
7824 && vis
!= DECL_VISIBILITY (decl
))
7826 tree attributes
= (TYPE_P (*node
)
7827 ? TYPE_ATTRIBUTES (*node
)
7828 : DECL_ATTRIBUTES (decl
));
7829 if (lookup_attribute ("visibility", attributes
))
7830 error ("%qD redeclared with different visibility", decl
);
7831 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
7832 && lookup_attribute ("dllimport", attributes
))
7833 error ("%qD was declared %qs which implies default visibility",
7835 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
7836 && lookup_attribute ("dllexport", attributes
))
7837 error ("%qD was declared %qs which implies default visibility",
7841 DECL_VISIBILITY (decl
) = vis
;
7842 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
7844 /* Go ahead and attach the attribute to the node as well. This is needed
7845 so we can determine whether we have VISIBILITY_DEFAULT because the
7846 visibility was not specified, or because it was explicitly overridden
7847 from the containing scope. */
7852 /* Determine the ELF symbol visibility for DECL, which is either a
7853 variable or a function. It is an error to use this function if a
7854 definition of DECL is not available in this translation unit.
7855 Returns true if the final visibility has been determined by this
7856 function; false if the caller is free to make additional
7860 c_determine_visibility (tree decl
)
7862 gcc_assert (TREE_CODE (decl
) == VAR_DECL
7863 || TREE_CODE (decl
) == FUNCTION_DECL
);
7865 /* If the user explicitly specified the visibility with an
7866 attribute, honor that. DECL_VISIBILITY will have been set during
7867 the processing of the attribute. We check for an explicit
7868 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
7869 to distinguish the use of an attribute from the use of a "#pragma
7870 GCC visibility push(...)"; in the latter case we still want other
7871 considerations to be able to overrule the #pragma. */
7872 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
7873 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
7874 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
7875 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
7878 /* Set default visibility to whatever the user supplied with
7879 visibility_specified depending on #pragma GCC visibility. */
7880 if (!DECL_VISIBILITY_SPECIFIED (decl
))
7882 if (visibility_options
.inpragma
7883 || DECL_VISIBILITY (decl
) != default_visibility
)
7885 DECL_VISIBILITY (decl
) = default_visibility
;
7886 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
7887 /* If visibility changed and DECL already has DECL_RTL, ensure
7888 symbol flags are updated. */
7889 if (((TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
7890 || TREE_CODE (decl
) == FUNCTION_DECL
)
7891 && DECL_RTL_SET_P (decl
))
7892 make_decl_rtl (decl
);
7898 /* Handle an "tls_model" attribute; arguments as in
7899 struct attribute_spec.handler. */
7902 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
7903 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7907 enum tls_model kind
;
7909 *no_add_attrs
= true;
7911 if (TREE_CODE (decl
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (decl
))
7913 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7917 kind
= DECL_TLS_MODEL (decl
);
7918 id
= TREE_VALUE (args
);
7919 if (TREE_CODE (id
) != STRING_CST
)
7921 error ("tls_model argument not a string");
7925 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
7926 kind
= TLS_MODEL_LOCAL_EXEC
;
7927 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
7928 kind
= TLS_MODEL_INITIAL_EXEC
;
7929 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
7930 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
7931 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
7932 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
7934 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7936 DECL_TLS_MODEL (decl
) = kind
;
7940 /* Handle a "no_instrument_function" attribute; arguments as in
7941 struct attribute_spec.handler. */
7944 handle_no_instrument_function_attribute (tree
*node
, tree name
,
7945 tree
ARG_UNUSED (args
),
7946 int ARG_UNUSED (flags
),
7951 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7953 error_at (DECL_SOURCE_LOCATION (decl
),
7954 "%qE attribute applies only to functions", name
);
7955 *no_add_attrs
= true;
7957 else if (DECL_INITIAL (decl
))
7959 error_at (DECL_SOURCE_LOCATION (decl
),
7960 "can%'t set %qE attribute after definition", name
);
7961 *no_add_attrs
= true;
7964 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
7969 /* Handle a "malloc" attribute; arguments as in
7970 struct attribute_spec.handler. */
7973 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7974 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7976 if (TREE_CODE (*node
) == FUNCTION_DECL
7977 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
7978 DECL_IS_MALLOC (*node
) = 1;
7981 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7982 *no_add_attrs
= true;
7988 /* Handle a "alloc_size" attribute; arguments as in
7989 struct attribute_spec.handler. */
7992 handle_alloc_size_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
7993 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7995 unsigned arg_count
= type_num_arguments (*node
);
7996 for (; args
; args
= TREE_CHAIN (args
))
7998 tree position
= TREE_VALUE (args
);
8000 if (TREE_CODE (position
) != INTEGER_CST
8001 || TREE_INT_CST_HIGH (position
)
8002 || TREE_INT_CST_LOW (position
) < 1
8003 || TREE_INT_CST_LOW (position
) > arg_count
)
8005 warning (OPT_Wattributes
,
8006 "alloc_size parameter outside range");
8007 *no_add_attrs
= true;
8014 /* Handle a "fn spec" attribute; arguments as in
8015 struct attribute_spec.handler. */
8018 handle_fnspec_attribute (tree
*node ATTRIBUTE_UNUSED
, tree
ARG_UNUSED (name
),
8019 tree args
, int ARG_UNUSED (flags
),
8020 bool *no_add_attrs ATTRIBUTE_UNUSED
)
8023 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
8024 && !TREE_CHAIN (args
));
8028 /* Handle a "bnd_variable_size" attribute; arguments as in
8029 struct attribute_spec.handler. */
8032 handle_bnd_variable_size_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
8033 int ARG_UNUSED (flags
), bool *no_add_attrs
)
8035 if (TREE_CODE (*node
) != FIELD_DECL
)
8037 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8038 *no_add_attrs
= true;
8044 /* Handle a "bnd_legacy" attribute; arguments as in
8045 struct attribute_spec.handler. */
8048 handle_bnd_legacy (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
8049 int ARG_UNUSED (flags
), bool *no_add_attrs
)
8051 if (TREE_CODE (*node
) != FUNCTION_DECL
)
8053 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8054 *no_add_attrs
= true;
8060 /* Handle a "warn_unused" attribute; arguments as in
8061 struct attribute_spec.handler. */
8064 handle_warn_unused_attribute (tree
*node
, tree name
,
8065 tree args ATTRIBUTE_UNUSED
,
8066 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
8069 /* Do nothing else, just set the attribute. We'll get at
8070 it later with lookup_attribute. */
8074 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8075 *no_add_attrs
= true;
8081 /* Handle an "omp declare simd" attribute; arguments as in
8082 struct attribute_spec.handler. */
8085 handle_omp_declare_simd_attribute (tree
*, tree
, tree
, int, bool *)
8090 /* Handle an "omp declare target" attribute; arguments as in
8091 struct attribute_spec.handler. */
8094 handle_omp_declare_target_attribute (tree
*, tree
, tree
, int, bool *)
8099 /* Handle a "returns_twice" attribute; arguments as in
8100 struct attribute_spec.handler. */
8103 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
8104 int ARG_UNUSED (flags
), bool *no_add_attrs
)
8106 if (TREE_CODE (*node
) == FUNCTION_DECL
)
8107 DECL_IS_RETURNS_TWICE (*node
) = 1;
8110 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8111 *no_add_attrs
= true;
8117 /* Handle a "no_limit_stack" attribute; arguments as in
8118 struct attribute_spec.handler. */
8121 handle_no_limit_stack_attribute (tree
*node
, tree name
,
8122 tree
ARG_UNUSED (args
),
8123 int ARG_UNUSED (flags
),
8128 if (TREE_CODE (decl
) != FUNCTION_DECL
)
8130 error_at (DECL_SOURCE_LOCATION (decl
),
8131 "%qE attribute applies only to functions", name
);
8132 *no_add_attrs
= true;
8134 else if (DECL_INITIAL (decl
))
8136 error_at (DECL_SOURCE_LOCATION (decl
),
8137 "can%'t set %qE attribute after definition", name
);
8138 *no_add_attrs
= true;
8141 DECL_NO_LIMIT_STACK (decl
) = 1;
8146 /* Handle a "pure" attribute; arguments as in
8147 struct attribute_spec.handler. */
8150 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
8151 int ARG_UNUSED (flags
), bool *no_add_attrs
)
8153 if (TREE_CODE (*node
) == FUNCTION_DECL
)
8154 DECL_PURE_P (*node
) = 1;
8155 /* ??? TODO: Support types. */
8158 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8159 *no_add_attrs
= true;
8165 /* Digest an attribute list destined for a transactional memory statement.
8166 ALLOWED is the set of attributes that are allowed for this statement;
8167 return the attribute we parsed. Multiple attributes are never allowed. */
8170 parse_tm_stmt_attr (tree attrs
, int allowed
)
8175 for ( ; attrs
; attrs
= TREE_CHAIN (attrs
))
8177 tree a
= TREE_PURPOSE (attrs
);
8180 if (is_attribute_p ("outer", a
))
8181 m
= TM_STMT_ATTR_OUTER
;
8183 if ((m
& allowed
) == 0)
8185 warning (OPT_Wattributes
, "%qE attribute directive ignored", a
);
8194 else if (m_seen
== m
)
8195 warning (OPT_Wattributes
, "%qE attribute duplicated", a
);
8197 warning (OPT_Wattributes
, "%qE attribute follows %qE", a
, a_seen
);
8203 /* Transform a TM attribute name into a maskable integer and back.
8204 Note that NULL (i.e. no attribute) is mapped to UNKNOWN, corresponding
8205 to how the lack of an attribute is treated. */
8208 tm_attr_to_mask (tree attr
)
8212 if (is_attribute_p ("transaction_safe", attr
))
8213 return TM_ATTR_SAFE
;
8214 if (is_attribute_p ("transaction_callable", attr
))
8215 return TM_ATTR_CALLABLE
;
8216 if (is_attribute_p ("transaction_pure", attr
))
8217 return TM_ATTR_PURE
;
8218 if (is_attribute_p ("transaction_unsafe", attr
))
8219 return TM_ATTR_IRREVOCABLE
;
8220 if (is_attribute_p ("transaction_may_cancel_outer", attr
))
8221 return TM_ATTR_MAY_CANCEL_OUTER
;
8226 tm_mask_to_attr (int mask
)
8232 str
= "transaction_safe";
8234 case TM_ATTR_CALLABLE
:
8235 str
= "transaction_callable";
8238 str
= "transaction_pure";
8240 case TM_ATTR_IRREVOCABLE
:
8241 str
= "transaction_unsafe";
8243 case TM_ATTR_MAY_CANCEL_OUTER
:
8244 str
= "transaction_may_cancel_outer";
8249 return get_identifier (str
);
8252 /* Return the first TM attribute seen in LIST. */
8255 find_tm_attribute (tree list
)
8257 for (; list
; list
= TREE_CHAIN (list
))
8259 tree name
= TREE_PURPOSE (list
);
8260 if (tm_attr_to_mask (name
) != 0)
8266 /* Handle the TM attributes; arguments as in struct attribute_spec.handler.
8267 Here we accept only function types, and verify that none of the other
8268 function TM attributes are also applied. */
8269 /* ??? We need to accept class types for C++, but not C. This greatly
8270 complicates this function, since we can no longer rely on the extra
8271 processing given by function_type_required. */
8274 handle_tm_attribute (tree
*node
, tree name
, tree args
,
8275 int flags
, bool *no_add_attrs
)
8277 /* Only one path adds the attribute; others don't. */
8278 *no_add_attrs
= true;
8280 switch (TREE_CODE (*node
))
8284 /* Only tm_callable and tm_safe apply to classes. */
8285 if (tm_attr_to_mask (name
) & ~(TM_ATTR_SAFE
| TM_ATTR_CALLABLE
))
8292 tree old_name
= find_tm_attribute (TYPE_ATTRIBUTES (*node
));
8293 if (old_name
== name
)
8295 else if (old_name
!= NULL_TREE
)
8296 error ("type was previously declared %qE", old_name
);
8298 *no_add_attrs
= false;
8304 enum tree_code subcode
= TREE_CODE (TREE_TYPE (*node
));
8305 if (subcode
== FUNCTION_TYPE
|| subcode
== METHOD_TYPE
)
8307 tree fn_tmp
= TREE_TYPE (*node
);
8308 decl_attributes (&fn_tmp
, tree_cons (name
, args
, NULL
), 0);
8309 *node
= build_pointer_type (fn_tmp
);
8316 /* If a function is next, pass it on to be tried next. */
8317 if (flags
& (int) ATTR_FLAG_FUNCTION_NEXT
)
8318 return tree_cons (name
, args
, NULL
);
8321 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8328 /* Handle the TM_WRAP attribute; arguments as in
8329 struct attribute_spec.handler. */
8332 handle_tm_wrap_attribute (tree
*node
, tree name
, tree args
,
8333 int ARG_UNUSED (flags
), bool *no_add_attrs
)
8337 /* We don't need the attribute even on success, since we
8338 record the entry in an external table. */
8339 *no_add_attrs
= true;
8341 if (TREE_CODE (decl
) != FUNCTION_DECL
)
8342 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8345 tree wrap_decl
= TREE_VALUE (args
);
8346 if (TREE_CODE (wrap_decl
) != IDENTIFIER_NODE
8347 && TREE_CODE (wrap_decl
) != VAR_DECL
8348 && TREE_CODE (wrap_decl
) != FUNCTION_DECL
)
8349 error ("%qE argument not an identifier", name
);
8352 if (TREE_CODE (wrap_decl
) == IDENTIFIER_NODE
)
8353 wrap_decl
= lookup_name (wrap_decl
);
8354 if (wrap_decl
&& TREE_CODE (wrap_decl
) == FUNCTION_DECL
)
8356 if (lang_hooks
.types_compatible_p (TREE_TYPE (decl
),
8357 TREE_TYPE (wrap_decl
)))
8358 record_tm_replacement (wrap_decl
, decl
);
8360 error ("%qD is not compatible with %qD", wrap_decl
, decl
);
8363 error ("transaction_wrap argument is not a function");
8370 /* Ignore the given attribute. Used when this attribute may be usefully
8371 overridden by the target, but is not used generically. */
8374 ignore_attribute (tree
* ARG_UNUSED (node
), tree
ARG_UNUSED (name
),
8375 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
8378 *no_add_attrs
= true;
8382 /* Handle a "no vops" attribute; arguments as in
8383 struct attribute_spec.handler. */
8386 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
8387 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
8388 bool *ARG_UNUSED (no_add_attrs
))
8390 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
8391 DECL_IS_NOVOPS (*node
) = 1;
8395 /* Handle a "deprecated" attribute; arguments as in
8396 struct attribute_spec.handler. */
8399 handle_deprecated_attribute (tree
*node
, tree name
,
8400 tree args
, int flags
,
8403 tree type
= NULL_TREE
;
8405 tree what
= NULL_TREE
;
8408 *no_add_attrs
= true;
8409 else if (TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
8411 error ("deprecated message is not a string");
8412 *no_add_attrs
= true;
8418 type
= TREE_TYPE (decl
);
8420 if (TREE_CODE (decl
) == TYPE_DECL
8421 || TREE_CODE (decl
) == PARM_DECL
8422 || TREE_CODE (decl
) == VAR_DECL
8423 || TREE_CODE (decl
) == FUNCTION_DECL
8424 || TREE_CODE (decl
) == FIELD_DECL
8425 || objc_method_decl (TREE_CODE (decl
)))
8426 TREE_DEPRECATED (decl
) = 1;
8430 else if (TYPE_P (*node
))
8432 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
8433 *node
= build_variant_type_copy (*node
);
8434 TREE_DEPRECATED (*node
) = 1;
8442 *no_add_attrs
= true;
8443 if (type
&& TYPE_NAME (type
))
8445 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
8446 what
= TYPE_NAME (*node
);
8447 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8448 && DECL_NAME (TYPE_NAME (type
)))
8449 what
= DECL_NAME (TYPE_NAME (type
));
8452 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
8454 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8460 /* Handle a "vector_size" attribute; arguments as in
8461 struct attribute_spec.handler. */
8464 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
8465 int ARG_UNUSED (flags
),
8468 unsigned HOST_WIDE_INT vecsize
, nunits
;
8469 enum machine_mode orig_mode
;
8470 tree type
= *node
, new_type
, size
;
8472 *no_add_attrs
= true;
8474 size
= TREE_VALUE (args
);
8476 if (!host_integerp (size
, 1))
8478 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8482 /* Get the vector size (in bytes). */
8483 vecsize
= tree_low_cst (size
, 1);
8485 /* We need to provide for vector pointers, vector arrays, and
8486 functions returning vectors. For example:
8488 __attribute__((vector_size(16))) short *foo;
8490 In this case, the mode is SI, but the type being modified is
8491 HI, so we need to look further. */
8493 while (POINTER_TYPE_P (type
)
8494 || TREE_CODE (type
) == FUNCTION_TYPE
8495 || TREE_CODE (type
) == METHOD_TYPE
8496 || TREE_CODE (type
) == ARRAY_TYPE
8497 || TREE_CODE (type
) == OFFSET_TYPE
)
8498 type
= TREE_TYPE (type
);
8500 /* Get the mode of the type being modified. */
8501 orig_mode
= TYPE_MODE (type
);
8503 if ((!INTEGRAL_TYPE_P (type
)
8504 && !SCALAR_FLOAT_TYPE_P (type
)
8505 && !FIXED_POINT_TYPE_P (type
))
8506 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
8507 && GET_MODE_CLASS (orig_mode
) != MODE_INT
8508 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode
))
8509 || !host_integerp (TYPE_SIZE_UNIT (type
), 1)
8510 || TREE_CODE (type
) == BOOLEAN_TYPE
)
8512 error ("invalid vector type for attribute %qE", name
);
8516 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
8518 error ("vector size not an integral multiple of component size");
8524 error ("zero vector size");
8528 /* Calculate how many units fit in the vector. */
8529 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
8530 if (nunits
& (nunits
- 1))
8532 error ("number of components of the vector not a power of two");
8536 new_type
= build_vector_type (type
, nunits
);
8538 /* Build back pointers if needed. */
8539 *node
= lang_hooks
.types
.reconstruct_complex_type (*node
, new_type
);
8544 /* Handle the "nonnull" attribute. */
8546 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
8547 tree args
, int ARG_UNUSED (flags
),
8551 unsigned HOST_WIDE_INT attr_arg_num
;
8553 /* If no arguments are specified, all pointer arguments should be
8554 non-null. Verify a full prototype is given so that the arguments
8555 will have the correct types when we actually check them later. */
8558 if (!prototype_p (type
))
8560 error ("nonnull attribute without arguments on a non-prototype");
8561 *no_add_attrs
= true;
8566 /* Argument list specified. Verify that each argument number references
8567 a pointer argument. */
8568 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
8570 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
8572 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
8574 error ("nonnull argument has invalid operand number (argument %lu)",
8575 (unsigned long) attr_arg_num
);
8576 *no_add_attrs
= true;
8580 if (prototype_p (type
))
8582 function_args_iterator iter
;
8585 function_args_iter_init (&iter
, type
);
8586 for (ck_num
= 1; ; ck_num
++, function_args_iter_next (&iter
))
8588 argument
= function_args_iter_cond (&iter
);
8589 if (argument
== NULL_TREE
|| ck_num
== arg_num
)
8594 || TREE_CODE (argument
) == VOID_TYPE
)
8596 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
8597 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
8598 *no_add_attrs
= true;
8602 if (TREE_CODE (argument
) != POINTER_TYPE
)
8604 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
8605 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
8606 *no_add_attrs
= true;
8615 /* Check the argument list of a function call for null in argument slots
8616 that are marked as requiring a non-null pointer argument. The NARGS
8617 arguments are passed in the array ARGARRAY.
8621 check_function_nonnull (tree attrs
, int nargs
, tree
*argarray
)
8626 attrs
= lookup_attribute ("nonnull", attrs
);
8627 if (attrs
== NULL_TREE
)
8631 /* See if any of the nonnull attributes has no arguments. If so,
8632 then every pointer argument is checked (in which case the check
8633 for pointer type is done in check_nonnull_arg). */
8634 if (TREE_VALUE (a
) != NULL_TREE
)
8636 a
= lookup_attribute ("nonnull", TREE_CHAIN (a
));
8637 while (a
!= NULL_TREE
&& TREE_VALUE (a
) != NULL_TREE
);
8640 for (i
= 0; i
< nargs
; i
++)
8641 check_function_arguments_recurse (check_nonnull_arg
, NULL
, argarray
[i
],
8645 /* Walk the argument list. If we encounter an argument number we
8646 should check for non-null, do it. */
8647 for (i
= 0; i
< nargs
; i
++)
8649 for (a
= attrs
; ; a
= TREE_CHAIN (a
))
8651 a
= lookup_attribute ("nonnull", a
);
8652 if (a
== NULL_TREE
|| nonnull_check_p (TREE_VALUE (a
), i
+ 1))
8657 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
8658 argarray
[i
], i
+ 1);
8663 /* Check that the Nth argument of a function call (counting backwards
8664 from the end) is a (pointer)0. The NARGS arguments are passed in the
8668 check_function_sentinel (const_tree fntype
, int nargs
, tree
*argarray
)
8670 tree attr
= lookup_attribute ("sentinel", TYPE_ATTRIBUTES (fntype
));
8677 function_args_iterator iter
;
8680 /* Skip over the named arguments. */
8681 FOREACH_FUNCTION_ARGS (fntype
, t
, iter
)
8688 if (TREE_VALUE (attr
))
8690 tree p
= TREE_VALUE (TREE_VALUE (attr
));
8691 pos
= TREE_INT_CST_LOW (p
);
8694 /* The sentinel must be one of the varargs, i.e.
8695 in position >= the number of fixed arguments. */
8696 if ((nargs
- 1 - pos
) < len
)
8698 warning (OPT_Wformat_
,
8699 "not enough variable arguments to fit a sentinel");
8703 /* Validate the sentinel. */
8704 sentinel
= argarray
[nargs
- 1 - pos
];
8705 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
8706 || !integer_zerop (sentinel
))
8707 /* Although __null (in C++) is only an integer we allow it
8708 nevertheless, as we are guaranteed that it's exactly
8709 as wide as a pointer, and we don't want to force
8710 users to cast the NULL they have written there.
8711 We warn with -Wstrict-null-sentinel, though. */
8712 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
8713 warning (OPT_Wformat_
, "missing sentinel in function call");
8717 /* Helper for check_function_nonnull; given a list of operands which
8718 must be non-null in ARGS, determine if operand PARAM_NUM should be
8722 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
8724 unsigned HOST_WIDE_INT arg_num
= 0;
8726 for (; args
; args
= TREE_CHAIN (args
))
8728 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
8732 if (arg_num
== param_num
)
8738 /* Check that the function argument PARAM (which is operand number
8739 PARAM_NUM) is non-null. This is called by check_function_nonnull
8740 via check_function_arguments_recurse. */
8743 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
8744 unsigned HOST_WIDE_INT param_num
)
8746 /* Just skip checking the argument if it's not a pointer. This can
8747 happen if the "nonnull" attribute was given without an operand
8748 list (which means to check every pointer argument). */
8750 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
8753 if (integer_zerop (param
))
8754 warning (OPT_Wnonnull
, "null argument where non-null required "
8755 "(argument %lu)", (unsigned long) param_num
);
8758 /* Helper for nonnull attribute handling; fetch the operand number
8759 from the attribute argument list. */
8762 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
8764 /* Verify the arg number is a constant. */
8765 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
8766 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
8769 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
8773 /* Handle a "nothrow" attribute; arguments as in
8774 struct attribute_spec.handler. */
8777 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
8778 int ARG_UNUSED (flags
), bool *no_add_attrs
)
8780 if (TREE_CODE (*node
) == FUNCTION_DECL
)
8781 TREE_NOTHROW (*node
) = 1;
8782 /* ??? TODO: Support types. */
8785 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8786 *no_add_attrs
= true;
8792 /* Handle a "cleanup" attribute; arguments as in
8793 struct attribute_spec.handler. */
8796 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
8797 int ARG_UNUSED (flags
), bool *no_add_attrs
)
8800 tree cleanup_id
, cleanup_decl
;
8802 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
8803 for global destructors in C++. This requires infrastructure that
8804 we don't have generically at the moment. It's also not a feature
8805 we'd be missing too much, since we do have attribute constructor. */
8806 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
8808 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8809 *no_add_attrs
= true;
8813 /* Verify that the argument is a function in scope. */
8814 /* ??? We could support pointers to functions here as well, if
8815 that was considered desirable. */
8816 cleanup_id
= TREE_VALUE (args
);
8817 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
8819 error ("cleanup argument not an identifier");
8820 *no_add_attrs
= true;
8823 cleanup_decl
= lookup_name (cleanup_id
);
8824 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
8826 error ("cleanup argument not a function");
8827 *no_add_attrs
= true;
8831 /* That the function has proper type is checked with the
8832 eventual call to build_function_call. */
8837 /* Handle a "warn_unused_result" attribute. No special handling. */
8840 handle_warn_unused_result_attribute (tree
*node
, tree name
,
8841 tree
ARG_UNUSED (args
),
8842 int ARG_UNUSED (flags
), bool *no_add_attrs
)
8844 /* Ignore the attribute for functions not returning any value. */
8845 if (VOID_TYPE_P (TREE_TYPE (*node
)))
8847 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8848 *no_add_attrs
= true;
8854 /* Handle a "sentinel" attribute. */
8857 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
8858 int ARG_UNUSED (flags
), bool *no_add_attrs
)
8860 if (!prototype_p (*node
))
8862 warning (OPT_Wattributes
,
8863 "%qE attribute requires prototypes with named arguments", name
);
8864 *no_add_attrs
= true;
8868 if (!stdarg_p (*node
))
8870 warning (OPT_Wattributes
,
8871 "%qE attribute only applies to variadic functions", name
);
8872 *no_add_attrs
= true;
8878 tree position
= TREE_VALUE (args
);
8880 if (TREE_CODE (position
) != INTEGER_CST
)
8882 warning (OPT_Wattributes
,
8883 "requested position is not an integer constant");
8884 *no_add_attrs
= true;
8888 if (tree_int_cst_lt (position
, integer_zero_node
))
8890 warning (OPT_Wattributes
,
8891 "requested position is less than zero");
8892 *no_add_attrs
= true;
8900 /* Handle a "type_generic" attribute. */
8903 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
8904 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
8905 bool * ARG_UNUSED (no_add_attrs
))
8907 /* Ensure we have a function type. */
8908 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
8910 /* Ensure we have a variadic function. */
8911 gcc_assert (!prototype_p (*node
) || stdarg_p (*node
));
8916 /* Handle a "target" attribute. */
8919 handle_target_attribute (tree
*node
, tree name
, tree args
, int flags
,
8922 /* Ensure we have a function type. */
8923 if (TREE_CODE (*node
) != FUNCTION_DECL
)
8925 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
8926 *no_add_attrs
= true;
8928 else if (! targetm
.target_option
.valid_attribute_p (*node
, name
, args
,
8930 *no_add_attrs
= true;
8935 /* Arguments being collected for optimization. */
8936 typedef const char *const_char_p
; /* For DEF_VEC_P. */
8937 static GTY(()) vec
<const_char_p
, va_gc
> *optimize_args
;
8940 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
8941 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
8942 false for #pragma GCC optimize. */
8945 parse_optimize_options (tree args
, bool attr_p
)
8950 int saved_flag_strict_aliasing
;
8951 const char **opt_argv
;
8952 struct cl_decoded_option
*decoded_options
;
8953 unsigned int decoded_options_count
;
8956 /* Build up argv vector. Just in case the string is stored away, use garbage
8957 collected strings. */
8958 vec_safe_truncate (optimize_args
, 0);
8959 vec_safe_push (optimize_args
, (const char *) NULL
);
8961 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
8963 tree value
= TREE_VALUE (ap
);
8965 if (TREE_CODE (value
) == INTEGER_CST
)
8968 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
8969 vec_safe_push (optimize_args
, ggc_strdup (buffer
));
8972 else if (TREE_CODE (value
) == STRING_CST
)
8974 /* Split string into multiple substrings. */
8975 size_t len
= TREE_STRING_LENGTH (value
);
8976 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
8977 char *end
= p
+ len
;
8981 while (next_p
!= NULL
)
8987 comma
= strchr (p
, ',');
9000 r
= q
= (char *) ggc_alloc_atomic (len2
+ 3);
9002 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
9004 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
9008 warning (OPT_Wattributes
,
9009 "bad option %s to optimize attribute", p
);
9011 warning (OPT_Wpragmas
,
9012 "bad option %s to pragma attribute", p
);
9020 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
9021 itself is -Os, and any other switch begins with a -f. */
9022 if ((*p
>= '0' && *p
<= '9')
9023 || (p
[0] == 's' && p
[1] == '\0'))
9029 memcpy (r
, p
, len2
);
9031 vec_safe_push (optimize_args
, (const char *) q
);
9037 opt_argc
= optimize_args
->length ();
9038 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
9040 for (i
= 1; i
< opt_argc
; i
++)
9041 opt_argv
[i
] = (*optimize_args
)[i
];
9043 saved_flag_strict_aliasing
= flag_strict_aliasing
;
9045 /* Now parse the options. */
9046 decode_cmdline_options_to_array_default_mask (opt_argc
, opt_argv
,
9048 &decoded_options_count
);
9049 decode_options (&global_options
, &global_options_set
,
9050 decoded_options
, decoded_options_count
,
9051 input_location
, global_dc
);
9053 targetm
.override_options_after_change();
9055 /* Don't allow changing -fstrict-aliasing. */
9056 flag_strict_aliasing
= saved_flag_strict_aliasing
;
9058 optimize_args
->truncate (0);
9062 /* For handling "optimize" attribute. arguments as in
9063 struct attribute_spec.handler. */
9066 handle_optimize_attribute (tree
*node
, tree name
, tree args
,
9067 int ARG_UNUSED (flags
), bool *no_add_attrs
)
9069 /* Ensure we have a function type. */
9070 if (TREE_CODE (*node
) != FUNCTION_DECL
)
9072 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
9073 *no_add_attrs
= true;
9077 struct cl_optimization cur_opts
;
9078 tree old_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
);
9080 /* Save current options. */
9081 cl_optimization_save (&cur_opts
, &global_options
);
9083 /* If we previously had some optimization options, use them as the
9086 cl_optimization_restore (&global_options
,
9087 TREE_OPTIMIZATION (old_opts
));
9089 /* Parse options, and update the vector. */
9090 parse_optimize_options (args
, true);
9091 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
)
9092 = build_optimization_node (&global_options
);
9094 /* Restore current options. */
9095 cl_optimization_restore (&global_options
, &cur_opts
);
9101 /* Handle a "no_split_stack" attribute. */
9104 handle_no_split_stack_attribute (tree
*node
, tree name
,
9105 tree
ARG_UNUSED (args
),
9106 int ARG_UNUSED (flags
),
9111 if (TREE_CODE (decl
) != FUNCTION_DECL
)
9113 error_at (DECL_SOURCE_LOCATION (decl
),
9114 "%qE attribute applies only to functions", name
);
9115 *no_add_attrs
= true;
9117 else if (DECL_INITIAL (decl
))
9119 error_at (DECL_SOURCE_LOCATION (decl
),
9120 "can%'t set %qE attribute after definition", name
);
9121 *no_add_attrs
= true;
9127 /* Handle a "returns_nonnull" attribute; arguments as in
9128 struct attribute_spec.handler. */
9131 handle_returns_nonnull_attribute (tree
*node
, tree
, tree
, int,
9134 // Even without a prototype we still have a return type we can check.
9135 if (TREE_CODE (TREE_TYPE (*node
)) != POINTER_TYPE
)
9137 error ("returns_nonnull attribute on a function not returning a pointer");
9138 *no_add_attrs
= true;
9144 /* Check for valid arguments being passed to a function with FNTYPE.
9145 There are NARGS arguments in the array ARGARRAY. */
9147 check_function_arguments (const_tree fntype
, int nargs
, tree
*argarray
)
9149 /* Check for null being passed in a pointer argument that must be
9150 non-null. We also need to do this if format checking is enabled. */
9153 check_function_nonnull (TYPE_ATTRIBUTES (fntype
), nargs
, argarray
);
9155 /* Check for errors in format strings. */
9157 if (warn_format
|| warn_suggest_attribute_format
)
9158 check_function_format (TYPE_ATTRIBUTES (fntype
), nargs
, argarray
);
9161 check_function_sentinel (fntype
, nargs
, argarray
);
9164 /* Generic argument checking recursion routine. PARAM is the argument to
9165 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
9166 once the argument is resolved. CTX is context for the callback. */
9168 check_function_arguments_recurse (void (*callback
)
9169 (void *, tree
, unsigned HOST_WIDE_INT
),
9170 void *ctx
, tree param
,
9171 unsigned HOST_WIDE_INT param_num
)
9173 if (CONVERT_EXPR_P (param
)
9174 && (TYPE_PRECISION (TREE_TYPE (param
))
9175 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
9177 /* Strip coercion. */
9178 check_function_arguments_recurse (callback
, ctx
,
9179 TREE_OPERAND (param
, 0), param_num
);
9183 if (TREE_CODE (param
) == CALL_EXPR
)
9185 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
9187 bool found_format_arg
= false;
9189 /* See if this is a call to a known internationalization function
9190 that modifies a format arg. Such a function may have multiple
9191 format_arg attributes (for example, ngettext). */
9193 for (attrs
= TYPE_ATTRIBUTES (type
);
9195 attrs
= TREE_CHAIN (attrs
))
9196 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
9199 tree format_num_expr
;
9202 call_expr_arg_iterator iter
;
9204 /* Extract the argument number, which was previously checked
9206 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
9208 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
9209 && !TREE_INT_CST_HIGH (format_num_expr
));
9211 format_num
= TREE_INT_CST_LOW (format_num_expr
);
9213 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
9215 inner_arg
= next_call_expr_arg (&iter
), i
++)
9216 if (i
== format_num
)
9218 check_function_arguments_recurse (callback
, ctx
,
9219 inner_arg
, param_num
);
9220 found_format_arg
= true;
9225 /* If we found a format_arg attribute and did a recursive check,
9226 we are done with checking this argument. Otherwise, we continue
9227 and this will be considered a non-literal. */
9228 if (found_format_arg
)
9232 if (TREE_CODE (param
) == COND_EXPR
)
9234 /* Check both halves of the conditional expression. */
9235 check_function_arguments_recurse (callback
, ctx
,
9236 TREE_OPERAND (param
, 1), param_num
);
9237 check_function_arguments_recurse (callback
, ctx
,
9238 TREE_OPERAND (param
, 2), param_num
);
9242 (*callback
) (ctx
, param
, param_num
);
9245 /* Checks for a builtin function FNDECL that the number of arguments
9246 NARGS against the required number REQUIRED and issues an error if
9247 there is a mismatch. Returns true if the number of arguments is
9248 correct, otherwise false. */
9251 builtin_function_validate_nargs (tree fndecl
, int nargs
, int required
)
9253 if (nargs
< required
)
9255 error_at (input_location
,
9256 "not enough arguments to function %qE", fndecl
);
9259 else if (nargs
> required
)
9261 error_at (input_location
,
9262 "too many arguments to function %qE", fndecl
);
9268 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
9269 Returns false if there was an error, otherwise true. */
9272 check_builtin_function_arguments (tree fndecl
, int nargs
, tree
*args
)
9274 if (!DECL_BUILT_IN (fndecl
)
9275 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
9278 switch (DECL_FUNCTION_CODE (fndecl
))
9280 case BUILT_IN_CONSTANT_P
:
9281 return builtin_function_validate_nargs (fndecl
, nargs
, 1);
9283 case BUILT_IN_ISFINITE
:
9284 case BUILT_IN_ISINF
:
9285 case BUILT_IN_ISINF_SIGN
:
9286 case BUILT_IN_ISNAN
:
9287 case BUILT_IN_ISNORMAL
:
9288 if (builtin_function_validate_nargs (fndecl
, nargs
, 1))
9290 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
9292 error ("non-floating-point argument in call to "
9293 "function %qE", fndecl
);
9300 case BUILT_IN_ISGREATER
:
9301 case BUILT_IN_ISGREATEREQUAL
:
9302 case BUILT_IN_ISLESS
:
9303 case BUILT_IN_ISLESSEQUAL
:
9304 case BUILT_IN_ISLESSGREATER
:
9305 case BUILT_IN_ISUNORDERED
:
9306 if (builtin_function_validate_nargs (fndecl
, nargs
, 2))
9308 enum tree_code code0
, code1
;
9309 code0
= TREE_CODE (TREE_TYPE (args
[0]));
9310 code1
= TREE_CODE (TREE_TYPE (args
[1]));
9311 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
9312 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
9313 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
9315 error ("non-floating-point arguments in call to "
9316 "function %qE", fndecl
);
9323 case BUILT_IN_FPCLASSIFY
:
9324 if (builtin_function_validate_nargs (fndecl
, nargs
, 6))
9329 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
9331 error ("non-const integer argument %u in call to function %qE",
9336 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
9338 error ("non-floating-point argument in call to function %qE",
9346 case BUILT_IN_ASSUME_ALIGNED
:
9347 if (builtin_function_validate_nargs (fndecl
, nargs
, 2 + (nargs
> 2)))
9349 if (nargs
>= 3 && TREE_CODE (TREE_TYPE (args
[2])) != INTEGER_TYPE
)
9351 error ("non-integer argument 3 in call to function %qE", fndecl
);
9363 /* Function to help qsort sort FIELD_DECLs by name order. */
9366 field_decl_cmp (const void *x_p
, const void *y_p
)
9368 const tree
*const x
= (const tree
*const) x_p
;
9369 const tree
*const y
= (const tree
*const) y_p
;
9371 if (DECL_NAME (*x
) == DECL_NAME (*y
))
9372 /* A nontype is "greater" than a type. */
9373 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
9374 if (DECL_NAME (*x
) == NULL_TREE
)
9376 if (DECL_NAME (*y
) == NULL_TREE
)
9378 if (DECL_NAME (*x
) < DECL_NAME (*y
))
9384 gt_pointer_operator new_value
;
9388 /* This routine compares two fields like field_decl_cmp but using the
9389 pointer operator in resort_data. */
9392 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
9394 const tree
*const x
= (const tree
*const) x_p
;
9395 const tree
*const y
= (const tree
*const) y_p
;
9397 if (DECL_NAME (*x
) == DECL_NAME (*y
))
9398 /* A nontype is "greater" than a type. */
9399 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
9400 if (DECL_NAME (*x
) == NULL_TREE
)
9402 if (DECL_NAME (*y
) == NULL_TREE
)
9405 tree d1
= DECL_NAME (*x
);
9406 tree d2
= DECL_NAME (*y
);
9407 resort_data
.new_value (&d1
, resort_data
.cookie
);
9408 resort_data
.new_value (&d2
, resort_data
.cookie
);
9415 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
9418 resort_sorted_fields (void *obj
,
9419 void * ARG_UNUSED (orig_obj
),
9420 gt_pointer_operator new_value
,
9423 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
9424 resort_data
.new_value
= new_value
;
9425 resort_data
.cookie
= cookie
;
9426 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
9427 resort_field_decl_cmp
);
9430 /* Subroutine of c_parse_error.
9431 Return the result of concatenating LHS and RHS. RHS is really
9432 a string literal, its first character is indicated by RHS_START and
9433 RHS_SIZE is its length (including the terminating NUL character).
9435 The caller is responsible for deleting the returned pointer. */
9438 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
9440 const int lhs_size
= strlen (lhs
);
9441 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
9442 strncpy (result
, lhs
, lhs_size
);
9443 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
9447 /* Issue the error given by GMSGID, indicating that it occurred before
9448 TOKEN, which had the associated VALUE. */
9451 c_parse_error (const char *gmsgid
, enum cpp_ttype token_type
,
9452 tree value
, unsigned char token_flags
)
9454 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
9456 char *message
= NULL
;
9458 if (token_type
== CPP_EOF
)
9459 message
= catenate_messages (gmsgid
, " at end of input");
9460 else if (token_type
== CPP_CHAR
9461 || token_type
== CPP_WCHAR
9462 || token_type
== CPP_CHAR16
9463 || token_type
== CPP_CHAR32
)
9465 unsigned int val
= TREE_INT_CST_LOW (value
);
9484 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
9485 message
= catenate_messages (gmsgid
, " before %s'%c'");
9487 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
9489 error (message
, prefix
, val
);
9493 else if (token_type
== CPP_CHAR_USERDEF
9494 || token_type
== CPP_WCHAR_USERDEF
9495 || token_type
== CPP_CHAR16_USERDEF
9496 || token_type
== CPP_CHAR32_USERDEF
)
9497 message
= catenate_messages (gmsgid
,
9498 " before user-defined character literal");
9499 else if (token_type
== CPP_STRING_USERDEF
9500 || token_type
== CPP_WSTRING_USERDEF
9501 || token_type
== CPP_STRING16_USERDEF
9502 || token_type
== CPP_STRING32_USERDEF
9503 || token_type
== CPP_UTF8STRING_USERDEF
)
9504 message
= catenate_messages (gmsgid
, " before user-defined string literal");
9505 else if (token_type
== CPP_STRING
9506 || token_type
== CPP_WSTRING
9507 || token_type
== CPP_STRING16
9508 || token_type
== CPP_STRING32
9509 || token_type
== CPP_UTF8STRING
)
9510 message
= catenate_messages (gmsgid
, " before string constant");
9511 else if (token_type
== CPP_NUMBER
)
9512 message
= catenate_messages (gmsgid
, " before numeric constant");
9513 else if (token_type
== CPP_NAME
)
9515 message
= catenate_messages (gmsgid
, " before %qE");
9516 error (message
, value
);
9520 else if (token_type
== CPP_PRAGMA
)
9521 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
9522 else if (token_type
== CPP_PRAGMA_EOL
)
9523 message
= catenate_messages (gmsgid
, " before end of line");
9524 else if (token_type
== CPP_DECLTYPE
)
9525 message
= catenate_messages (gmsgid
, " before %<decltype%>");
9526 else if (token_type
< N_TTYPES
)
9528 message
= catenate_messages (gmsgid
, " before %qs token");
9529 error (message
, cpp_type2name (token_type
, token_flags
));
9541 #undef catenate_messages
9544 /* Mapping for cpp message reasons to the options that enable them. */
9546 struct reason_option_codes_t
9548 const int reason
; /* cpplib message reason. */
9549 const int option_code
; /* gcc option that controls this message. */
9552 static const struct reason_option_codes_t option_codes
[] = {
9553 {CPP_W_DEPRECATED
, OPT_Wdeprecated
},
9554 {CPP_W_COMMENTS
, OPT_Wcomment
},
9555 {CPP_W_TRIGRAPHS
, OPT_Wtrigraphs
},
9556 {CPP_W_MULTICHAR
, OPT_Wmultichar
},
9557 {CPP_W_TRADITIONAL
, OPT_Wtraditional
},
9558 {CPP_W_LONG_LONG
, OPT_Wlong_long
},
9559 {CPP_W_ENDIF_LABELS
, OPT_Wendif_labels
},
9560 {CPP_W_VARIADIC_MACROS
, OPT_Wvariadic_macros
},
9561 {CPP_W_BUILTIN_MACRO_REDEFINED
, OPT_Wbuiltin_macro_redefined
},
9562 {CPP_W_UNDEF
, OPT_Wundef
},
9563 {CPP_W_UNUSED_MACROS
, OPT_Wunused_macros
},
9564 {CPP_W_CXX_OPERATOR_NAMES
, OPT_Wc___compat
},
9565 {CPP_W_NORMALIZE
, OPT_Wnormalized_
},
9566 {CPP_W_INVALID_PCH
, OPT_Winvalid_pch
},
9567 {CPP_W_WARNING_DIRECTIVE
, OPT_Wcpp
},
9568 {CPP_W_LITERAL_SUFFIX
, OPT_Wliteral_suffix
},
9569 {CPP_W_DATE_TIME
, OPT_Wdate_time
},
9573 /* Return the gcc option code associated with the reason for a cpp
9574 message, or 0 if none. */
9577 c_option_controlling_cpp_error (int reason
)
9579 const struct reason_option_codes_t
*entry
;
9581 for (entry
= option_codes
; entry
->reason
!= CPP_W_NONE
; entry
++)
9583 if (entry
->reason
== reason
)
9584 return entry
->option_code
;
9589 /* Callback from cpp_error for PFILE to print diagnostics from the
9590 preprocessor. The diagnostic is of type LEVEL, with REASON set
9591 to the reason code if LEVEL is represents a warning, at location
9592 LOCATION unless this is after lexing and the compiler's location
9593 should be used instead, with column number possibly overridden by
9594 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
9595 the arguments. Returns true if a diagnostic was emitted, false
9599 c_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
, int reason
,
9600 location_t location
, unsigned int column_override
,
9601 const char *msg
, va_list *ap
)
9603 diagnostic_info diagnostic
;
9604 diagnostic_t dlevel
;
9605 bool save_warn_system_headers
= global_dc
->dc_warn_system_headers
;
9610 case CPP_DL_WARNING_SYSHDR
:
9613 global_dc
->dc_warn_system_headers
= 1;
9615 case CPP_DL_WARNING
:
9618 dlevel
= DK_WARNING
;
9620 case CPP_DL_PEDWARN
:
9621 if (flag_no_output
&& !flag_pedantic_errors
)
9623 dlevel
= DK_PEDWARN
;
9641 location
= input_location
;
9642 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
9644 if (column_override
)
9645 diagnostic_override_column (&diagnostic
, column_override
);
9646 diagnostic_override_option_index (&diagnostic
,
9647 c_option_controlling_cpp_error (reason
));
9648 ret
= report_diagnostic (&diagnostic
);
9649 if (level
== CPP_DL_WARNING_SYSHDR
)
9650 global_dc
->dc_warn_system_headers
= save_warn_system_headers
;
9654 /* Convert a character from the host to the target execution character
9655 set. cpplib handles this, mostly. */
9658 c_common_to_target_charset (HOST_WIDE_INT c
)
9660 /* Character constants in GCC proper are sign-extended under -fsigned-char,
9661 zero-extended under -fno-signed-char. cpplib insists that characters
9662 and character constants are always unsigned. Hence we must convert
9664 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
9666 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
9668 if (flag_signed_char
)
9669 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
9670 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
9675 /* Fold an offsetof-like expression. EXPR is a nested sequence of component
9676 references with an INDIRECT_REF of a constant at the bottom; much like the
9677 traditional rendering of offsetof as a macro. Return the folded result. */
9680 fold_offsetof_1 (tree expr
)
9684 switch (TREE_CODE (expr
))
9690 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
9691 return error_mark_node
;
9695 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
9696 return error_mark_node
;
9700 if (!TREE_CONSTANT (TREE_OPERAND (expr
, 0)))
9702 error ("cannot apply %<offsetof%> to a non constant address");
9703 return error_mark_node
;
9705 return TREE_OPERAND (expr
, 0);
9708 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0));
9709 if (base
== error_mark_node
)
9712 t
= TREE_OPERAND (expr
, 1);
9713 if (DECL_C_BIT_FIELD (t
))
9715 error ("attempt to take address of bit-field structure "
9717 return error_mark_node
;
9719 off
= size_binop_loc (input_location
, PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
9720 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
),
9726 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0));
9727 if (base
== error_mark_node
)
9730 t
= TREE_OPERAND (expr
, 1);
9732 /* Check if the offset goes beyond the upper bound of the array. */
9733 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) >= 0)
9735 tree upbound
= array_ref_up_bound (expr
);
9736 if (upbound
!= NULL_TREE
9737 && TREE_CODE (upbound
) == INTEGER_CST
9738 && !tree_int_cst_equal (upbound
,
9739 TYPE_MAX_VALUE (TREE_TYPE (upbound
))))
9741 upbound
= size_binop (PLUS_EXPR
, upbound
,
9742 build_int_cst (TREE_TYPE (upbound
), 1));
9743 if (tree_int_cst_lt (upbound
, t
))
9747 for (v
= TREE_OPERAND (expr
, 0);
9748 TREE_CODE (v
) == COMPONENT_REF
;
9749 v
= TREE_OPERAND (v
, 0))
9750 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v
, 0)))
9753 tree fld_chain
= DECL_CHAIN (TREE_OPERAND (v
, 1));
9754 for (; fld_chain
; fld_chain
= DECL_CHAIN (fld_chain
))
9755 if (TREE_CODE (fld_chain
) == FIELD_DECL
)
9761 /* Don't warn if the array might be considered a poor
9762 man's flexible array member with a very permissive
9763 definition thereof. */
9764 if (TREE_CODE (v
) == ARRAY_REF
9765 || TREE_CODE (v
) == COMPONENT_REF
)
9766 warning (OPT_Warray_bounds
,
9767 "index %E denotes an offset "
9768 "greater than size of %qT",
9769 t
, TREE_TYPE (TREE_OPERAND (expr
, 0)));
9774 t
= convert (sizetype
, t
);
9775 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
9779 /* Handle static members of volatile structs. */
9780 t
= TREE_OPERAND (expr
, 1);
9781 gcc_assert (TREE_CODE (t
) == VAR_DECL
);
9782 return fold_offsetof_1 (t
);
9788 return fold_build_pointer_plus (base
, off
);
9791 /* Likewise, but convert it to the return type of offsetof. */
9794 fold_offsetof (tree expr
)
9796 return convert (size_type_node
, fold_offsetof_1 (expr
));
9799 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
9800 expression, because B will always be true. */
9803 warn_for_omitted_condop (location_t location
, tree cond
)
9805 if (truth_value_p (TREE_CODE (cond
)))
9806 warning_at (location
, OPT_Wparentheses
,
9807 "the omitted middle operand in ?: will always be %<true%>, "
9808 "suggest explicit middle operand");
9811 /* Give an error for storing into ARG, which is 'const'. USE indicates
9812 how ARG was being used. */
9815 readonly_error (tree arg
, enum lvalue_use use
)
9817 gcc_assert (use
== lv_assign
|| use
== lv_increment
|| use
== lv_decrement
9819 /* Using this macro rather than (for example) arrays of messages
9820 ensures that all the format strings are checked at compile
9822 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
9823 : (use == lv_increment ? (I) \
9824 : (use == lv_decrement ? (D) : (AS))))
9825 if (TREE_CODE (arg
) == COMPONENT_REF
)
9827 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg
, 0))))
9828 error (READONLY_MSG (G_("assignment of member "
9829 "%qD in read-only object"),
9830 G_("increment of member "
9831 "%qD in read-only object"),
9832 G_("decrement of member "
9833 "%qD in read-only object"),
9834 G_("member %qD in read-only object "
9835 "used as %<asm%> output")),
9836 TREE_OPERAND (arg
, 1));
9838 error (READONLY_MSG (G_("assignment of read-only member %qD"),
9839 G_("increment of read-only member %qD"),
9840 G_("decrement of read-only member %qD"),
9841 G_("read-only member %qD used as %<asm%> output")),
9842 TREE_OPERAND (arg
, 1));
9844 else if (TREE_CODE (arg
) == VAR_DECL
)
9845 error (READONLY_MSG (G_("assignment of read-only variable %qD"),
9846 G_("increment of read-only variable %qD"),
9847 G_("decrement of read-only variable %qD"),
9848 G_("read-only variable %qD used as %<asm%> output")),
9850 else if (TREE_CODE (arg
) == PARM_DECL
)
9851 error (READONLY_MSG (G_("assignment of read-only parameter %qD"),
9852 G_("increment of read-only parameter %qD"),
9853 G_("decrement of read-only parameter %qD"),
9854 G_("read-only parameter %qD use as %<asm%> output")),
9856 else if (TREE_CODE (arg
) == RESULT_DECL
)
9858 gcc_assert (c_dialect_cxx ());
9859 error (READONLY_MSG (G_("assignment of "
9860 "read-only named return value %qD"),
9862 "read-only named return value %qD"),
9864 "read-only named return value %qD"),
9865 G_("read-only named return value %qD "
9866 "used as %<asm%>output")),
9869 else if (TREE_CODE (arg
) == FUNCTION_DECL
)
9870 error (READONLY_MSG (G_("assignment of function %qD"),
9871 G_("increment of function %qD"),
9872 G_("decrement of function %qD"),
9873 G_("function %qD used as %<asm%> output")),
9876 error (READONLY_MSG (G_("assignment of read-only location %qE"),
9877 G_("increment of read-only location %qE"),
9878 G_("decrement of read-only location %qE"),
9879 G_("read-only location %qE used as %<asm%> output")),
9883 /* Print an error message for an invalid lvalue. USE says
9884 how the lvalue is being used and so selects the error message. LOC
9885 is the location for the error. */
9888 lvalue_error (location_t loc
, enum lvalue_use use
)
9893 error_at (loc
, "lvalue required as left operand of assignment");
9896 error_at (loc
, "lvalue required as increment operand");
9899 error_at (loc
, "lvalue required as decrement operand");
9902 error_at (loc
, "lvalue required as unary %<&%> operand");
9905 error_at (loc
, "lvalue required in asm statement");
9912 /* Print an error message for an invalid indirection of type TYPE.
9913 ERRSTRING is the name of the operator for the indirection. */
9916 invalid_indirection_error (location_t loc
, tree type
, ref_operator errstring
)
9921 gcc_assert (c_dialect_cxx ());
9922 error_at (loc
, "invalid type argument (have %qT)", type
);
9924 case RO_ARRAY_INDEXING
:
9926 "invalid type argument of array indexing (have %qT)",
9931 "invalid type argument of unary %<*%> (have %qT)",
9936 "invalid type argument of %<->%> (have %qT)",
9941 "invalid type argument of %<->*%> (have %qT)",
9944 case RO_IMPLICIT_CONVERSION
:
9946 "invalid type argument of implicit conversion (have %qT)",
9954 /* *PTYPE is an incomplete array. Complete it with a domain based on
9955 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
9956 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
9957 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
9960 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
9962 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
9963 int failure
= 0, quals
;
9964 hashval_t hashcode
= 0;
9965 bool overflow_p
= false;
9967 maxindex
= size_zero_node
;
9970 if (TREE_CODE (initial_value
) == STRING_CST
)
9973 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
9974 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
9976 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
9978 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
9980 if (vec_safe_is_empty (v
))
9984 maxindex
= ssize_int (-1);
9989 unsigned HOST_WIDE_INT cnt
;
9990 constructor_elt
*ce
;
9991 bool fold_p
= false;
9994 maxindex
= (*v
)[0].index
, fold_p
= true;
9996 curindex
= maxindex
;
9998 for (cnt
= 1; vec_safe_iterate (v
, cnt
, &ce
); cnt
++)
10000 bool curfold_p
= false;
10002 curindex
= ce
->index
, curfold_p
= true;
10007 /* Since we treat size types now as ordinary
10008 unsigned types, we need an explicit overflow
10010 tree orig
= curindex
;
10011 curindex
= fold_convert (sizetype
, curindex
);
10012 overflow_p
|= tree_int_cst_lt (curindex
, orig
);
10014 curindex
= size_binop (PLUS_EXPR
, curindex
,
10017 if (tree_int_cst_lt (maxindex
, curindex
))
10018 maxindex
= curindex
, fold_p
= curfold_p
;
10022 tree orig
= maxindex
;
10023 maxindex
= fold_convert (sizetype
, maxindex
);
10024 overflow_p
|= tree_int_cst_lt (maxindex
, orig
);
10030 /* Make an error message unless that happened already. */
10031 if (initial_value
!= error_mark_node
)
10043 elt
= TREE_TYPE (type
);
10044 quals
= TYPE_QUALS (strip_array_types (elt
));
10048 unqual_elt
= c_build_qualified_type (elt
, KEEP_QUAL_ADDR_SPACE (quals
));
10050 /* Using build_distinct_type_copy and modifying things afterward instead
10051 of using build_array_type to create a new type preserves all of the
10052 TYPE_LANG_FLAG_? bits that the front end may have set. */
10053 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
10054 TREE_TYPE (main_type
) = unqual_elt
;
10055 TYPE_DOMAIN (main_type
)
10056 = build_range_type (TREE_TYPE (maxindex
),
10057 build_int_cst (TREE_TYPE (maxindex
), 0), maxindex
);
10058 layout_type (main_type
);
10060 /* Make sure we have the canonical MAIN_TYPE. */
10061 hashcode
= iterative_hash_object (TYPE_HASH (unqual_elt
), hashcode
);
10062 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type
)),
10064 main_type
= type_hash_canon (hashcode
, main_type
);
10066 /* Fix the canonical type. */
10067 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
10068 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
10069 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
10070 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
10071 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
10072 != TYPE_DOMAIN (main_type
)))
10073 TYPE_CANONICAL (main_type
)
10074 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
10075 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)));
10077 TYPE_CANONICAL (main_type
) = main_type
;
10082 type
= c_build_qualified_type (main_type
, quals
);
10084 if (COMPLETE_TYPE_P (type
)
10085 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
10086 && (overflow_p
|| TREE_OVERFLOW (TYPE_SIZE_UNIT (type
))))
10088 error ("size of array is too large");
10089 /* If we proceed with the array type as it is, we'll eventually
10090 crash in tree_low_cst(). */
10091 type
= error_mark_node
;
10098 /* Like c_mark_addressable but don't check register qualifier. */
10100 c_common_mark_addressable_vec (tree t
)
10102 while (handled_component_p (t
))
10103 t
= TREE_OPERAND (t
, 0);
10104 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
10106 TREE_ADDRESSABLE (t
) = 1;
10111 /* Used to help initialize the builtin-types.def table. When a type of
10112 the correct size doesn't exist, use error_mark_node instead of NULL.
10113 The later results in segfaults even when a decl using the type doesn't
10117 builtin_type_for_size (int size
, bool unsignedp
)
10119 tree type
= c_common_type_for_size (size
, unsignedp
);
10120 return type
? type
: error_mark_node
;
10123 /* A helper function for resolve_overloaded_builtin in resolving the
10124 overloaded __sync_ builtins. Returns a positive power of 2 if the
10125 first operand of PARAMS is a pointer to a supported data type.
10126 Returns 0 if an error is encountered. */
10129 sync_resolve_size (tree function
, vec
<tree
, va_gc
> *params
)
10136 error ("too few arguments to function %qE", function
);
10140 type
= TREE_TYPE ((*params
)[0]);
10141 if (TREE_CODE (type
) != POINTER_TYPE
)
10144 type
= TREE_TYPE (type
);
10145 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
10148 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
10149 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
10153 error ("incompatible type for argument %d of %qE", 1, function
);
10157 /* A helper function for resolve_overloaded_builtin. Adds casts to
10158 PARAMS to make arguments match up with those of FUNCTION. Drops
10159 the variadic arguments at the end. Returns false if some error
10160 was encountered; true on success. */
10163 sync_resolve_params (location_t loc
, tree orig_function
, tree function
,
10164 vec
<tree
, va_gc
> *params
, bool orig_format
)
10166 function_args_iterator iter
;
10168 unsigned int parmnum
;
10170 function_args_iter_init (&iter
, TREE_TYPE (function
));
10171 /* We've declared the implementation functions to use "volatile void *"
10172 as the pointer parameter, so we shouldn't get any complaints from the
10173 call to check_function_arguments what ever type the user used. */
10174 function_args_iter_next (&iter
);
10175 ptype
= TREE_TYPE (TREE_TYPE ((*params
)[0]));
10176 ptype
= TYPE_MAIN_VARIANT (ptype
);
10178 /* For the rest of the values, we need to cast these to FTYPE, so that we
10179 don't get warnings for passing pointer types, etc. */
10183 tree val
, arg_type
;
10185 arg_type
= function_args_iter_cond (&iter
);
10186 /* XXX void_type_node belies the abstraction. */
10187 if (arg_type
== void_type_node
)
10191 if (params
->length () <= parmnum
)
10193 error_at (loc
, "too few arguments to function %qE", orig_function
);
10197 /* Only convert parameters if arg_type is unsigned integer type with
10198 new format sync routines, i.e. don't attempt to convert pointer
10199 arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n),
10200 bool arguments (e.g. WEAK argument) or signed int arguments (memmodel
10202 if (TREE_CODE (arg_type
) == INTEGER_TYPE
&& TYPE_UNSIGNED (arg_type
))
10204 /* Ideally for the first conversion we'd use convert_for_assignment
10205 so that we get warnings for anything that doesn't match the pointer
10206 type. This isn't portable across the C and C++ front ends atm. */
10207 val
= (*params
)[parmnum
];
10208 val
= convert (ptype
, val
);
10209 val
= convert (arg_type
, val
);
10210 (*params
)[parmnum
] = val
;
10213 function_args_iter_next (&iter
);
10216 /* __atomic routines are not variadic. */
10217 if (!orig_format
&& params
->length () != parmnum
+ 1)
10219 error_at (loc
, "too many arguments to function %qE", orig_function
);
10223 /* The definition of these primitives is variadic, with the remaining
10224 being "an optional list of variables protected by the memory barrier".
10225 No clue what that's supposed to mean, precisely, but we consider all
10226 call-clobbered variables to be protected so we're safe. */
10227 params
->truncate (parmnum
+ 1);
10232 /* A helper function for resolve_overloaded_builtin. Adds a cast to
10233 RESULT to make it match the type of the first pointer argument in
10237 sync_resolve_return (tree first_param
, tree result
, bool orig_format
)
10239 tree ptype
= TREE_TYPE (TREE_TYPE (first_param
));
10240 tree rtype
= TREE_TYPE (result
);
10241 ptype
= TYPE_MAIN_VARIANT (ptype
);
10243 /* New format doesn't require casting unless the types are the same size. */
10244 if (orig_format
|| tree_int_cst_equal (TYPE_SIZE (ptype
), TYPE_SIZE (rtype
)))
10245 return convert (ptype
, result
);
10250 /* This function verifies the PARAMS to generic atomic FUNCTION.
10251 It returns the size if all the parameters are the same size, otherwise
10252 0 is returned if the parameters are invalid. */
10255 get_atomic_generic_size (location_t loc
, tree function
,
10256 vec
<tree
, va_gc
> *params
)
10258 unsigned int n_param
;
10259 unsigned int n_model
;
10264 /* Determine the parameter makeup. */
10265 switch (DECL_FUNCTION_CODE (function
))
10267 case BUILT_IN_ATOMIC_EXCHANGE
:
10271 case BUILT_IN_ATOMIC_LOAD
:
10272 case BUILT_IN_ATOMIC_STORE
:
10276 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
10281 gcc_unreachable ();
10284 if (vec_safe_length (params
) != n_param
)
10286 error_at (loc
, "incorrect number of arguments to function %qE", function
);
10290 /* Get type of first parameter, and determine its size. */
10291 type_0
= TREE_TYPE ((*params
)[0]);
10292 if (TREE_CODE (type_0
) != POINTER_TYPE
|| VOID_TYPE_P (TREE_TYPE (type_0
)))
10294 error_at (loc
, "argument 1 of %qE must be a non-void pointer type",
10299 /* Types must be compile time constant sizes. */
10300 if (TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type_0
)))) != INTEGER_CST
)
10303 "argument 1 of %qE must be a pointer to a constant size type",
10308 size_0
= tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (type_0
)), 1);
10310 /* Zero size objects are not allowed. */
10314 "argument 1 of %qE must be a pointer to a nonzero size object",
10319 /* Check each other parameter is a pointer and the same size. */
10320 for (x
= 0; x
< n_param
- n_model
; x
++)
10323 tree type
= TREE_TYPE ((*params
)[x
]);
10324 /* __atomic_compare_exchange has a bool in the 4th position, skip it. */
10325 if (n_param
== 6 && x
== 3)
10327 if (!POINTER_TYPE_P (type
))
10329 error_at (loc
, "argument %d of %qE must be a pointer type", x
+ 1,
10333 size
= tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (type
)), 1);
10334 if (size
!= size_0
)
10336 error_at (loc
, "size mismatch in argument %d of %qE", x
+ 1,
10342 /* Check memory model parameters for validity. */
10343 for (x
= n_param
- n_model
; x
< n_param
; x
++)
10345 tree p
= (*params
)[x
];
10346 if (TREE_CODE (p
) == INTEGER_CST
)
10348 int i
= tree_low_cst (p
, 1);
10349 if (i
< 0 || (i
& MEMMODEL_MASK
) >= MEMMODEL_LAST
)
10351 warning_at (loc
, OPT_Winvalid_memory_model
,
10352 "invalid memory model argument %d of %qE", x
+ 1,
10357 if (!INTEGRAL_TYPE_P (TREE_TYPE (p
)))
10359 error_at (loc
, "non-integer memory model argument %d of %qE", x
+ 1,
10369 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N
10370 at the beginning of the parameter list PARAMS representing the size of the
10371 objects. This is to match the library ABI requirement. LOC is the location
10372 of the function call.
10373 The new function is returned if it needed rebuilding, otherwise NULL_TREE is
10374 returned to allow the external call to be constructed. */
10377 add_atomic_size_parameter (unsigned n
, location_t loc
, tree function
,
10378 vec
<tree
, va_gc
> *params
)
10382 /* Insert a SIZE_T parameter as the first param. If there isn't
10383 enough space, allocate a new vector and recursively re-build with that. */
10384 if (!params
->space (1))
10386 unsigned int z
, len
;
10387 vec
<tree
, va_gc
> *v
;
10390 len
= params
->length ();
10391 vec_alloc (v
, len
+ 1);
10392 for (z
= 0; z
< len
; z
++)
10393 v
->quick_push ((*params
)[z
]);
10394 f
= build_function_call_vec (loc
, function
, v
, NULL
);
10399 /* Add the size parameter and leave as a function call for processing. */
10400 size_node
= build_int_cst (size_type_node
, n
);
10401 params
->quick_insert (0, size_node
);
10406 /* This will process an __atomic_exchange function call, determine whether it
10407 needs to be mapped to the _N variation, or turned into a library call.
10408 LOC is the location of the builtin call.
10409 FUNCTION is the DECL that has been invoked;
10410 PARAMS is the argument list for the call. The return value is non-null
10411 TRUE is returned if it is translated into the proper format for a call to the
10412 external library, and NEW_RETURN is set the tree for that function.
10413 FALSE is returned if processing for the _N variation is required, and
10414 NEW_RETURN is set to the the return value the result is copied into. */
10416 resolve_overloaded_atomic_exchange (location_t loc
, tree function
,
10417 vec
<tree
, va_gc
> *params
, tree
*new_return
)
10419 tree p0
, p1
, p2
, p3
;
10420 tree I_type
, I_type_ptr
;
10421 int n
= get_atomic_generic_size (loc
, function
, params
);
10423 /* Size of 0 is an error condition. */
10426 *new_return
= error_mark_node
;
10430 /* If not a lock-free size, change to the library generic format. */
10431 if (n
!= 1 && n
!= 2 && n
!= 4 && n
!= 8 && n
!= 16)
10433 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
10437 /* Otherwise there is a lockfree match, transform the call from:
10438 void fn(T* mem, T* desired, T* return, model)
10440 *return = (T) (fn (In* mem, (In) *desired, model)) */
10447 /* Create pointer to appropriate size. */
10448 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
10449 I_type_ptr
= build_pointer_type (I_type
);
10451 /* Convert object pointer to required type. */
10452 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
10454 /* Convert new value to required type, and dereference it. */
10455 p1
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
10456 p1
= build1 (VIEW_CONVERT_EXPR
, I_type
, p1
);
10459 /* Move memory model to the 3rd position, and end param list. */
10461 params
->truncate (3);
10463 /* Convert return pointer and dereference it for later assignment. */
10464 *new_return
= build_indirect_ref (loc
, p2
, RO_UNARY_STAR
);
10470 /* This will process an __atomic_compare_exchange function call, determine
10471 whether it needs to be mapped to the _N variation, or turned into a lib call.
10472 LOC is the location of the builtin call.
10473 FUNCTION is the DECL that has been invoked;
10474 PARAMS is the argument list for the call. The return value is non-null
10475 TRUE is returned if it is translated into the proper format for a call to the
10476 external library, and NEW_RETURN is set the tree for that function.
10477 FALSE is returned if processing for the _N variation is required. */
10480 resolve_overloaded_atomic_compare_exchange (location_t loc
, tree function
,
10481 vec
<tree
, va_gc
> *params
,
10485 tree I_type
, I_type_ptr
;
10486 int n
= get_atomic_generic_size (loc
, function
, params
);
10488 /* Size of 0 is an error condition. */
10491 *new_return
= error_mark_node
;
10495 /* If not a lock-free size, change to the library generic format. */
10496 if (n
!= 1 && n
!= 2 && n
!= 4 && n
!= 8 && n
!= 16)
10498 /* The library generic format does not have the weak parameter, so
10499 remove it from the param list. Since a parameter has been removed,
10500 we can be sure that there is room for the SIZE_T parameter, meaning
10501 there will not be a recursive rebuilding of the parameter list, so
10502 there is no danger this will be done twice. */
10505 (*params
)[3] = (*params
)[4];
10506 (*params
)[4] = (*params
)[5];
10507 params
->truncate (5);
10509 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
10513 /* Otherwise, there is a match, so the call needs to be transformed from:
10514 bool fn(T* mem, T* desired, T* return, weak, success, failure)
10516 bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */
10522 /* Create pointer to appropriate size. */
10523 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
10524 I_type_ptr
= build_pointer_type (I_type
);
10526 /* Convert object pointer to required type. */
10527 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
10530 /* Convert expected pointer to required type. */
10531 p1
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p1
);
10534 /* Convert desired value to required type, and dereference it. */
10535 p2
= build_indirect_ref (loc
, p2
, RO_UNARY_STAR
);
10536 p2
= build1 (VIEW_CONVERT_EXPR
, I_type
, p2
);
10539 /* The rest of the parameters are fine. NULL means no special return value
10541 *new_return
= NULL
;
10546 /* This will process an __atomic_load function call, determine whether it
10547 needs to be mapped to the _N variation, or turned into a library call.
10548 LOC is the location of the builtin call.
10549 FUNCTION is the DECL that has been invoked;
10550 PARAMS is the argument list for the call. The return value is non-null
10551 TRUE is returned if it is translated into the proper format for a call to the
10552 external library, and NEW_RETURN is set the tree for that function.
10553 FALSE is returned if processing for the _N variation is required, and
10554 NEW_RETURN is set to the the return value the result is copied into. */
10557 resolve_overloaded_atomic_load (location_t loc
, tree function
,
10558 vec
<tree
, va_gc
> *params
, tree
*new_return
)
10561 tree I_type
, I_type_ptr
;
10562 int n
= get_atomic_generic_size (loc
, function
, params
);
10564 /* Size of 0 is an error condition. */
10567 *new_return
= error_mark_node
;
10571 /* If not a lock-free size, change to the library generic format. */
10572 if (n
!= 1 && n
!= 2 && n
!= 4 && n
!= 8 && n
!= 16)
10574 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
10578 /* Otherwise, there is a match, so the call needs to be transformed from:
10579 void fn(T* mem, T* return, model)
10581 *return = (T) (fn ((In *) mem, model)) */
10587 /* Create pointer to appropriate size. */
10588 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
10589 I_type_ptr
= build_pointer_type (I_type
);
10591 /* Convert object pointer to required type. */
10592 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
10595 /* Move memory model to the 2nd position, and end param list. */
10597 params
->truncate (2);
10599 /* Convert return pointer and dereference it for later assignment. */
10600 *new_return
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
10606 /* This will process an __atomic_store function call, determine whether it
10607 needs to be mapped to the _N variation, or turned into a library call.
10608 LOC is the location of the builtin call.
10609 FUNCTION is the DECL that has been invoked;
10610 PARAMS is the argument list for the call. The return value is non-null
10611 TRUE is returned if it is translated into the proper format for a call to the
10612 external library, and NEW_RETURN is set the tree for that function.
10613 FALSE is returned if processing for the _N variation is required, and
10614 NEW_RETURN is set to the the return value the result is copied into. */
10617 resolve_overloaded_atomic_store (location_t loc
, tree function
,
10618 vec
<tree
, va_gc
> *params
, tree
*new_return
)
10621 tree I_type
, I_type_ptr
;
10622 int n
= get_atomic_generic_size (loc
, function
, params
);
10624 /* Size of 0 is an error condition. */
10627 *new_return
= error_mark_node
;
10631 /* If not a lock-free size, change to the library generic format. */
10632 if (n
!= 1 && n
!= 2 && n
!= 4 && n
!= 8 && n
!= 16)
10634 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
10638 /* Otherwise, there is a match, so the call needs to be transformed from:
10639 void fn(T* mem, T* value, model)
10641 fn ((In *) mem, (In) *value, model) */
10646 /* Create pointer to appropriate size. */
10647 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
10648 I_type_ptr
= build_pointer_type (I_type
);
10650 /* Convert object pointer to required type. */
10651 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
10654 /* Convert new value to required type, and dereference it. */
10655 p1
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
10656 p1
= build1 (VIEW_CONVERT_EXPR
, I_type
, p1
);
10659 /* The memory model is in the right spot already. Return is void. */
10660 *new_return
= NULL_TREE
;
10666 /* Some builtin functions are placeholders for other expressions. This
10667 function should be called immediately after parsing the call expression
10668 before surrounding code has committed to the type of the expression.
10670 LOC is the location of the builtin call.
10672 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
10673 PARAMS is the argument list for the call. The return value is non-null
10674 when expansion is complete, and null if normal processing should
10678 resolve_overloaded_builtin (location_t loc
, tree function
,
10679 vec
<tree
, va_gc
> *params
)
10681 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
10682 bool orig_format
= true;
10683 tree new_return
= NULL_TREE
;
10685 switch (DECL_BUILT_IN_CLASS (function
))
10687 case BUILT_IN_NORMAL
:
10690 if (targetm
.resolve_overloaded_builtin
)
10691 return targetm
.resolve_overloaded_builtin (loc
, function
, params
);
10698 /* Handle BUILT_IN_NORMAL here. */
10701 case BUILT_IN_ATOMIC_EXCHANGE
:
10702 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
10703 case BUILT_IN_ATOMIC_LOAD
:
10704 case BUILT_IN_ATOMIC_STORE
:
10706 /* Handle these 4 together so that they can fall through to the next
10707 case if the call is transformed to an _N variant. */
10710 case BUILT_IN_ATOMIC_EXCHANGE
:
10712 if (resolve_overloaded_atomic_exchange (loc
, function
, params
,
10715 /* Change to the _N variant. */
10716 orig_code
= BUILT_IN_ATOMIC_EXCHANGE_N
;
10720 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
10722 if (resolve_overloaded_atomic_compare_exchange (loc
, function
,
10726 /* Change to the _N variant. */
10727 orig_code
= BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
;
10730 case BUILT_IN_ATOMIC_LOAD
:
10732 if (resolve_overloaded_atomic_load (loc
, function
, params
,
10735 /* Change to the _N variant. */
10736 orig_code
= BUILT_IN_ATOMIC_LOAD_N
;
10739 case BUILT_IN_ATOMIC_STORE
:
10741 if (resolve_overloaded_atomic_store (loc
, function
, params
,
10744 /* Change to the _N variant. */
10745 orig_code
= BUILT_IN_ATOMIC_STORE_N
;
10749 gcc_unreachable ();
10751 /* Fallthrough to the normal processing. */
10753 case BUILT_IN_ATOMIC_EXCHANGE_N
:
10754 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
:
10755 case BUILT_IN_ATOMIC_LOAD_N
:
10756 case BUILT_IN_ATOMIC_STORE_N
:
10757 case BUILT_IN_ATOMIC_ADD_FETCH_N
:
10758 case BUILT_IN_ATOMIC_SUB_FETCH_N
:
10759 case BUILT_IN_ATOMIC_AND_FETCH_N
:
10760 case BUILT_IN_ATOMIC_NAND_FETCH_N
:
10761 case BUILT_IN_ATOMIC_XOR_FETCH_N
:
10762 case BUILT_IN_ATOMIC_OR_FETCH_N
:
10763 case BUILT_IN_ATOMIC_FETCH_ADD_N
:
10764 case BUILT_IN_ATOMIC_FETCH_SUB_N
:
10765 case BUILT_IN_ATOMIC_FETCH_AND_N
:
10766 case BUILT_IN_ATOMIC_FETCH_NAND_N
:
10767 case BUILT_IN_ATOMIC_FETCH_XOR_N
:
10768 case BUILT_IN_ATOMIC_FETCH_OR_N
:
10770 orig_format
= false;
10771 /* Fallthru for parameter processing. */
10773 case BUILT_IN_SYNC_FETCH_AND_ADD_N
:
10774 case BUILT_IN_SYNC_FETCH_AND_SUB_N
:
10775 case BUILT_IN_SYNC_FETCH_AND_OR_N
:
10776 case BUILT_IN_SYNC_FETCH_AND_AND_N
:
10777 case BUILT_IN_SYNC_FETCH_AND_XOR_N
:
10778 case BUILT_IN_SYNC_FETCH_AND_NAND_N
:
10779 case BUILT_IN_SYNC_ADD_AND_FETCH_N
:
10780 case BUILT_IN_SYNC_SUB_AND_FETCH_N
:
10781 case BUILT_IN_SYNC_OR_AND_FETCH_N
:
10782 case BUILT_IN_SYNC_AND_AND_FETCH_N
:
10783 case BUILT_IN_SYNC_XOR_AND_FETCH_N
:
10784 case BUILT_IN_SYNC_NAND_AND_FETCH_N
:
10785 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
:
10786 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N
:
10787 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_N
:
10788 case BUILT_IN_SYNC_LOCK_RELEASE_N
:
10790 int n
= sync_resolve_size (function
, params
);
10791 tree new_function
, first_param
, result
;
10792 enum built_in_function fncode
;
10795 return error_mark_node
;
10797 fncode
= (enum built_in_function
)((int)orig_code
+ exact_log2 (n
) + 1);
10798 new_function
= builtin_decl_explicit (fncode
);
10799 if (!sync_resolve_params (loc
, function
, new_function
, params
,
10801 return error_mark_node
;
10803 first_param
= (*params
)[0];
10804 result
= build_function_call_vec (loc
, new_function
, params
, NULL
);
10805 if (result
== error_mark_node
)
10807 if (orig_code
!= BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
10808 && orig_code
!= BUILT_IN_SYNC_LOCK_RELEASE_N
10809 && orig_code
!= BUILT_IN_ATOMIC_STORE_N
)
10810 result
= sync_resolve_return (first_param
, result
, orig_format
);
10812 /* If new_return is set, assign function to that expr and cast the
10813 result to void since the generic interface returned void. */
10816 /* Cast function result from I{1,2,4,8,16} to the required type. */
10817 result
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (new_return
), result
);
10818 result
= build2 (MODIFY_EXPR
, TREE_TYPE (new_return
), new_return
,
10820 TREE_SIDE_EFFECTS (result
) = 1;
10821 protected_set_expr_location (result
, loc
);
10822 result
= convert (void_type_node
, result
);
10832 /* vector_types_compatible_elements_p is used in type checks of vectors
10833 values used as operands of binary operators. Where it returns true, and
10834 the other checks of the caller succeed (being vector types in he first
10835 place, and matching number of elements), we can just treat the types
10836 as essentially the same.
10837 Contrast with vector_targets_convertible_p, which is used for vector
10838 pointer types, and vector_types_convertible_p, which will allow
10839 language-specific matches under the control of flag_lax_vector_conversions,
10840 and might still require a conversion. */
10841 /* True if vector types T1 and T2 can be inputs to the same binary
10842 operator without conversion.
10843 We don't check the overall vector size here because some of our callers
10844 want to give different error messages when the vectors are compatible
10845 except for the element count. */
10848 vector_types_compatible_elements_p (tree t1
, tree t2
)
10850 bool opaque
= TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
);
10851 t1
= TREE_TYPE (t1
);
10852 t2
= TREE_TYPE (t2
);
10854 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
10856 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
|| c1
== FIXED_POINT_TYPE
)
10857 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
10858 || c2
== FIXED_POINT_TYPE
));
10860 t1
= c_common_signed_type (t1
);
10861 t2
= c_common_signed_type (t2
);
10862 /* Equality works here because c_common_signed_type uses
10863 TYPE_MAIN_VARIANT. */
10866 if (opaque
&& c1
== c2
10867 && (c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
)
10868 && TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
10873 /* Check for missing format attributes on function pointers. LTYPE is
10874 the new type or left-hand side type. RTYPE is the old type or
10875 right-hand side type. Returns TRUE if LTYPE is missing the desired
10879 check_missing_format_attribute (tree ltype
, tree rtype
)
10881 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
10884 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
10885 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
10890 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
10891 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
10899 /* Subscripting with type char is likely to lose on a machine where
10900 chars are signed. So warn on any machine, but optionally. Don't
10901 warn for unsigned char since that type is safe. Don't warn for
10902 signed char because anyone who uses that must have done so
10903 deliberately. Furthermore, we reduce the false positive load by
10904 warning only for non-constant value of type char. */
10907 warn_array_subscript_with_type_char (tree index
)
10909 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
10910 && TREE_CODE (index
) != INTEGER_CST
)
10911 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
10914 /* Implement -Wparentheses for the unexpected C precedence rules, to
10915 cover cases like x + y << z which readers are likely to
10916 misinterpret. We have seen an expression in which CODE is a binary
10917 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
10918 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
10919 CODE_RIGHT may be ERROR_MARK, which means that that side of the
10920 expression was not formed using a binary or unary operator, or it
10921 was enclosed in parentheses. */
10924 warn_about_parentheses (location_t loc
, enum tree_code code
,
10925 enum tree_code code_left
, tree arg_left
,
10926 enum tree_code code_right
, tree arg_right
)
10928 if (!warn_parentheses
)
10931 /* This macro tests that the expression ARG with original tree code
10932 CODE appears to be a boolean expression. or the result of folding a
10933 boolean expression. */
10934 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
10935 (truth_value_p (TREE_CODE (ARG)) \
10936 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
10937 /* Folding may create 0 or 1 integers from other expressions. */ \
10938 || ((CODE) != INTEGER_CST \
10939 && (integer_onep (ARG) || integer_zerop (ARG))))
10944 if (code_left
== PLUS_EXPR
)
10945 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
10946 "suggest parentheses around %<+%> inside %<<<%>");
10947 else if (code_right
== PLUS_EXPR
)
10948 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
10949 "suggest parentheses around %<+%> inside %<<<%>");
10950 else if (code_left
== MINUS_EXPR
)
10951 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
10952 "suggest parentheses around %<-%> inside %<<<%>");
10953 else if (code_right
== MINUS_EXPR
)
10954 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
10955 "suggest parentheses around %<-%> inside %<<<%>");
10959 if (code_left
== PLUS_EXPR
)
10960 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
10961 "suggest parentheses around %<+%> inside %<>>%>");
10962 else if (code_right
== PLUS_EXPR
)
10963 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
10964 "suggest parentheses around %<+%> inside %<>>%>");
10965 else if (code_left
== MINUS_EXPR
)
10966 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
10967 "suggest parentheses around %<-%> inside %<>>%>");
10968 else if (code_right
== MINUS_EXPR
)
10969 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
10970 "suggest parentheses around %<-%> inside %<>>%>");
10973 case TRUTH_ORIF_EXPR
:
10974 if (code_left
== TRUTH_ANDIF_EXPR
)
10975 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
10976 "suggest parentheses around %<&&%> within %<||%>");
10977 else if (code_right
== TRUTH_ANDIF_EXPR
)
10978 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
10979 "suggest parentheses around %<&&%> within %<||%>");
10983 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
10984 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
)
10985 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
10986 "suggest parentheses around arithmetic in operand of %<|%>");
10987 else if (code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
10988 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
10989 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
10990 "suggest parentheses around arithmetic in operand of %<|%>");
10991 /* Check cases like x|y==z */
10992 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
10993 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
10994 "suggest parentheses around comparison in operand of %<|%>");
10995 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
10996 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
10997 "suggest parentheses around comparison in operand of %<|%>");
10998 /* Check cases like !x | y */
10999 else if (code_left
== TRUTH_NOT_EXPR
11000 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
11001 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11002 "suggest parentheses around operand of "
11003 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
11007 if (code_left
== BIT_AND_EXPR
11008 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
)
11009 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11010 "suggest parentheses around arithmetic in operand of %<^%>");
11011 else if (code_right
== BIT_AND_EXPR
11012 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
11013 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
11014 "suggest parentheses around arithmetic in operand of %<^%>");
11015 /* Check cases like x^y==z */
11016 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
11017 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11018 "suggest parentheses around comparison in operand of %<^%>");
11019 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
11020 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
11021 "suggest parentheses around comparison in operand of %<^%>");
11025 if (code_left
== PLUS_EXPR
)
11026 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11027 "suggest parentheses around %<+%> in operand of %<&%>");
11028 else if (code_right
== PLUS_EXPR
)
11029 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
11030 "suggest parentheses around %<+%> in operand of %<&%>");
11031 else if (code_left
== MINUS_EXPR
)
11032 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11033 "suggest parentheses around %<-%> in operand of %<&%>");
11034 else if (code_right
== MINUS_EXPR
)
11035 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
11036 "suggest parentheses around %<-%> in operand of %<&%>");
11037 /* Check cases like x&y==z */
11038 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
11039 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11040 "suggest parentheses around comparison in operand of %<&%>");
11041 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
11042 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
11043 "suggest parentheses around comparison in operand of %<&%>");
11044 /* Check cases like !x & y */
11045 else if (code_left
== TRUTH_NOT_EXPR
11046 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
11047 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11048 "suggest parentheses around operand of "
11049 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
11053 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
11054 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11055 "suggest parentheses around comparison in operand of %<==%>");
11056 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
11057 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
11058 "suggest parentheses around comparison in operand of %<==%>");
11061 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
)
11062 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11063 "suggest parentheses around comparison in operand of %<!=%>");
11064 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
)
11065 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
11066 "suggest parentheses around comparison in operand of %<!=%>");
11070 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
11072 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
11073 && code_left
!= NE_EXPR
&& code_left
!= EQ_EXPR
11074 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left
)))
11075 warning_at (EXPR_LOC_OR_LOC (arg_left
, loc
), OPT_Wparentheses
,
11076 "comparisons like %<X<=Y<=Z%> do not "
11077 "have their mathematical meaning");
11078 else if (TREE_CODE_CLASS (code_right
) == tcc_comparison
11079 && code_right
!= NE_EXPR
&& code_right
!= EQ_EXPR
11080 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right
)))
11081 warning_at (EXPR_LOC_OR_LOC (arg_right
, loc
), OPT_Wparentheses
,
11082 "comparisons like %<X<=Y<=Z%> do not "
11083 "have their mathematical meaning");
11087 #undef NOT_A_BOOLEAN_EXPR_P
11090 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
11093 warn_for_unused_label (tree label
)
11095 if (!TREE_USED (label
))
11097 if (DECL_INITIAL (label
))
11098 warning (OPT_Wunused_label
, "label %q+D defined but not used", label
);
11100 warning (OPT_Wunused_label
, "label %q+D declared but not defined", label
);
11104 /* Warn for division by zero according to the value of DIVISOR. LOC
11105 is the location of the division operator. */
11108 warn_for_div_by_zero (location_t loc
, tree divisor
)
11110 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
11111 about division by zero. Do not issue a warning if DIVISOR has a
11112 floating-point type, since we consider 0.0/0.0 a valid way of
11113 generating a NaN. */
11114 if (c_inhibit_evaluation_warnings
== 0
11115 && (integer_zerop (divisor
) || fixed_zerop (divisor
)))
11116 warning_at (loc
, OPT_Wdiv_by_zero
, "division by zero");
11119 /* Subroutine of build_binary_op. Give warnings for comparisons
11120 between signed and unsigned quantities that may fail. Do the
11121 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
11122 so that casts will be considered, but default promotions won't
11125 LOCATION is the location of the comparison operator.
11127 The arguments of this function map directly to local variables
11128 of build_binary_op. */
11131 warn_for_sign_compare (location_t location
,
11132 tree orig_op0
, tree orig_op1
,
11133 tree op0
, tree op1
,
11134 tree result_type
, enum tree_code resultcode
)
11136 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
11137 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
11138 int unsignedp0
, unsignedp1
;
11140 /* In C++, check for comparison of different enum types. */
11141 if (c_dialect_cxx()
11142 && TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
11143 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
11144 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
11145 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
11147 warning_at (location
,
11148 OPT_Wsign_compare
, "comparison between types %qT and %qT",
11149 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
11152 /* Do not warn if the comparison is being done in a signed type,
11153 since the signed type will only be chosen if it can represent
11154 all the values of the unsigned type. */
11155 if (!TYPE_UNSIGNED (result_type
))
11157 /* Do not warn if both operands are unsigned. */
11158 else if (op0_signed
== op1_signed
)
11162 tree sop
, uop
, base_type
;
11166 sop
= orig_op0
, uop
= orig_op1
;
11168 sop
= orig_op1
, uop
= orig_op0
;
11170 STRIP_TYPE_NOPS (sop
);
11171 STRIP_TYPE_NOPS (uop
);
11172 base_type
= (TREE_CODE (result_type
) == COMPLEX_TYPE
11173 ? TREE_TYPE (result_type
) : result_type
);
11175 /* Do not warn if the signed quantity is an unsuffixed integer
11176 literal (or some static constant expression involving such
11177 literals or a conditional expression involving such literals)
11178 and it is non-negative. */
11179 if (tree_expr_nonnegative_warnv_p (sop
, &ovf
))
11181 /* Do not warn if the comparison is an equality operation, the
11182 unsigned quantity is an integral constant, and it would fit
11183 in the result if the result were signed. */
11184 else if (TREE_CODE (uop
) == INTEGER_CST
11185 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
11186 && int_fits_type_p (uop
, c_common_signed_type (base_type
)))
11188 /* In C, do not warn if the unsigned quantity is an enumeration
11189 constant and its maximum value would fit in the result if the
11190 result were signed. */
11191 else if (!c_dialect_cxx() && TREE_CODE (uop
) == INTEGER_CST
11192 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
11193 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
11194 c_common_signed_type (base_type
)))
11197 warning_at (location
,
11199 "comparison between signed and unsigned integer expressions");
11202 /* Warn if two unsigned values are being compared in a size larger
11203 than their original size, and one (and only one) is the result of
11204 a `~' operator. This comparison will always fail.
11206 Also warn if one operand is a constant, and the constant does not
11207 have all bits set that are set in the ~ operand when it is
11210 op0
= c_common_get_narrower (op0
, &unsignedp0
);
11211 op1
= c_common_get_narrower (op1
, &unsignedp1
);
11213 if ((TREE_CODE (op0
) == BIT_NOT_EXPR
)
11214 ^ (TREE_CODE (op1
) == BIT_NOT_EXPR
))
11216 if (TREE_CODE (op0
) == BIT_NOT_EXPR
)
11217 op0
= c_common_get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
11218 if (TREE_CODE (op1
) == BIT_NOT_EXPR
)
11219 op1
= c_common_get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
11221 if (host_integerp (op0
, 0) || host_integerp (op1
, 0))
11224 HOST_WIDE_INT constant
, mask
;
11228 if (host_integerp (op0
, 0))
11231 unsignedp
= unsignedp1
;
11232 constant
= tree_low_cst (op0
, 0);
11237 unsignedp
= unsignedp0
;
11238 constant
= tree_low_cst (op1
, 0);
11241 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
11242 if (bits
< TYPE_PRECISION (result_type
)
11243 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
11245 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
11246 if ((mask
& constant
) != mask
)
11249 warning (OPT_Wsign_compare
,
11250 "promoted ~unsigned is always non-zero");
11252 warning_at (location
, OPT_Wsign_compare
,
11253 "comparison of promoted ~unsigned with constant");
11257 else if (unsignedp0
&& unsignedp1
11258 && (TYPE_PRECISION (TREE_TYPE (op0
))
11259 < TYPE_PRECISION (result_type
))
11260 && (TYPE_PRECISION (TREE_TYPE (op1
))
11261 < TYPE_PRECISION (result_type
)))
11262 warning_at (location
, OPT_Wsign_compare
,
11263 "comparison of promoted ~unsigned with unsigned");
11267 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
11268 type via c_common_type. If -Wdouble-promotion is in use, and the
11269 conditions for warning have been met, issue a warning. GMSGID is
11270 the warning message. It must have two %T specifiers for the type
11271 that was converted (generally "float") and the type to which it was
11272 converted (generally "double), respectively. LOC is the location
11273 to which the awrning should refer. */
11276 do_warn_double_promotion (tree result_type
, tree type1
, tree type2
,
11277 const char *gmsgid
, location_t loc
)
11281 if (!warn_double_promotion
)
11283 /* If the conversion will not occur at run-time, there is no need to
11285 if (c_inhibit_evaluation_warnings
)
11287 if (TYPE_MAIN_VARIANT (result_type
) != double_type_node
11288 && TYPE_MAIN_VARIANT (result_type
) != complex_double_type_node
)
11290 if (TYPE_MAIN_VARIANT (type1
) == float_type_node
11291 || TYPE_MAIN_VARIANT (type1
) == complex_float_type_node
)
11292 source_type
= type1
;
11293 else if (TYPE_MAIN_VARIANT (type2
) == float_type_node
11294 || TYPE_MAIN_VARIANT (type2
) == complex_float_type_node
)
11295 source_type
= type2
;
11298 warning_at (loc
, OPT_Wdouble_promotion
, gmsgid
, source_type
, result_type
);
11301 /* Setup a TYPE_DECL node as a typedef representation.
11303 X is a TYPE_DECL for a typedef statement. Create a brand new
11304 ..._TYPE node (which will be just a variant of the existing
11305 ..._TYPE node with identical properties) and then install X
11306 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
11308 The whole point here is to end up with a situation where each
11309 and every ..._TYPE node the compiler creates will be uniquely
11310 associated with AT MOST one node representing a typedef name.
11311 This way, even though the compiler substitutes corresponding
11312 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
11313 early on, later parts of the compiler can always do the reverse
11314 translation and get back the corresponding typedef name. For
11317 typedef struct S MY_TYPE;
11320 Later parts of the compiler might only know that `object' was of
11321 type `struct S' if it were not for code just below. With this
11322 code however, later parts of the compiler see something like:
11324 struct S' == struct S
11325 typedef struct S' MY_TYPE;
11328 And they can then deduce (from the node for type struct S') that
11329 the original object declaration was:
11333 Being able to do this is important for proper support of protoize,
11334 and also for generating precise symbolic debugging information
11335 which takes full account of the programmer's (typedef) vocabulary.
11337 Obviously, we don't want to generate a duplicate ..._TYPE node if
11338 the TYPE_DECL node that we are now processing really represents a
11339 standard built-in type. */
11342 set_underlying_type (tree x
)
11344 if (x
== error_mark_node
)
11346 if (DECL_IS_BUILTIN (x
))
11348 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
11349 TYPE_NAME (TREE_TYPE (x
)) = x
;
11351 else if (TREE_TYPE (x
) != error_mark_node
11352 && DECL_ORIGINAL_TYPE (x
) == NULL_TREE
)
11354 tree tt
= TREE_TYPE (x
);
11355 DECL_ORIGINAL_TYPE (x
) = tt
;
11356 tt
= build_variant_type_copy (tt
);
11357 TYPE_STUB_DECL (tt
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
11358 TYPE_NAME (tt
) = x
;
11359 TREE_USED (tt
) = TREE_USED (x
);
11360 TREE_TYPE (x
) = tt
;
11364 /* Record the types used by the current global variable declaration
11365 being parsed, so that we can decide later to emit their debug info.
11366 Those types are in types_used_by_cur_var_decl, and we are going to
11367 store them in the types_used_by_vars_hash hash table.
11368 DECL is the declaration of the global variable that has been parsed. */
11371 record_types_used_by_current_var_decl (tree decl
)
11373 gcc_assert (decl
&& DECL_P (decl
) && TREE_STATIC (decl
));
11375 while (types_used_by_cur_var_decl
&& !types_used_by_cur_var_decl
->is_empty ())
11377 tree type
= types_used_by_cur_var_decl
->pop ();
11378 types_used_by_var_decl_insert (type
, decl
);
11382 /* If DECL is a typedef that is declared in the current function,
11383 record it for the purpose of -Wunused-local-typedefs. */
11386 record_locally_defined_typedef (tree decl
)
11388 struct c_language_function
*l
;
11390 if (!warn_unused_local_typedefs
11392 /* if this is not a locally defined typedef then we are not
11394 || !is_typedef_decl (decl
)
11395 || !decl_function_context (decl
))
11398 l
= (struct c_language_function
*) cfun
->language
;
11399 vec_safe_push (l
->local_typedefs
, decl
);
11402 /* If T is a TYPE_DECL declared locally, mark it as used. */
11405 maybe_record_typedef_use (tree t
)
11407 if (!is_typedef_decl (t
))
11410 TREE_USED (t
) = true;
11413 /* Warn if there are some unused locally defined typedefs in the
11414 current function. */
11417 maybe_warn_unused_local_typedefs (void)
11421 /* The number of times we have emitted -Wunused-local-typedefs
11422 warnings. If this is different from errorcount, that means some
11423 unrelated errors have been issued. In which case, we'll avoid
11424 emitting "unused-local-typedefs" warnings. */
11425 static int unused_local_typedefs_warn_count
;
11426 struct c_language_function
*l
;
11431 if ((l
= (struct c_language_function
*) cfun
->language
) == NULL
)
11434 if (warn_unused_local_typedefs
11435 && errorcount
== unused_local_typedefs_warn_count
)
11437 FOR_EACH_VEC_SAFE_ELT (l
->local_typedefs
, i
, decl
)
11438 if (!TREE_USED (decl
))
11439 warning_at (DECL_SOURCE_LOCATION (decl
),
11440 OPT_Wunused_local_typedefs
,
11441 "typedef %qD locally defined but not used", decl
);
11442 unused_local_typedefs_warn_count
= errorcount
;
11445 vec_free (l
->local_typedefs
);
11448 /* The C and C++ parsers both use vectors to hold function arguments.
11449 For efficiency, we keep a cache of unused vectors. This is the
11452 typedef vec
<tree
, va_gc
> *tree_gc_vec
;
11453 static GTY((deletable
)) vec
<tree_gc_vec
, va_gc
> *tree_vector_cache
;
11455 /* Return a new vector from the cache. If the cache is empty,
11456 allocate a new vector. These vectors are GC'ed, so it is OK if the
11457 pointer is not released.. */
11460 make_tree_vector (void)
11462 if (tree_vector_cache
&& !tree_vector_cache
->is_empty ())
11463 return tree_vector_cache
->pop ();
11466 /* Passing 0 to vec::alloc returns NULL, and our callers require
11467 that we always return a non-NULL value. The vector code uses
11468 4 when growing a NULL vector, so we do too. */
11469 vec
<tree
, va_gc
> *v
;
11475 /* Release a vector of trees back to the cache. */
11478 release_tree_vector (vec
<tree
, va_gc
> *vec
)
11483 vec_safe_push (tree_vector_cache
, vec
);
11487 /* Get a new tree vector holding a single tree. */
11490 make_tree_vector_single (tree t
)
11492 vec
<tree
, va_gc
> *ret
= make_tree_vector ();
11493 ret
->quick_push (t
);
11497 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */
11500 make_tree_vector_from_list (tree list
)
11502 vec
<tree
, va_gc
> *ret
= make_tree_vector ();
11503 for (; list
; list
= TREE_CHAIN (list
))
11504 vec_safe_push (ret
, TREE_VALUE (list
));
11508 /* Get a new tree vector which is a copy of an existing one. */
11511 make_tree_vector_copy (const vec
<tree
, va_gc
> *orig
)
11513 vec
<tree
, va_gc
> *ret
;
11517 ret
= make_tree_vector ();
11518 vec_safe_reserve (ret
, vec_safe_length (orig
));
11519 FOR_EACH_VEC_SAFE_ELT (orig
, ix
, t
)
11520 ret
->quick_push (t
);
11524 /* Return true if KEYWORD starts a type specifier. */
11527 keyword_begins_type_specifier (enum rid keyword
)
11543 case RID_DFLOAT128
:
11563 /* Return true if KEYWORD names a type qualifier. */
11566 keyword_is_type_qualifier (enum rid keyword
)
11580 /* Return true if KEYWORD names a storage class specifier.
11582 RID_TYPEDEF is not included in this list despite `typedef' being
11583 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
11584 such for syntactic convenience only. */
11587 keyword_is_storage_class_specifier (enum rid keyword
)
11603 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
11606 keyword_is_function_specifier (enum rid keyword
)
11620 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
11621 declaration-specifier (C99 6.7). */
11624 keyword_is_decl_specifier (enum rid keyword
)
11626 if (keyword_is_storage_class_specifier (keyword
)
11627 || keyword_is_type_qualifier (keyword
)
11628 || keyword_is_function_specifier (keyword
))
11635 case RID_CONSTEXPR
:
11642 /* Initialize language-specific-bits of tree_contains_struct. */
11645 c_common_init_ts (void)
11647 MARK_TS_TYPED (C_MAYBE_CONST_EXPR
);
11648 MARK_TS_TYPED (EXCESS_PRECISION_EXPR
);
11649 MARK_TS_TYPED (ARRAY_NOTATION_REF
);
11652 /* Build a user-defined numeric literal out of an integer constant type VALUE
11653 with identifier SUFFIX. */
11656 build_userdef_literal (tree suffix_id
, tree value
,
11657 enum overflow_type overflow
, tree num_string
)
11659 tree literal
= make_node (USERDEF_LITERAL
);
11660 USERDEF_LITERAL_SUFFIX_ID (literal
) = suffix_id
;
11661 USERDEF_LITERAL_VALUE (literal
) = value
;
11662 USERDEF_LITERAL_OVERFLOW (literal
) = overflow
;
11663 USERDEF_LITERAL_NUM_STRING (literal
) = num_string
;
11667 /* For vector[index], convert the vector to a
11668 pointer of the underlying type. */
11670 convert_vector_to_pointer_for_subscript (location_t loc
,
11671 tree
* vecp
, tree index
)
11673 if (TREE_CODE (TREE_TYPE (*vecp
)) == VECTOR_TYPE
)
11675 tree type
= TREE_TYPE (*vecp
);
11678 if (TREE_CODE (index
) == INTEGER_CST
)
11679 if (!host_integerp (index
, 1)
11680 || ((unsigned HOST_WIDE_INT
) tree_low_cst (index
, 1)
11681 >= TYPE_VECTOR_SUBPARTS (type
)))
11682 warning_at (loc
, OPT_Warray_bounds
, "index value is out of bound");
11684 c_common_mark_addressable_vec (*vecp
);
11685 type
= build_qualified_type (TREE_TYPE (type
), TYPE_QUALS (type
));
11686 type
= build_pointer_type (type
);
11687 type1
= build_pointer_type (TREE_TYPE (*vecp
));
11688 *vecp
= build1 (ADDR_EXPR
, type1
, *vecp
);
11689 *vecp
= convert (type
, *vecp
);
11693 /* Determine which of the operands, if any, is a scalar that needs to be
11694 converted to a vector, for the range of operations. */
11696 scalar_to_vector (location_t loc
, enum tree_code code
, tree op0
, tree op1
,
11699 tree type0
= TREE_TYPE (op0
);
11700 tree type1
= TREE_TYPE (op1
);
11701 bool integer_only_op
= false;
11702 enum stv_conv ret
= stv_firstarg
;
11704 gcc_assert (TREE_CODE (type0
) == VECTOR_TYPE
11705 || TREE_CODE (type1
) == VECTOR_TYPE
);
11708 /* Most GENERIC binary expressions require homogeneous arguments.
11709 LSHIFT_EXPR and RSHIFT_EXPR are exceptions and accept a first
11710 argument that is a vector and a second one that is a scalar, so
11711 we never return stv_secondarg for them. */
11714 if (TREE_CODE (type0
) == INTEGER_TYPE
11715 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
11717 if (unsafe_conversion_p (TREE_TYPE (type1
), op0
, false))
11720 error_at (loc
, "conversion of scalar %qT to vector %qT "
11721 "involves truncation", type0
, type1
);
11725 return stv_firstarg
;
11732 integer_only_op
= true;
11733 /* ... fall through ... */
11735 case VEC_COND_EXPR
:
11740 case TRUNC_DIV_EXPR
:
11741 case CEIL_DIV_EXPR
:
11742 case FLOOR_DIV_EXPR
:
11743 case ROUND_DIV_EXPR
:
11744 case EXACT_DIV_EXPR
:
11745 case TRUNC_MOD_EXPR
:
11746 case FLOOR_MOD_EXPR
:
11754 /* What about UNLT_EXPR? */
11755 if (TREE_CODE (type0
) == VECTOR_TYPE
)
11758 ret
= stv_secondarg
;
11759 /* Swap TYPE0 with TYPE1 and OP0 with OP1 */
11760 tmp
= type0
; type0
= type1
; type1
= tmp
;
11761 tmp
= op0
; op0
= op1
; op1
= tmp
;
11764 if (TREE_CODE (type0
) == INTEGER_TYPE
11765 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
11767 if (unsafe_conversion_p (TREE_TYPE (type1
), op0
, false))
11770 error_at (loc
, "conversion of scalar %qT to vector %qT "
11771 "involves truncation", type0
, type1
);
11776 else if (!integer_only_op
11777 /* Allow integer --> real conversion if safe. */
11778 && (TREE_CODE (type0
) == REAL_TYPE
11779 || TREE_CODE (type0
) == INTEGER_TYPE
)
11780 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (type1
)))
11782 if (unsafe_conversion_p (TREE_TYPE (type1
), op0
, false))
11785 error_at (loc
, "conversion of scalar %qT to vector %qT "
11786 "involves truncation", type0
, type1
);
11795 return stv_nothing
;
11798 /* Return true iff ALIGN is an integral constant that is a fundamental
11799 alignment, as defined by [basic.align] in the c++-11
11804 [A fundamental alignment is represented by an alignment less than or
11805 equal to the greatest alignment supported by the implementation
11806 in all contexts, which is equal to
11807 alignof(max_align_t)]. */
11810 cxx_fundamental_alignment_p (unsigned align
)
11812 return (align
<= MAX (TYPE_ALIGN (long_long_integer_type_node
),
11813 TYPE_ALIGN (long_double_type_node
)));
11816 #include "gt-c-family-c-common.h"