1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992-2019 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/>. */
20 #define GCC_C_COMMON_C
24 #include "coretypes.h"
30 #include "gimple-expr.h"
32 #include "stringpool.h"
34 #include "diagnostic.h"
36 #include "stor-layout.h"
40 #include "trans-mem.h"
42 #include "common/common-target.h"
43 #include "langhooks.h"
44 #include "tree-inline.h"
46 #include "tree-iterator.h"
49 #include "substring-locations.h"
50 #include "spellcheck.h"
53 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
55 /* Mode used to build pointers (VOIDmode means ptr_mode). */
57 machine_mode c_default_pointer_mode
= VOIDmode
;
59 /* The following symbols are subsumed in the c_global_trees array, and
60 listed here individually for documentation purposes.
62 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
64 tree short_integer_type_node;
65 tree long_integer_type_node;
66 tree long_long_integer_type_node;
68 tree short_unsigned_type_node;
69 tree long_unsigned_type_node;
70 tree long_long_unsigned_type_node;
72 tree truthvalue_type_node;
73 tree truthvalue_false_node;
74 tree truthvalue_true_node;
76 tree ptrdiff_type_node;
78 tree unsigned_char_type_node;
79 tree signed_char_type_node;
83 tree char16_type_node;
84 tree char32_type_node;
87 tree double_type_node;
88 tree long_double_type_node;
90 tree complex_integer_type_node;
91 tree complex_float_type_node;
92 tree complex_double_type_node;
93 tree complex_long_double_type_node;
95 tree dfloat32_type_node;
96 tree dfloat64_type_node;
97 tree_dfloat128_type_node;
100 tree intHI_type_node;
101 tree intSI_type_node;
102 tree intDI_type_node;
103 tree intTI_type_node;
105 tree unsigned_intQI_type_node;
106 tree unsigned_intHI_type_node;
107 tree unsigned_intSI_type_node;
108 tree unsigned_intDI_type_node;
109 tree unsigned_intTI_type_node;
111 tree widest_integer_literal_type_node;
112 tree widest_unsigned_literal_type_node;
114 Nodes for types `void *' and `const void *'.
116 tree ptr_type_node, const_ptr_type_node;
118 Nodes for types `char *' and `const char *'.
120 tree string_type_node, const_string_type_node;
122 Type `char[SOMENUMBER]'.
123 Used when an array of char is needed and the size is irrelevant.
125 tree char_array_type_node;
127 Type `wchar_t[SOMENUMBER]' or something like it.
128 Used when a wide string literal is created.
130 tree wchar_array_type_node;
132 Type `char8_t[SOMENUMBER]' or something like it.
133 Used when a UTF-8 string literal is created.
135 tree char8_array_type_node;
137 Type `char16_t[SOMENUMBER]' or something like it.
138 Used when a UTF-16 string literal is created.
140 tree char16_array_type_node;
142 Type `char32_t[SOMENUMBER]' or something like it.
143 Used when a UTF-32 string literal is created.
145 tree char32_array_type_node;
147 Type `int ()' -- used for implicit declaration of functions.
149 tree default_function_type;
151 A VOID_TYPE node, packaged in a TREE_LIST.
155 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
156 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
157 VAR_DECLS, but C++ does.)
159 tree function_name_decl_node;
160 tree pretty_function_name_decl_node;
161 tree c99_function_name_decl_node;
163 Stack of nested function name VAR_DECLs.
165 tree saved_function_name_decls;
169 tree c_global_trees
[CTI_MAX
];
171 /* Switches common to the C front ends. */
173 /* Nonzero means don't output line number information. */
175 char flag_no_line_commands
;
177 /* Nonzero causes -E output not to be done, but directives such as
178 #define that have side effects are still obeyed. */
182 /* Nonzero means dump macros in some fashion. */
184 char flag_dump_macros
;
186 /* Nonzero means pass #include lines through to the output. */
188 char flag_dump_includes
;
190 /* Nonzero means process PCH files while preprocessing. */
192 bool flag_pch_preprocess
;
194 /* The file name to which we should write a precompiled header, or
195 NULL if no header will be written in this compile. */
197 const char *pch_file
;
199 /* Nonzero if an ISO standard was selected. It rejects macros in the
203 /* C/ObjC language option variables. */
206 /* Nonzero means allow type mismatches in conditional expressions;
207 just make their values `void'. */
209 int flag_cond_mismatch
;
211 /* Nonzero means enable C89 Amendment 1 features. */
215 /* Nonzero means use the ISO C99 (or C11) dialect of C. */
219 /* Nonzero means use the ISO C11 dialect of C. */
223 /* Nonzero means use the ISO C2X dialect of C. */
227 /* Nonzero means that we have builtin functions, and main is an int. */
232 /* ObjC language option variables. */
235 /* Tells the compiler that this is a special run. Do not perform any
236 compiling, instead we are to test some platform dependent features
237 and output a C header file with appropriate definitions. */
239 int print_struct_values
;
241 /* Tells the compiler what is the constant string class for ObjC. */
243 const char *constant_string_class_name
;
246 /* C++ language option variables. */
248 /* The reference version of the ABI for -Wabi. */
250 int warn_abi_version
= -1;
252 /* Nonzero means generate separate instantiation control files and
253 juggle them at link time. */
255 int flag_use_repository
;
257 /* The C++ dialect being used. Default set in c_common_post_options. */
259 enum cxx_dialect cxx_dialect
= cxx_unset
;
261 /* Maximum template instantiation depth. This limit exists to limit the
262 time it takes to notice excessively recursive template instantiations.
264 The default is lower than the 1024 recommended by the C++0x standard
265 because G++ runs out of stack before 1024 with highly recursive template
266 argument deduction substitution (g++.dg/cpp0x/enum11.C). */
268 int max_tinst_depth
= 900;
270 /* The elements of `ridpointers' are identifier nodes for the reserved
271 type names and storage classes. It is indexed by a RID_... value. */
274 tree (*make_fname_decl
) (location_t
, tree
, int);
276 /* Nonzero means don't warn about problems that occur when the code is
278 int c_inhibit_evaluation_warnings
;
280 /* Whether we are building a boolean conversion inside
281 convert_for_assignment, or some other late binary operation. If
282 build_binary_op is called for C (from code shared by C and C++) in
283 this case, then the operands have already been folded and the
284 result will not be folded again, so C_MAYBE_CONST_EXPR should not
286 bool in_late_binary_op
;
288 /* Whether lexing has been completed, so subsequent preprocessor
289 errors should use the compiler's input_location. */
290 bool done_lexing
= false;
292 /* Information about how a function name is generated. */
295 tree
*const decl
; /* pointer to the VAR_DECL. */
296 const unsigned rid
; /* RID number for the identifier. */
297 const int pretty
; /* How pretty is it? */
300 /* The three ways of getting then name of the current function. */
302 const struct fname_var_t fname_vars
[] =
304 /* C99 compliant __func__, must be first. */
305 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
306 /* GCC __FUNCTION__ compliant. */
307 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
308 /* GCC __PRETTY_FUNCTION__ compliant. */
309 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
313 /* Global visibility options. */
314 struct visibility_flags visibility_options
;
316 static tree
check_case_value (location_t
, tree
);
317 static bool check_case_bounds (location_t
, tree
, tree
, tree
*, tree
*,
321 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
322 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
324 /* Reserved words. The third field is a mask: keywords are disabled
325 if they match the mask.
328 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
329 C --std=c99: D_CXXONLY | D_OBJC
330 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
331 C++ --std=c++98: D_CONLY | D_CXX11 | D_OBJC
332 C++ --std=c++11: D_CONLY | D_OBJC
333 ObjC++ is like C++ except that D_OBJC is not set
335 If -fno-asm is used, D_ASM is added to the mask. If
336 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
337 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
338 In C with -Wc++-compat, we warn if D_CXXWARN is set.
340 Note the complication of the D_CXX_OBJC keywords. These are
341 reserved words such as 'class'. In C++, 'class' is a reserved
342 word. In Objective-C++ it is too. In Objective-C, it is a
343 reserved word too, but only if it follows an '@' sign.
345 const struct c_common_resword c_common_reswords
[] =
347 { "_Alignas", RID_ALIGNAS
, D_CONLY
},
348 { "_Alignof", RID_ALIGNOF
, D_CONLY
},
349 { "_Atomic", RID_ATOMIC
, D_CONLY
},
350 { "_Bool", RID_BOOL
, D_CONLY
},
351 { "_Complex", RID_COMPLEX
, 0 },
352 { "_Imaginary", RID_IMAGINARY
, D_CONLY
},
353 { "_Float16", RID_FLOAT16
, D_CONLY
},
354 { "_Float32", RID_FLOAT32
, D_CONLY
},
355 { "_Float64", RID_FLOAT64
, D_CONLY
},
356 { "_Float128", RID_FLOAT128
, D_CONLY
},
357 { "_Float32x", RID_FLOAT32X
, D_CONLY
},
358 { "_Float64x", RID_FLOAT64X
, D_CONLY
},
359 { "_Float128x", RID_FLOAT128X
, D_CONLY
},
360 { "_Decimal32", RID_DFLOAT32
, D_CONLY
| D_EXT
},
361 { "_Decimal64", RID_DFLOAT64
, D_CONLY
| D_EXT
},
362 { "_Decimal128", RID_DFLOAT128
, D_CONLY
| D_EXT
},
363 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
364 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
365 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
366 { "_Static_assert", RID_STATIC_ASSERT
, D_CONLY
},
367 { "_Noreturn", RID_NORETURN
, D_CONLY
},
368 { "_Generic", RID_GENERIC
, D_CONLY
},
369 { "_Thread_local", RID_THREAD
, D_CONLY
},
370 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
371 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
372 { "__alignof", RID_ALIGNOF
, 0 },
373 { "__alignof__", RID_ALIGNOF
, 0 },
374 { "__asm", RID_ASM
, 0 },
375 { "__asm__", RID_ASM
, 0 },
376 { "__attribute", RID_ATTRIBUTE
, 0 },
377 { "__attribute__", RID_ATTRIBUTE
, 0 },
378 { "__auto_type", RID_AUTO_TYPE
, D_CONLY
},
379 { "__bases", RID_BASES
, D_CXXONLY
},
380 { "__builtin_addressof", RID_ADDRESSOF
, D_CXXONLY
},
381 { "__builtin_call_with_static_chain",
382 RID_BUILTIN_CALL_WITH_STATIC_CHAIN
, D_CONLY
},
383 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
384 { "__builtin_complex", RID_BUILTIN_COMPLEX
, D_CONLY
},
385 { "__builtin_convertvector", RID_BUILTIN_CONVERTVECTOR
, 0 },
386 { "__builtin_has_attribute", RID_BUILTIN_HAS_ATTRIBUTE
, 0 },
387 { "__builtin_launder", RID_BUILTIN_LAUNDER
, D_CXXONLY
},
388 { "__builtin_shuffle", RID_BUILTIN_SHUFFLE
, 0 },
389 { "__builtin_tgmath", RID_BUILTIN_TGMATH
, D_CONLY
},
390 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
391 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
392 { "__builtin_va_arg", RID_VA_ARG
, 0 },
393 { "__complex", RID_COMPLEX
, 0 },
394 { "__complex__", RID_COMPLEX
, 0 },
395 { "__const", RID_CONST
, 0 },
396 { "__const__", RID_CONST
, 0 },
397 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
398 { "__direct_bases", RID_DIRECT_BASES
, D_CXXONLY
},
399 { "__extension__", RID_EXTENSION
, 0 },
400 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
401 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
402 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
403 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
404 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
405 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
406 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
407 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
408 { "__has_unique_object_representations", RID_HAS_UNIQUE_OBJ_REPRESENTATIONS
,
410 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
411 { "__imag", RID_IMAGPART
, 0 },
412 { "__imag__", RID_IMAGPART
, 0 },
413 { "__inline", RID_INLINE
, 0 },
414 { "__inline__", RID_INLINE
, 0 },
415 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
416 { "__is_aggregate", RID_IS_AGGREGATE
, D_CXXONLY
},
417 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
418 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
419 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
420 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
421 { "__is_final", RID_IS_FINAL
, D_CXXONLY
},
422 { "__is_literal_type", RID_IS_LITERAL_TYPE
, D_CXXONLY
},
423 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
424 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
425 { "__is_same_as", RID_IS_SAME_AS
, D_CXXONLY
},
426 { "__is_standard_layout", RID_IS_STD_LAYOUT
, D_CXXONLY
},
427 { "__is_trivial", RID_IS_TRIVIAL
, D_CXXONLY
},
428 { "__is_trivially_assignable", RID_IS_TRIVIALLY_ASSIGNABLE
, D_CXXONLY
},
429 { "__is_trivially_constructible", RID_IS_TRIVIALLY_CONSTRUCTIBLE
, D_CXXONLY
},
430 { "__is_trivially_copyable", RID_IS_TRIVIALLY_COPYABLE
, D_CXXONLY
},
431 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
432 { "__label__", RID_LABEL
, 0 },
433 { "__null", RID_NULL
, 0 },
434 { "__real", RID_REALPART
, 0 },
435 { "__real__", RID_REALPART
, 0 },
436 { "__restrict", RID_RESTRICT
, 0 },
437 { "__restrict__", RID_RESTRICT
, 0 },
438 { "__signed", RID_SIGNED
, 0 },
439 { "__signed__", RID_SIGNED
, 0 },
440 { "__thread", RID_THREAD
, 0 },
441 { "__transaction_atomic", RID_TRANSACTION_ATOMIC
, 0 },
442 { "__transaction_relaxed", RID_TRANSACTION_RELAXED
, 0 },
443 { "__transaction_cancel", RID_TRANSACTION_CANCEL
, 0 },
444 { "__typeof", RID_TYPEOF
, 0 },
445 { "__typeof__", RID_TYPEOF
, 0 },
446 { "__underlying_type", RID_UNDERLYING_TYPE
, D_CXXONLY
},
447 { "__volatile", RID_VOLATILE
, 0 },
448 { "__volatile__", RID_VOLATILE
, 0 },
449 { "__GIMPLE", RID_GIMPLE
, D_CONLY
},
450 { "__PHI", RID_PHI
, D_CONLY
},
451 { "__RTL", RID_RTL
, D_CONLY
},
452 { "alignas", RID_ALIGNAS
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
453 { "alignof", RID_ALIGNOF
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
454 { "asm", RID_ASM
, D_ASM
},
455 { "auto", RID_AUTO
, 0 },
456 { "bool", RID_BOOL
, D_CXXONLY
| D_CXXWARN
},
457 { "break", RID_BREAK
, 0 },
458 { "case", RID_CASE
, 0 },
459 { "catch", RID_CATCH
, D_CXX_OBJC
| D_CXXWARN
},
460 { "char", RID_CHAR
, 0 },
461 { "char8_t", RID_CHAR8
, D_CXX_CHAR8_T_FLAGS
| D_CXXWARN
},
462 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
463 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
464 { "class", RID_CLASS
, D_CXX_OBJC
| D_CXXWARN
},
465 { "const", RID_CONST
, 0 },
466 { "constexpr", RID_CONSTEXPR
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
467 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
468 { "continue", RID_CONTINUE
, 0 },
469 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
470 { "default", RID_DEFAULT
, 0 },
471 { "delete", RID_DELETE
, D_CXXONLY
| D_CXXWARN
},
473 { "double", RID_DOUBLE
, 0 },
474 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
475 { "else", RID_ELSE
, 0 },
476 { "enum", RID_ENUM
, 0 },
477 { "explicit", RID_EXPLICIT
, D_CXXONLY
| D_CXXWARN
},
478 { "export", RID_EXPORT
, D_CXXONLY
| D_CXXWARN
},
479 { "extern", RID_EXTERN
, 0 },
480 { "false", RID_FALSE
, D_CXXONLY
| D_CXXWARN
},
481 { "float", RID_FLOAT
, 0 },
482 { "for", RID_FOR
, 0 },
483 { "friend", RID_FRIEND
, D_CXXONLY
| D_CXXWARN
},
484 { "goto", RID_GOTO
, 0 },
486 { "inline", RID_INLINE
, D_EXT89
},
487 { "int", RID_INT
, 0 },
488 { "long", RID_LONG
, 0 },
489 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
490 { "namespace", RID_NAMESPACE
, D_CXXONLY
| D_CXXWARN
},
491 { "new", RID_NEW
, D_CXXONLY
| D_CXXWARN
},
492 { "noexcept", RID_NOEXCEPT
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
493 { "nullptr", RID_NULLPTR
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
494 { "operator", RID_OPERATOR
, D_CXXONLY
| D_CXXWARN
},
495 { "private", RID_PRIVATE
, D_CXX_OBJC
| D_CXXWARN
},
496 { "protected", RID_PROTECTED
, D_CXX_OBJC
| D_CXXWARN
},
497 { "public", RID_PUBLIC
, D_CXX_OBJC
| D_CXXWARN
},
498 { "register", RID_REGISTER
, 0 },
499 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
500 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
501 { "return", RID_RETURN
, 0 },
502 { "short", RID_SHORT
, 0 },
503 { "signed", RID_SIGNED
, 0 },
504 { "sizeof", RID_SIZEOF
, 0 },
505 { "static", RID_STATIC
, 0 },
506 { "static_assert", RID_STATIC_ASSERT
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
507 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
508 { "struct", RID_STRUCT
, 0 },
509 { "switch", RID_SWITCH
, 0 },
510 { "template", RID_TEMPLATE
, D_CXXONLY
| D_CXXWARN
},
511 { "this", RID_THIS
, D_CXXONLY
| D_CXXWARN
},
512 { "thread_local", RID_THREAD
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
513 { "throw", RID_THROW
, D_CXX_OBJC
| D_CXXWARN
},
514 { "true", RID_TRUE
, D_CXXONLY
| D_CXXWARN
},
515 { "try", RID_TRY
, D_CXX_OBJC
| D_CXXWARN
},
516 { "typedef", RID_TYPEDEF
, 0 },
517 { "typename", RID_TYPENAME
, D_CXXONLY
| D_CXXWARN
},
518 { "typeid", RID_TYPEID
, D_CXXONLY
| D_CXXWARN
},
519 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
520 { "union", RID_UNION
, 0 },
521 { "unsigned", RID_UNSIGNED
, 0 },
522 { "using", RID_USING
, D_CXXONLY
| D_CXXWARN
},
523 { "virtual", RID_VIRTUAL
, D_CXXONLY
| D_CXXWARN
},
524 { "void", RID_VOID
, 0 },
525 { "volatile", RID_VOLATILE
, 0 },
526 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
527 { "while", RID_WHILE
, 0 },
528 { "__is_assignable", RID_IS_ASSIGNABLE
, D_CXXONLY
},
529 { "__is_constructible", RID_IS_CONSTRUCTIBLE
, D_CXXONLY
},
531 /* C++ transactional memory. */
532 { "synchronized", RID_SYNCHRONIZED
, D_CXX_OBJC
| D_TRANSMEM
},
533 { "atomic_noexcept", RID_ATOMIC_NOEXCEPT
, D_CXXONLY
| D_TRANSMEM
},
534 { "atomic_cancel", RID_ATOMIC_CANCEL
, D_CXXONLY
| D_TRANSMEM
},
535 { "atomic_commit", RID_TRANSACTION_ATOMIC
, D_CXXONLY
| D_TRANSMEM
},
537 /* Concepts-related keywords */
538 { "concept", RID_CONCEPT
, D_CXX_CONCEPTS_FLAGS
| D_CXXWARN
},
539 { "requires", RID_REQUIRES
, D_CXX_CONCEPTS_FLAGS
| D_CXXWARN
},
541 /* These Objective-C keywords are recognized only immediately after
543 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
544 { "defs", RID_AT_DEFS
, D_OBJC
},
545 { "encode", RID_AT_ENCODE
, D_OBJC
},
546 { "end", RID_AT_END
, D_OBJC
},
547 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
548 { "interface", RID_AT_INTERFACE
, D_OBJC
},
549 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
550 { "selector", RID_AT_SELECTOR
, D_OBJC
},
551 { "finally", RID_AT_FINALLY
, D_OBJC
},
552 { "optional", RID_AT_OPTIONAL
, D_OBJC
},
553 { "required", RID_AT_REQUIRED
, D_OBJC
},
554 { "property", RID_AT_PROPERTY
, D_OBJC
},
555 { "package", RID_AT_PACKAGE
, D_OBJC
},
556 { "synthesize", RID_AT_SYNTHESIZE
, D_OBJC
},
557 { "dynamic", RID_AT_DYNAMIC
, D_OBJC
},
558 /* These are recognized only in protocol-qualifier context
560 { "bycopy", RID_BYCOPY
, D_OBJC
},
561 { "byref", RID_BYREF
, D_OBJC
},
562 { "in", RID_IN
, D_OBJC
},
563 { "inout", RID_INOUT
, D_OBJC
},
564 { "oneway", RID_ONEWAY
, D_OBJC
},
565 { "out", RID_OUT
, D_OBJC
},
566 /* These are recognized inside a property attribute list */
567 { "assign", RID_ASSIGN
, D_OBJC
},
568 { "copy", RID_COPY
, D_OBJC
},
569 { "getter", RID_GETTER
, D_OBJC
},
570 { "nonatomic", RID_NONATOMIC
, D_OBJC
},
571 { "readonly", RID_READONLY
, D_OBJC
},
572 { "readwrite", RID_READWRITE
, D_OBJC
},
573 { "retain", RID_RETAIN
, D_OBJC
},
574 { "setter", RID_SETTER
, D_OBJC
},
577 const unsigned int num_c_common_reswords
=
578 sizeof c_common_reswords
/ sizeof (struct c_common_resword
);
580 /* Return identifier for address space AS. */
583 c_addr_space_name (addr_space_t as
)
585 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
586 gcc_assert (ridpointers
[rid
]);
587 return IDENTIFIER_POINTER (ridpointers
[rid
]);
590 /* Push current bindings for the function name VAR_DECLS. */
593 start_fname_decls (void)
596 tree saved
= NULL_TREE
;
598 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
600 tree decl
= *fname_vars
[ix
].decl
;
604 saved
= tree_cons (decl
, build_int_cst (integer_type_node
, ix
),
606 *fname_vars
[ix
].decl
= NULL_TREE
;
609 if (saved
|| saved_function_name_decls
)
610 /* Normally they'll have been NULL, so only push if we've got a
611 stack, or they are non-NULL. */
612 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
613 saved_function_name_decls
);
616 /* Finish up the current bindings, adding them into the current function's
617 statement tree. This must be done _before_ finish_stmt_tree is called.
618 If there is no current function, we must be at file scope and no statements
619 are involved. Pop the previous bindings. */
622 finish_fname_decls (void)
625 tree stmts
= NULL_TREE
;
626 tree stack
= saved_function_name_decls
;
628 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
629 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
633 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
635 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
636 bodyp
= &BIND_EXPR_BODY (*bodyp
);
638 append_to_statement_list_force (*bodyp
, &stmts
);
642 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
643 *fname_vars
[ix
].decl
= NULL_TREE
;
647 /* We had saved values, restore them. */
650 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
652 tree decl
= TREE_PURPOSE (saved
);
653 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
655 *fname_vars
[ix
].decl
= decl
;
657 stack
= TREE_CHAIN (stack
);
659 saved_function_name_decls
= stack
;
662 /* Return the text name of the current function, suitably prettified
663 by PRETTY_P. Return string must be freed by caller. */
666 fname_as_string (int pretty_p
)
668 const char *name
= "top level";
671 cpp_string cstr
= { 0, 0 }, strname
;
679 if (current_function_decl
)
680 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
682 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
684 namep
= XNEWVEC (char, len
);
685 snprintf (namep
, len
, "\"%s\"", name
);
686 strname
.text
= (unsigned char *) namep
;
687 strname
.len
= len
- 1;
689 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
692 return (const char *) cstr
.text
;
698 /* Return the VAR_DECL for a const char array naming the current
699 function. If the VAR_DECL has not yet been created, create it
700 now. RID indicates how it should be formatted and IDENTIFIER_NODE
701 ID is its name (unfortunately C and C++ hold the RID values of
702 keywords in different places, so we can't derive RID from ID in
703 this language independent code. LOC is the location of the
707 fname_decl (location_t loc
, unsigned int rid
, tree id
)
710 tree decl
= NULL_TREE
;
712 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
713 if (fname_vars
[ix
].rid
== rid
)
716 decl
= *fname_vars
[ix
].decl
;
719 /* If a tree is built here, it would normally have the lineno of
720 the current statement. Later this tree will be moved to the
721 beginning of the function and this line number will be wrong.
722 To avoid this problem set the lineno to 0 here; that prevents
723 it from appearing in the RTL. */
725 location_t saved_location
= input_location
;
726 input_location
= UNKNOWN_LOCATION
;
728 stmts
= push_stmt_list ();
729 decl
= (*make_fname_decl
) (loc
, id
, fname_vars
[ix
].pretty
);
730 stmts
= pop_stmt_list (stmts
);
731 if (!IS_EMPTY_STMT (stmts
))
732 saved_function_name_decls
733 = tree_cons (decl
, stmts
, saved_function_name_decls
);
734 *fname_vars
[ix
].decl
= decl
;
735 input_location
= saved_location
;
737 if (!ix
&& !current_function_decl
)
738 pedwarn (loc
, 0, "%qD is not defined outside of function scope", decl
);
743 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
746 fix_string_type (tree value
)
748 int length
= TREE_STRING_LENGTH (value
);
750 tree e_type
, i_type
, a_type
;
752 /* Compute the number of elements, for the array type. */
753 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
756 e_type
= char_type_node
;
758 else if (flag_char8_t
&& TREE_TYPE (value
) == char8_array_type_node
)
760 charsz
= TYPE_PRECISION (char8_type_node
) / BITS_PER_UNIT
;
761 e_type
= char8_type_node
;
763 else if (TREE_TYPE (value
) == char16_array_type_node
)
765 charsz
= TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
;
766 e_type
= char16_type_node
;
768 else if (TREE_TYPE (value
) == char32_array_type_node
)
770 charsz
= TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
;
771 e_type
= char32_type_node
;
775 charsz
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
776 e_type
= wchar_type_node
;
779 /* This matters only for targets where ssizetype has smaller precision
781 if (wi::lts_p (wi::to_wide (TYPE_MAX_VALUE (ssizetype
)), length
))
783 error ("size of string literal is too large");
784 length
= tree_to_shwi (TYPE_MAX_VALUE (ssizetype
)) / charsz
* charsz
;
785 char *str
= CONST_CAST (char *, TREE_STRING_POINTER (value
));
786 memset (str
+ length
, '\0',
787 MIN (TREE_STRING_LENGTH (value
) - length
, charsz
));
788 TREE_STRING_LENGTH (value
) = length
;
790 nchars
= length
/ charsz
;
792 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
793 limit in C++98 Annex B is very large (65536) and is not normative,
794 so we do not diagnose it (warn_overlength_strings is forced off
795 in c_common_post_options). */
796 if (warn_overlength_strings
)
798 const int nchars_max
= flag_isoc99
? 4095 : 509;
799 const int relevant_std
= flag_isoc99
? 99 : 90;
800 if (nchars
- 1 > nchars_max
)
801 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
802 separate the %d from the 'C'. 'ISO' should not be
803 translated, but it may be moved after 'C%d' in languages
804 where modifiers follow nouns. */
805 pedwarn (input_location
, OPT_Woverlength_strings
,
806 "string length %qd is greater than the length %qd "
807 "ISO C%d compilers are required to support",
808 nchars
- 1, nchars_max
, relevant_std
);
811 /* Create the array type for the string constant. The ISO C++
812 standard says that a string literal has type `const char[N]' or
813 `const wchar_t[N]'. We use the same logic when invoked as a C
814 front-end with -Wwrite-strings.
815 ??? We should change the type of an expression depending on the
816 state of a warning flag. We should just be warning -- see how
817 this is handled in the C++ front-end for the deprecated implicit
818 conversion from string literals to `char*' or `wchar_t*'.
820 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
821 array type being the unqualified version of that type.
822 Therefore, if we are constructing an array of const char, we must
823 construct the matching unqualified array type first. The C front
824 end does not require this, but it does no harm, so we do it
826 i_type
= build_index_type (size_int (nchars
- 1));
827 a_type
= build_array_type (e_type
, i_type
);
828 if (c_dialect_cxx() || warn_write_strings
)
829 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
831 TREE_TYPE (value
) = a_type
;
832 TREE_CONSTANT (value
) = 1;
833 TREE_READONLY (value
) = 1;
834 TREE_STATIC (value
) = 1;
838 /* Given a string of type STRING_TYPE, determine what kind of string
839 token would give an equivalent execution encoding: CPP_STRING,
840 CPP_STRING16, or CPP_STRING32. Return CPP_OTHER in case of error.
841 This may not be exactly the string token type that initially created
842 the string, since CPP_WSTRING is indistinguishable from the 16/32 bit
843 string type, and CPP_UTF8STRING is indistinguishable from CPP_STRING
846 This effectively reverses part of the logic in lex_string and
849 static enum cpp_ttype
850 get_cpp_ttype_from_string_type (tree string_type
)
852 gcc_assert (string_type
);
853 if (TREE_CODE (string_type
) == POINTER_TYPE
)
854 string_type
= TREE_TYPE (string_type
);
856 if (TREE_CODE (string_type
) != ARRAY_TYPE
)
859 tree element_type
= TREE_TYPE (string_type
);
860 if (TREE_CODE (element_type
) != INTEGER_TYPE
)
863 int bits_per_character
= TYPE_PRECISION (element_type
);
864 switch (bits_per_character
)
867 return CPP_STRING
; /* It could have also been CPP_UTF8STRING. */
877 /* The global record of string concatentations, for use in
878 extracting locations within string literals. */
880 GTY(()) string_concat_db
*g_string_concat_db
;
882 /* Implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */
885 c_get_substring_location (const substring_loc
&substr_loc
,
888 enum cpp_ttype tok_type
889 = get_cpp_ttype_from_string_type (substr_loc
.get_string_type ());
890 if (tok_type
== CPP_OTHER
)
891 return "unrecognized string type";
893 return get_location_within_string (parse_in
, g_string_concat_db
,
894 substr_loc
.get_fmt_string_loc (),
896 substr_loc
.get_caret_idx (),
897 substr_loc
.get_start_idx (),
898 substr_loc
.get_end_idx (),
903 /* Return true iff T is a boolean promoted to int. */
906 bool_promoted_to_int_p (tree t
)
908 return (CONVERT_EXPR_P (t
)
909 && TREE_TYPE (t
) == integer_type_node
910 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == BOOLEAN_TYPE
);
913 /* vector_targets_convertible_p is used for vector pointer types. The
914 callers perform various checks that the qualifiers are satisfactory,
915 while OTOH vector_targets_convertible_p ignores the number of elements
916 in the vectors. That's fine with vector pointers as we can consider,
917 say, a vector of 8 elements as two consecutive vectors of 4 elements,
918 and that does not require and conversion of the pointer values.
919 In contrast, vector_types_convertible_p and
920 vector_types_compatible_elements_p are used for vector value types. */
921 /* True if pointers to distinct types T1 and T2 can be converted to
922 each other without an explicit cast. Only returns true for opaque
925 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
927 if (VECTOR_TYPE_P (t1
) && VECTOR_TYPE_P (t2
)
928 && (TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
929 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
935 /* vector_types_convertible_p is used for vector value types.
936 It could in principle call vector_targets_convertible_p as a subroutine,
937 but then the check for vector type would be duplicated with its callers,
938 and also the purpose of vector_targets_convertible_p would become
940 Where vector_types_convertible_p returns true, a conversion might still be
941 needed to make the types match.
942 In contrast, vector_targets_convertible_p is used for vector pointer
943 values, and vector_types_compatible_elements_p is used specifically
944 in the context for binary operators, as a check if use is possible without
946 /* True if vector types T1 and T2 can be converted to each other
947 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
948 can only be converted with -flax-vector-conversions yet that is not
949 in effect, emit a note telling the user about that option if such
950 a note has not previously been emitted. */
952 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
954 static bool emitted_lax_note
= false;
955 bool convertible_lax
;
957 if ((TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
958 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
962 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
963 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
964 || known_eq (TYPE_VECTOR_SUBPARTS (t1
),
965 TYPE_VECTOR_SUBPARTS (t2
)))
966 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
967 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
969 if (!convertible_lax
|| flag_lax_vector_conversions
)
970 return convertible_lax
;
972 if (known_eq (TYPE_VECTOR_SUBPARTS (t1
), TYPE_VECTOR_SUBPARTS (t2
))
973 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
976 if (emit_lax_note
&& !emitted_lax_note
)
978 emitted_lax_note
= true;
979 inform (input_location
, "use %<-flax-vector-conversions%> to permit "
980 "conversions between vectors with differing "
981 "element types or numbers of subparts");
987 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes
988 and have vector types, V0 has the same type as V1, and the number of
989 elements of V0, V1, MASK is the same.
991 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
992 called with two arguments. In this case implementation passes the
993 first argument twice in order to share the same tree code. This fact
994 could enable the mask-values being twice the vector length. This is
995 an implementation accident and this semantics is not guaranteed to
998 c_build_vec_perm_expr (location_t loc
, tree v0
, tree v1
, tree mask
,
1003 bool maybe_const
= false;
1004 bool two_arguments
= false;
1006 if (v1
== NULL_TREE
)
1008 two_arguments
= true;
1012 if (v0
== error_mark_node
|| v1
== error_mark_node
1013 || mask
== error_mark_node
)
1014 return error_mark_node
;
1016 if (!VECTOR_INTEGER_TYPE_P (TREE_TYPE (mask
)))
1019 error_at (loc
, "%<__builtin_shuffle%> last argument must "
1020 "be an integer vector");
1021 return error_mark_node
;
1024 if (!VECTOR_TYPE_P (TREE_TYPE (v0
))
1025 || !VECTOR_TYPE_P (TREE_TYPE (v1
)))
1028 error_at (loc
, "%<__builtin_shuffle%> arguments must be vectors");
1029 return error_mark_node
;
1032 if (TYPE_MAIN_VARIANT (TREE_TYPE (v0
)) != TYPE_MAIN_VARIANT (TREE_TYPE (v1
)))
1035 error_at (loc
, "%<__builtin_shuffle%> argument vectors must be of "
1037 return error_mark_node
;
1040 if (maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v0
)),
1041 TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask
)))
1042 && maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v1
)),
1043 TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask
))))
1046 error_at (loc
, "%<__builtin_shuffle%> number of elements of the "
1047 "argument vector(s) and the mask vector should "
1049 return error_mark_node
;
1052 if (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (TREE_TYPE (v0
))))
1053 != GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (TREE_TYPE (mask
)))))
1056 error_at (loc
, "%<__builtin_shuffle%> argument vector(s) inner type "
1057 "must have the same size as inner type of the mask");
1058 return error_mark_node
;
1061 if (!c_dialect_cxx ())
1063 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
1064 v0
= c_fully_fold (v0
, false, &maybe_const
);
1065 wrap
&= maybe_const
;
1068 v1
= v0
= save_expr (v0
);
1071 v1
= c_fully_fold (v1
, false, &maybe_const
);
1072 wrap
&= maybe_const
;
1075 mask
= c_fully_fold (mask
, false, &maybe_const
);
1076 wrap
&= maybe_const
;
1078 else if (two_arguments
)
1079 v1
= v0
= save_expr (v0
);
1081 ret
= build3_loc (loc
, VEC_PERM_EXPR
, TREE_TYPE (v0
), v0
, v1
, mask
);
1083 if (!c_dialect_cxx () && !wrap
)
1084 ret
= c_wrap_maybe_const (ret
, true);
1089 /* Build a VEC_CONVERT ifn for __builtin_convertvector builtin. */
1092 c_build_vec_convert (location_t loc1
, tree expr
, location_t loc2
, tree type
,
1095 if (error_operand_p (type
))
1096 return error_mark_node
;
1097 if (error_operand_p (expr
))
1098 return error_mark_node
;
1100 if (!VECTOR_INTEGER_TYPE_P (TREE_TYPE (expr
))
1101 && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (expr
)))
1104 error_at (loc1
, "%<__builtin_convertvector%> first argument must "
1105 "be an integer or floating vector");
1106 return error_mark_node
;
1109 if (!VECTOR_INTEGER_TYPE_P (type
) && !VECTOR_FLOAT_TYPE_P (type
))
1112 error_at (loc2
, "%<__builtin_convertvector%> second argument must "
1113 "be an integer or floating vector type");
1114 return error_mark_node
;
1117 if (maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr
)),
1118 TYPE_VECTOR_SUBPARTS (type
)))
1121 error_at (loc1
, "%<__builtin_convertvector%> number of elements "
1122 "of the first argument vector and the second argument "
1123 "vector type should be the same");
1124 return error_mark_node
;
1127 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (expr
)))
1128 == TYPE_MAIN_VARIANT (TREE_TYPE (type
)))
1129 || (VECTOR_INTEGER_TYPE_P (TREE_TYPE (expr
))
1130 && VECTOR_INTEGER_TYPE_P (type
)
1131 && (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (expr
)))
1132 == TYPE_PRECISION (TREE_TYPE (type
)))))
1133 return build1_loc (loc1
, VIEW_CONVERT_EXPR
, type
, expr
);
1136 bool maybe_const
= false;
1138 if (!c_dialect_cxx ())
1140 /* Avoid C_MAYBE_CONST_EXPRs inside of VEC_CONVERT argument. */
1141 expr
= c_fully_fold (expr
, false, &maybe_const
);
1142 wrap
&= maybe_const
;
1145 ret
= build_call_expr_internal_loc (loc1
, IFN_VEC_CONVERT
, type
, 1, expr
);
1148 ret
= c_wrap_maybe_const (ret
, true);
1153 /* Like tree.c:get_narrower, but retain conversion from C++0x scoped enum
1154 to integral type. */
1157 c_common_get_narrower (tree op
, int *unsignedp_ptr
)
1159 op
= get_narrower (op
, unsignedp_ptr
);
1161 if (TREE_CODE (TREE_TYPE (op
)) == ENUMERAL_TYPE
1162 && ENUM_IS_SCOPED (TREE_TYPE (op
)))
1164 /* C++0x scoped enumerations don't implicitly convert to integral
1165 type; if we stripped an explicit conversion to a larger type we
1166 need to replace it so common_type will still work. */
1167 tree type
= c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op
)),
1168 TYPE_UNSIGNED (TREE_TYPE (op
)));
1169 op
= fold_convert (type
, op
);
1174 /* This is a helper function of build_binary_op.
1176 For certain operations if both args were extended from the same
1177 smaller type, do the arithmetic in that type and then extend.
1179 BITWISE indicates a bitwise operation.
1180 For them, this optimization is safe only if
1181 both args are zero-extended or both are sign-extended.
1182 Otherwise, we might change the result.
1183 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1184 but calculated in (unsigned short) it would be (unsigned short)-1.
1187 shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
1189 int unsigned0
, unsigned1
;
1194 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1195 excessive narrowing when we call get_narrower below. For
1196 example, suppose that OP0 is of unsigned int extended
1197 from signed char and that RESULT_TYPE is long long int.
1198 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1201 (long long int) (unsigned int) signed_char
1203 which get_narrower would narrow down to
1205 (unsigned int) signed char
1207 If we do not cast OP0 first, get_narrower would return
1208 signed_char, which is inconsistent with the case of the
1210 op0
= convert (result_type
, op0
);
1211 op1
= convert (result_type
, op1
);
1213 arg0
= c_common_get_narrower (op0
, &unsigned0
);
1214 arg1
= c_common_get_narrower (op1
, &unsigned1
);
1216 /* UNS is 1 if the operation to be done is an unsigned one. */
1217 uns
= TYPE_UNSIGNED (result_type
);
1219 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1220 but it *requires* conversion to FINAL_TYPE. */
1222 if ((TYPE_PRECISION (TREE_TYPE (op0
))
1223 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1224 && TREE_TYPE (op0
) != result_type
)
1225 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1226 if ((TYPE_PRECISION (TREE_TYPE (op1
))
1227 == TYPE_PRECISION (TREE_TYPE (arg1
)))
1228 && TREE_TYPE (op1
) != result_type
)
1229 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1231 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1233 /* For bitwise operations, signedness of nominal type
1234 does not matter. Consider only how operands were extended. */
1238 /* Note that in all three cases below we refrain from optimizing
1239 an unsigned operation on sign-extended args.
1240 That would not be valid. */
1242 /* Both args variable: if both extended in same way
1243 from same width, do it in that width.
1244 Do it unsigned if args were zero-extended. */
1245 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
1246 < TYPE_PRECISION (result_type
))
1247 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1248 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1249 && unsigned0
== unsigned1
1250 && (unsigned0
|| !uns
))
1251 return c_common_signed_or_unsigned_type
1252 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
1254 else if (TREE_CODE (arg0
) == INTEGER_CST
1255 && (unsigned1
|| !uns
)
1256 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1257 < TYPE_PRECISION (result_type
))
1259 = c_common_signed_or_unsigned_type (unsigned1
,
1261 && !POINTER_TYPE_P (type
)
1262 && int_fits_type_p (arg0
, type
))
1265 else if (TREE_CODE (arg1
) == INTEGER_CST
1266 && (unsigned0
|| !uns
)
1267 && (TYPE_PRECISION (TREE_TYPE (arg0
))
1268 < TYPE_PRECISION (result_type
))
1270 = c_common_signed_or_unsigned_type (unsigned0
,
1272 && !POINTER_TYPE_P (type
)
1273 && int_fits_type_p (arg1
, type
))
1279 /* Returns true iff any integer value of type FROM_TYPE can be represented as
1280 real of type TO_TYPE. This is a helper function for unsafe_conversion_p. */
1283 int_safely_convertible_to_real_p (const_tree from_type
, const_tree to_type
)
1285 tree type_low_bound
= TYPE_MIN_VALUE (from_type
);
1286 tree type_high_bound
= TYPE_MAX_VALUE (from_type
);
1287 REAL_VALUE_TYPE real_low_bound
=
1288 real_value_from_int_cst (0, type_low_bound
);
1289 REAL_VALUE_TYPE real_high_bound
=
1290 real_value_from_int_cst (0, type_high_bound
);
1292 return exact_real_truncate (TYPE_MODE (to_type
), &real_low_bound
)
1293 && exact_real_truncate (TYPE_MODE (to_type
), &real_high_bound
);
1296 /* Checks if expression EXPR of complex/real/integer type cannot be converted
1297 to the complex/real/integer type TYPE. Function returns non-zero when:
1298 * EXPR is a constant which cannot be exactly converted to TYPE.
1299 * EXPR is not a constant and size of EXPR's type > than size of TYPE,
1300 for EXPR type and TYPE being both integers or both real, or both
1302 * EXPR is not a constant of complex type and TYPE is a real or
1304 * EXPR is not a constant of real type and TYPE is an integer.
1305 * EXPR is not a constant of integer type which cannot be
1306 exactly converted to real type.
1308 Function allows conversions between types of different signedness and
1309 can return SAFE_CONVERSION (zero) in that case. Function can produce
1310 signedness warnings if PRODUCE_WARNS is true.
1312 RESULT, when non-null is the result of the conversion. When constant
1313 it is included in the text of diagnostics.
1315 Function allows conversions from complex constants to non-complex types,
1316 provided that imaginary part is zero and real part can be safely converted
1319 enum conversion_safety
1320 unsafe_conversion_p (location_t loc
, tree type
, tree expr
, tree result
,
1323 enum conversion_safety give_warning
= SAFE_CONVERSION
; /* is 0 or false */
1324 tree expr_type
= TREE_TYPE (expr
);
1326 bool cstresult
= (result
1327 && TREE_CODE_CLASS (TREE_CODE (result
)) == tcc_constant
);
1329 loc
= expansion_point_location_if_in_system_header (loc
);
1331 expr
= fold_for_warn (expr
);
1333 if (TREE_CODE (expr
) == REAL_CST
|| TREE_CODE (expr
) == INTEGER_CST
)
1335 /* If type is complex, we are interested in compatibility with
1337 if (TREE_CODE (type
) == COMPLEX_TYPE
)
1338 type
= TREE_TYPE (type
);
1340 /* Warn for real constant that is not an exact integer converted
1342 if (TREE_CODE (expr_type
) == REAL_TYPE
1343 && TREE_CODE (type
) == INTEGER_TYPE
)
1345 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (expr_type
)))
1346 give_warning
= UNSAFE_REAL
;
1348 /* Warn for an integer constant that does not fit into integer type. */
1349 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1350 && TREE_CODE (type
) == INTEGER_TYPE
1351 && !int_fits_type_p (expr
, type
))
1353 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)
1354 && tree_int_cst_sgn (expr
) < 0)
1359 warning_at (loc
, OPT_Wsign_conversion
,
1360 "unsigned conversion from %qT to %qT "
1361 "changes value from %qE to %qE",
1362 expr_type
, type
, expr
, result
);
1364 warning_at (loc
, OPT_Wsign_conversion
,
1365 "unsigned conversion from %qT to %qT "
1366 "changes the value of %qE",
1367 expr_type
, type
, expr
);
1370 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (expr_type
))
1373 warning_at (loc
, OPT_Wsign_conversion
,
1374 "signed conversion from %qT to %qT changes "
1375 "value from %qE to %qE",
1376 expr_type
, type
, expr
, result
);
1378 warning_at (loc
, OPT_Wsign_conversion
,
1379 "signed conversion from %qT to %qT changes "
1381 expr_type
, type
, expr
);
1384 give_warning
= UNSAFE_OTHER
;
1386 else if (TREE_CODE (type
) == REAL_TYPE
)
1388 /* Warn for an integer constant that does not fit into real type. */
1389 if (TREE_CODE (expr_type
) == INTEGER_TYPE
)
1391 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
1392 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1393 give_warning
= UNSAFE_REAL
;
1395 /* Warn for a real constant that does not fit into a smaller
1397 else if (TREE_CODE (expr_type
) == REAL_TYPE
1398 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1400 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
1401 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1402 give_warning
= UNSAFE_REAL
;
1407 else if (TREE_CODE (expr
) == COMPLEX_CST
)
1409 tree imag_part
= TREE_IMAGPART (expr
);
1410 /* Conversion from complex constant with zero imaginary part,
1411 perform check for conversion of real part. */
1412 if ((TREE_CODE (imag_part
) == REAL_CST
1413 && real_zerop (imag_part
))
1414 || (TREE_CODE (imag_part
) == INTEGER_CST
1415 && integer_zerop (imag_part
)))
1416 /* Note: in this branch we use recursive call to unsafe_conversion_p
1417 with different type of EXPR, but it is still safe, because when EXPR
1418 is a constant, it's type is not used in text of generated warnings
1419 (otherwise they could sound misleading). */
1420 return unsafe_conversion_p (loc
, type
, TREE_REALPART (expr
), result
,
1422 /* Conversion from complex constant with non-zero imaginary part. */
1425 /* Conversion to complex type.
1426 Perform checks for both real and imaginary parts. */
1427 if (TREE_CODE (type
) == COMPLEX_TYPE
)
1429 /* Unfortunately, produce_warns must be false in two subsequent
1430 calls of unsafe_conversion_p, because otherwise we could
1431 produce strange "double" warnings, if both real and imaginary
1432 parts have conversion problems related to signedness.
1435 int32_t _Complex a = 0x80000000 + 0x80000000i;
1437 Possible solution: add a separate function for checking
1438 constants and combine result of two calls appropriately. */
1439 enum conversion_safety re_safety
=
1440 unsafe_conversion_p (loc
, type
, TREE_REALPART (expr
),
1442 enum conversion_safety im_safety
=
1443 unsafe_conversion_p (loc
, type
, imag_part
, result
, false);
1445 /* Merge the results into appropriate single warning. */
1447 /* Note: this case includes SAFE_CONVERSION, i.e. success. */
1448 if (re_safety
== im_safety
)
1449 give_warning
= re_safety
;
1450 else if (!re_safety
&& im_safety
)
1451 give_warning
= im_safety
;
1452 else if (re_safety
&& !im_safety
)
1453 give_warning
= re_safety
;
1455 give_warning
= UNSAFE_OTHER
;
1457 /* Warn about conversion from complex to real or integer type. */
1459 give_warning
= UNSAFE_IMAGINARY
;
1463 /* Checks for remaining case: EXPR is not constant. */
1466 /* Warn for real types converted to integer types. */
1467 if (TREE_CODE (expr_type
) == REAL_TYPE
1468 && TREE_CODE (type
) == INTEGER_TYPE
)
1469 give_warning
= UNSAFE_REAL
;
1471 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1472 && TREE_CODE (type
) == INTEGER_TYPE
)
1474 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1475 expr
= get_unwidened (expr
, 0);
1476 expr_type
= TREE_TYPE (expr
);
1478 /* Don't warn for short y; short x = ((int)y & 0xff); */
1479 if (TREE_CODE (expr
) == BIT_AND_EXPR
1480 || TREE_CODE (expr
) == BIT_IOR_EXPR
1481 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
1483 /* If both args were extended from a shortest type,
1484 use that type if that is safe. */
1485 expr_type
= shorten_binary_op (expr_type
,
1486 TREE_OPERAND (expr
, 0),
1487 TREE_OPERAND (expr
, 1),
1490 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
1492 tree op0
= TREE_OPERAND (expr
, 0);
1493 tree op1
= TREE_OPERAND (expr
, 1);
1494 bool unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1495 bool unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1497 /* If one of the operands is a non-negative constant
1498 that fits in the target type, then the type of the
1499 other operand does not matter. */
1500 if ((TREE_CODE (op0
) == INTEGER_CST
1501 && int_fits_type_p (op0
, c_common_signed_type (type
))
1502 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
1503 || (TREE_CODE (op1
) == INTEGER_CST
1504 && int_fits_type_p (op1
, c_common_signed_type (type
))
1505 && int_fits_type_p (op1
,
1506 c_common_unsigned_type (type
))))
1507 return SAFE_CONVERSION
;
1508 /* If constant is unsigned and fits in the target
1509 type, then the result will also fit. */
1510 else if ((TREE_CODE (op0
) == INTEGER_CST
1512 && int_fits_type_p (op0
, type
))
1513 || (TREE_CODE (op1
) == INTEGER_CST
1515 && int_fits_type_p (op1
, type
)))
1516 return SAFE_CONVERSION
;
1519 /* Warn for integer types converted to smaller integer types. */
1520 if (TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1521 give_warning
= UNSAFE_OTHER
;
1523 /* When they are the same width but different signedness,
1524 then the value may change. */
1525 else if (((TYPE_PRECISION (type
) == TYPE_PRECISION (expr_type
)
1526 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
1527 /* Even when converted to a bigger type, if the type is
1528 unsigned but expr is signed, then negative values
1530 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
1532 warning_at (loc
, OPT_Wsign_conversion
, "conversion to %qT from %qT "
1533 "may change the sign of the result",
1537 /* Warn for integer types converted to real types if and only if
1538 all the range of values of the integer type cannot be
1539 represented by the real type. */
1540 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1541 && TREE_CODE (type
) == REAL_TYPE
)
1543 /* Don't warn about char y = 0xff; float x = (int) y; */
1544 expr
= get_unwidened (expr
, 0);
1545 expr_type
= TREE_TYPE (expr
);
1547 if (!int_safely_convertible_to_real_p (expr_type
, type
))
1548 give_warning
= UNSAFE_OTHER
;
1551 /* Warn for real types converted to smaller real types. */
1552 else if (TREE_CODE (expr_type
) == REAL_TYPE
1553 && TREE_CODE (type
) == REAL_TYPE
1554 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1555 give_warning
= UNSAFE_REAL
;
1557 /* Check conversion between two complex types. */
1558 else if (TREE_CODE (expr_type
) == COMPLEX_TYPE
1559 && TREE_CODE (type
) == COMPLEX_TYPE
)
1561 /* Extract underlying types (i.e., type of real and imaginary
1562 parts) of expr_type and type. */
1563 tree from_type
= TREE_TYPE (expr_type
);
1564 tree to_type
= TREE_TYPE (type
);
1566 /* Warn for real types converted to integer types. */
1567 if (TREE_CODE (from_type
) == REAL_TYPE
1568 && TREE_CODE (to_type
) == INTEGER_TYPE
)
1569 give_warning
= UNSAFE_REAL
;
1571 /* Warn for real types converted to smaller real types. */
1572 else if (TREE_CODE (from_type
) == REAL_TYPE
1573 && TREE_CODE (to_type
) == REAL_TYPE
1574 && TYPE_PRECISION (to_type
) < TYPE_PRECISION (from_type
))
1575 give_warning
= UNSAFE_REAL
;
1577 /* Check conversion for complex integer types. Here implementation
1578 is simpler than for real-domain integers because it does not
1579 involve sophisticated cases, such as bitmasks, casts, etc. */
1580 else if (TREE_CODE (from_type
) == INTEGER_TYPE
1581 && TREE_CODE (to_type
) == INTEGER_TYPE
)
1583 /* Warn for integer types converted to smaller integer types. */
1584 if (TYPE_PRECISION (to_type
) < TYPE_PRECISION (from_type
))
1585 give_warning
= UNSAFE_OTHER
;
1587 /* Check for different signedness, see case for real-domain
1588 integers (above) for a more detailed comment. */
1589 else if (((TYPE_PRECISION (to_type
) == TYPE_PRECISION (from_type
)
1590 && TYPE_UNSIGNED (to_type
) != TYPE_UNSIGNED (from_type
))
1591 || (TYPE_UNSIGNED (to_type
) && !TYPE_UNSIGNED (from_type
)))
1593 warning_at (loc
, OPT_Wsign_conversion
,
1594 "conversion to %qT from %qT "
1595 "may change the sign of the result",
1598 else if (TREE_CODE (from_type
) == INTEGER_TYPE
1599 && TREE_CODE (to_type
) == REAL_TYPE
1600 && !int_safely_convertible_to_real_p (from_type
, to_type
))
1601 give_warning
= UNSAFE_OTHER
;
1604 /* Warn for complex types converted to real or integer types. */
1605 else if (TREE_CODE (expr_type
) == COMPLEX_TYPE
1606 && TREE_CODE (type
) != COMPLEX_TYPE
)
1607 give_warning
= UNSAFE_IMAGINARY
;
1610 return give_warning
;
1614 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1615 Invoke this function on every expression that is converted implicitly,
1616 i.e. because of language rules and not because of an explicit cast. */
1619 convert_and_check (location_t loc
, tree type
, tree expr
)
1622 tree expr_for_warning
;
1624 /* Convert from a value with possible excess precision rather than
1625 via the semantic type, but do not warn about values not fitting
1626 exactly in the semantic type. */
1627 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
1629 tree orig_type
= TREE_TYPE (expr
);
1630 expr
= TREE_OPERAND (expr
, 0);
1631 expr_for_warning
= convert (orig_type
, expr
);
1632 if (orig_type
== type
)
1633 return expr_for_warning
;
1636 expr_for_warning
= expr
;
1638 if (TREE_TYPE (expr
) == type
)
1641 result
= convert (type
, expr
);
1643 if (c_inhibit_evaluation_warnings
== 0
1644 && !TREE_OVERFLOW_P (expr
)
1645 && result
!= error_mark_node
)
1646 warnings_for_convert_and_check (loc
, type
, expr_for_warning
, result
);
1651 /* A node in a list that describes references to variables (EXPR), which are
1652 either read accesses if WRITER is zero, or write accesses, in which case
1653 WRITER is the parent of EXPR. */
1660 /* Used to implement a cache the results of a call to verify_tree. We only
1661 use this for SAVE_EXPRs. */
1664 struct tlist_cache
*next
;
1665 struct tlist
*cache_before_sp
;
1666 struct tlist
*cache_after_sp
;
1670 /* Obstack to use when allocating tlist structures, and corresponding
1672 static struct obstack tlist_obstack
;
1673 static char *tlist_firstobj
= 0;
1675 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1677 static struct tlist
*warned_ids
;
1678 /* SAVE_EXPRs need special treatment. We process them only once and then
1679 cache the results. */
1680 static struct tlist_cache
*save_expr_cache
;
1682 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
1683 static void merge_tlist (struct tlist
**, struct tlist
*, int);
1684 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
1685 static bool warning_candidate_p (tree
);
1686 static bool candidate_equal_p (const_tree
, const_tree
);
1687 static void warn_for_collisions (struct tlist
*);
1688 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
1689 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
1691 /* Create a new struct tlist and fill in its fields. */
1692 static struct tlist
*
1693 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1696 l
= XOBNEW (&tlist_obstack
, struct tlist
);
1703 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1704 is nonnull, we ignore any node we find which has a writer equal to it. */
1707 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1711 struct tlist
*next
= add
->next
;
1714 if (!exclude_writer
|| !candidate_equal_p (add
->writer
, exclude_writer
))
1715 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1720 /* Merge the nodes of ADD into TO. This merging process is done so that for
1721 each variable that already exists in TO, no new node is added; however if
1722 there is a write access recorded in ADD, and an occurrence on TO is only
1723 a read access, then the occurrence in TO will be modified to record the
1727 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1729 struct tlist
**end
= to
;
1732 end
= &(*end
)->next
;
1738 struct tlist
*next
= add
->next
;
1740 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1741 if (candidate_equal_p (tmp2
->expr
, add
->expr
))
1745 tmp2
->writer
= add
->writer
;
1749 *end
= copy
? new_tlist (NULL
, add
->expr
, add
->writer
) : add
;
1750 end
= &(*end
)->next
;
1757 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1758 references in list LIST conflict with it, excluding reads if ONLY writers
1762 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1767 /* Avoid duplicate warnings. */
1768 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1769 if (candidate_equal_p (tmp
->expr
, written
))
1774 if (candidate_equal_p (list
->expr
, written
)
1775 && !candidate_equal_p (list
->writer
, writer
)
1776 && (!only_writes
|| list
->writer
))
1778 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1779 warning_at (EXPR_LOC_OR_LOC (writer
, input_location
),
1780 OPT_Wsequence_point
, "operation on %qE may be undefined",
1787 /* Given a list LIST of references to variables, find whether any of these
1788 can cause conflicts due to missing sequence points. */
1791 warn_for_collisions (struct tlist
*list
)
1795 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1798 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1802 /* Return nonzero if X is a tree that can be verified by the sequence point
1806 warning_candidate_p (tree x
)
1808 if (DECL_P (x
) && DECL_ARTIFICIAL (x
))
1811 if (TREE_CODE (x
) == BLOCK
)
1814 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
1815 (lvalue_p) crash on TRY/CATCH. */
1816 if (TREE_TYPE (x
) == NULL_TREE
|| VOID_TYPE_P (TREE_TYPE (x
)))
1822 /* No point to track non-const calls, they will never satisfy
1824 if (TREE_CODE (x
) == CALL_EXPR
&& (call_expr_flags (x
) & ECF_CONST
) == 0)
1827 if (TREE_CODE (x
) == STRING_CST
)
1833 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
1835 candidate_equal_p (const_tree x
, const_tree y
)
1837 return (x
== y
) || (x
&& y
&& operand_equal_p (x
, y
, 0));
1840 /* Walk the tree X, and record accesses to variables. If X is written by the
1841 parent tree, WRITER is the parent.
1842 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1843 expression or its only operand forces a sequence point, then everything up
1844 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1846 Once we return, we will have emitted warnings if any subexpression before
1847 such a sequence point could be undefined. On a higher level, however, the
1848 sequence point may not be relevant, and we'll merge the two lists.
1850 Example: (b++, a) + b;
1851 The call that processes the COMPOUND_EXPR will store the increment of B
1852 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1853 processes the PLUS_EXPR will need to merge the two lists so that
1854 eventually, all accesses end up on the same list (and we'll warn about the
1855 unordered subexpressions b++ and b.
1857 A note on merging. If we modify the former example so that our expression
1860 care must be taken not simply to add all three expressions into the final
1861 PNO_SP list. The function merge_tlist takes care of that by merging the
1862 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1863 way, so that no more than one access to B is recorded. */
1866 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
1869 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1870 enum tree_code code
;
1871 enum tree_code_class cl
;
1873 /* X may be NULL if it is the operand of an empty statement expression
1879 code
= TREE_CODE (x
);
1880 cl
= TREE_CODE_CLASS (code
);
1882 if (warning_candidate_p (x
))
1883 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1892 case TRUTH_ANDIF_EXPR
:
1893 case TRUTH_ORIF_EXPR
:
1894 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1895 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1896 warn_for_collisions (tmp_nosp
);
1897 merge_tlist (pbefore_sp
, tmp_before
, 0);
1898 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1899 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1900 warn_for_collisions (tmp_list2
);
1901 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1902 merge_tlist (pno_sp
, tmp_list2
, 0);
1906 tmp_before
= tmp_list2
= 0;
1907 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1908 warn_for_collisions (tmp_list2
);
1909 merge_tlist (pbefore_sp
, tmp_before
, 0);
1910 merge_tlist (pbefore_sp
, tmp_list2
, 0);
1912 tmp_list3
= tmp_nosp
= 0;
1913 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1914 warn_for_collisions (tmp_nosp
);
1915 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1917 tmp_list3
= tmp_list2
= 0;
1918 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1919 warn_for_collisions (tmp_list2
);
1920 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1921 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1922 two first, to avoid warning for (a ? b++ : b++). */
1923 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1924 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1927 case PREDECREMENT_EXPR
:
1928 case PREINCREMENT_EXPR
:
1929 case POSTDECREMENT_EXPR
:
1930 case POSTINCREMENT_EXPR
:
1931 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1935 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1936 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1937 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1938 /* Expressions inside the LHS are not ordered wrt. the sequence points
1939 in the RHS. Example:
1941 Despite the fact that the modification of "a" is in the before_sp
1942 list (tmp_before), it conflicts with the use of "a" in the LHS.
1943 We can handle this by adding the contents of tmp_list3
1944 to those of tmp_before, and redoing the collision warnings for that
1946 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1947 warn_for_collisions (tmp_before
);
1948 /* Exclude the LHS itself here; we first have to merge it into the
1949 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1950 didn't exclude the LHS, we'd get it twice, once as a read and once
1952 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1953 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1955 merge_tlist (pbefore_sp
, tmp_before
, 0);
1956 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1957 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1958 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1962 /* We need to warn about conflicts among arguments and conflicts between
1963 args and the function address. Side effects of the function address,
1964 however, are not ordered by the sequence point of the call. */
1966 call_expr_arg_iterator iter
;
1968 tmp_before
= tmp_nosp
= 0;
1969 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1970 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
1972 tmp_list2
= tmp_list3
= 0;
1973 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
1974 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1975 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1977 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1978 warn_for_collisions (tmp_before
);
1979 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1984 /* Scan all the list, e.g. indices of multi dimensional array. */
1987 tmp_before
= tmp_nosp
= 0;
1988 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1989 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1990 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1997 struct tlist_cache
*t
;
1998 for (t
= save_expr_cache
; t
; t
= t
->next
)
1999 if (candidate_equal_p (t
->expr
, x
))
2004 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
2005 t
->next
= save_expr_cache
;
2007 save_expr_cache
= t
;
2009 tmp_before
= tmp_nosp
= 0;
2010 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2011 warn_for_collisions (tmp_nosp
);
2014 merge_tlist (&tmp_list3
, tmp_nosp
, 0);
2015 t
->cache_before_sp
= tmp_before
;
2016 t
->cache_after_sp
= tmp_list3
;
2018 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
2019 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
2024 x
= TREE_OPERAND (x
, 0);
2030 case VIEW_CONVERT_EXPR
:
2031 if (location_wrapper_p (x
))
2033 x
= TREE_OPERAND (x
, 0);
2038 /* For other expressions, simply recurse on their operands.
2039 Manual tail recursion for unary expressions.
2040 Other non-expressions need not be processed. */
2041 if (cl
== tcc_unary
)
2043 x
= TREE_OPERAND (x
, 0);
2047 else if (IS_EXPR_CODE_CLASS (cl
))
2050 int max
= TREE_OPERAND_LENGTH (x
);
2051 for (lp
= 0; lp
< max
; lp
++)
2053 tmp_before
= tmp_nosp
= 0;
2054 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
2055 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2056 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2063 /* Try to warn for undefined behavior in EXPR due to missing sequence
2067 verify_sequence_points (tree expr
)
2069 struct tlist
*before_sp
= 0, *after_sp
= 0;
2072 save_expr_cache
= 0;
2073 if (tlist_firstobj
== 0)
2075 gcc_obstack_init (&tlist_obstack
);
2076 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
2079 verify_tree (expr
, &before_sp
, &after_sp
, 0);
2080 warn_for_collisions (after_sp
);
2081 obstack_free (&tlist_obstack
, tlist_firstobj
);
2084 /* Validate the expression after `case' and apply default promotions. */
2087 check_case_value (location_t loc
, tree value
)
2089 if (value
== NULL_TREE
)
2092 if (TREE_CODE (value
) == INTEGER_CST
)
2093 /* Promote char or short to int. */
2094 value
= perform_integral_promotions (value
);
2095 else if (value
!= error_mark_node
)
2097 error_at (loc
, "case label does not reduce to an integer constant");
2098 value
= error_mark_node
;
2101 constant_expression_warning (value
);
2106 /* See if the case values LOW and HIGH are in the range of the original
2107 type (i.e. before the default conversion to int) of the switch testing
2109 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2110 the type before promoting it. CASE_LOW_P is a pointer to the lower
2111 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2112 if the case is not a case range.
2113 The caller has to make sure that we are not called with NULL for
2114 CASE_LOW_P (i.e. the default case). OUTSIDE_RANGE_P says whether there
2115 was a case value that doesn't fit into the range of the ORIG_TYPE.
2116 Returns true if the case label is in range of ORIG_TYPE (saturated or
2117 untouched) or false if the label is out of range. */
2120 check_case_bounds (location_t loc
, tree type
, tree orig_type
,
2121 tree
*case_low_p
, tree
*case_high_p
,
2122 bool *outside_range_p
)
2124 tree min_value
, max_value
;
2125 tree case_low
= *case_low_p
;
2126 tree case_high
= case_high_p
? *case_high_p
: case_low
;
2128 /* If there was a problem with the original type, do nothing. */
2129 if (orig_type
== error_mark_node
)
2132 min_value
= TYPE_MIN_VALUE (orig_type
);
2133 max_value
= TYPE_MAX_VALUE (orig_type
);
2135 /* We'll really need integer constants here. */
2136 case_low
= fold (case_low
);
2137 case_high
= fold (case_high
);
2139 /* Case label is less than minimum for type. */
2140 if (tree_int_cst_compare (case_low
, min_value
) < 0
2141 && tree_int_cst_compare (case_high
, min_value
) < 0)
2143 warning_at (loc
, 0, "case label value is less than minimum value "
2145 *outside_range_p
= true;
2149 /* Case value is greater than maximum for type. */
2150 if (tree_int_cst_compare (case_low
, max_value
) > 0
2151 && tree_int_cst_compare (case_high
, max_value
) > 0)
2153 warning_at (loc
, 0, "case label value exceeds maximum value for type");
2154 *outside_range_p
= true;
2158 /* Saturate lower case label value to minimum. */
2159 if (tree_int_cst_compare (case_high
, min_value
) >= 0
2160 && tree_int_cst_compare (case_low
, min_value
) < 0)
2162 warning_at (loc
, 0, "lower value in case label range"
2163 " less than minimum value for type");
2164 *outside_range_p
= true;
2165 case_low
= min_value
;
2168 /* Saturate upper case label value to maximum. */
2169 if (tree_int_cst_compare (case_low
, max_value
) <= 0
2170 && tree_int_cst_compare (case_high
, max_value
) > 0)
2172 warning_at (loc
, 0, "upper value in case label range"
2173 " exceeds maximum value for type");
2174 *outside_range_p
= true;
2175 case_high
= max_value
;
2178 if (*case_low_p
!= case_low
)
2179 *case_low_p
= convert (type
, case_low
);
2180 if (case_high_p
&& *case_high_p
!= case_high
)
2181 *case_high_p
= convert (type
, case_high
);
2186 /* Return an integer type with BITS bits of precision,
2187 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2190 c_common_type_for_size (unsigned int bits
, int unsignedp
)
2194 if (bits
== TYPE_PRECISION (integer_type_node
))
2195 return unsignedp
? unsigned_type_node
: integer_type_node
;
2197 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2198 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2200 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2201 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2203 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2204 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2206 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2207 return (unsignedp
? long_long_unsigned_type_node
2208 : long_long_integer_type_node
);
2210 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2211 if (int_n_enabled_p
[i
]
2212 && bits
== int_n_data
[i
].bitsize
)
2213 return (unsignedp
? int_n_trees
[i
].unsigned_type
2214 : int_n_trees
[i
].signed_type
);
2216 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2217 return (unsignedp
? widest_unsigned_literal_type_node
2218 : widest_integer_literal_type_node
);
2220 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2221 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2223 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2224 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2226 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2227 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2229 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2230 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2235 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2236 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2237 and saturating if SATP is nonzero, otherwise not saturating. */
2240 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
2241 int unsignedp
, int satp
)
2243 enum mode_class mclass
;
2245 mclass
= unsignedp
? MODE_UFRACT
: MODE_FRACT
;
2247 mclass
= unsignedp
? MODE_UACCUM
: MODE_ACCUM
;
2249 opt_scalar_mode opt_mode
;
2251 FOR_EACH_MODE_IN_CLASS (opt_mode
, mclass
)
2253 mode
= opt_mode
.require ();
2254 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2258 if (!opt_mode
.exists (&mode
) || !targetm
.scalar_mode_supported_p (mode
))
2260 sorry ("GCC cannot support operators with integer types and "
2261 "fixed-point types that have too many integral and "
2262 "fractional bits together");
2266 return c_common_type_for_mode (mode
, satp
);
2269 /* Used for communication between c_common_type_for_mode and
2270 c_register_builtin_type. */
2271 tree registered_builtin_types
;
2273 /* Return a data type that has machine mode MODE.
2274 If the mode is an integer,
2275 then UNSIGNEDP selects between signed and unsigned types.
2276 If the mode is a fixed-point mode,
2277 then UNSIGNEDP selects between saturating and nonsaturating types. */
2280 c_common_type_for_mode (machine_mode mode
, int unsignedp
)
2285 if (mode
== TYPE_MODE (integer_type_node
))
2286 return unsignedp
? unsigned_type_node
: integer_type_node
;
2288 if (mode
== TYPE_MODE (signed_char_type_node
))
2289 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2291 if (mode
== TYPE_MODE (short_integer_type_node
))
2292 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2294 if (mode
== TYPE_MODE (long_integer_type_node
))
2295 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2297 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2298 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2300 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2301 if (int_n_enabled_p
[i
]
2302 && mode
== int_n_data
[i
].m
)
2303 return (unsignedp
? int_n_trees
[i
].unsigned_type
2304 : int_n_trees
[i
].signed_type
);
2307 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2310 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2313 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2316 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2318 #if HOST_BITS_PER_WIDE_INT >= 64
2319 if (mode
== TYPE_MODE (intTI_type_node
))
2320 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2323 if (mode
== TYPE_MODE (float_type_node
))
2324 return float_type_node
;
2326 if (mode
== TYPE_MODE (double_type_node
))
2327 return double_type_node
;
2329 if (mode
== TYPE_MODE (long_double_type_node
))
2330 return long_double_type_node
;
2332 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
2333 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
2334 && mode
== TYPE_MODE (FLOATN_NX_TYPE_NODE (i
)))
2335 return FLOATN_NX_TYPE_NODE (i
);
2337 if (mode
== TYPE_MODE (void_type_node
))
2338 return void_type_node
;
2340 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
))
2341 || mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2343 unsigned int precision
2344 = GET_MODE_PRECISION (as_a
<scalar_int_mode
> (mode
));
2346 ? make_unsigned_type (precision
)
2347 : make_signed_type (precision
));
2350 if (COMPLEX_MODE_P (mode
))
2352 machine_mode inner_mode
;
2355 if (mode
== TYPE_MODE (complex_float_type_node
))
2356 return complex_float_type_node
;
2357 if (mode
== TYPE_MODE (complex_double_type_node
))
2358 return complex_double_type_node
;
2359 if (mode
== TYPE_MODE (complex_long_double_type_node
))
2360 return complex_long_double_type_node
;
2362 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
2363 if (COMPLEX_FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
2364 && mode
== TYPE_MODE (COMPLEX_FLOATN_NX_TYPE_NODE (i
)))
2365 return COMPLEX_FLOATN_NX_TYPE_NODE (i
);
2367 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
2368 return complex_integer_type_node
;
2370 inner_mode
= GET_MODE_INNER (mode
);
2371 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2372 if (inner_type
!= NULL_TREE
)
2373 return build_complex_type (inner_type
);
2375 else if (GET_MODE_CLASS (mode
) == MODE_VECTOR_BOOL
2376 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
2378 unsigned int elem_bits
= vector_element_size (GET_MODE_BITSIZE (mode
),
2379 GET_MODE_NUNITS (mode
));
2380 tree bool_type
= build_nonstandard_boolean_type (elem_bits
);
2381 return build_vector_type_for_mode (bool_type
, mode
);
2383 else if (VECTOR_MODE_P (mode
)
2384 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
2386 machine_mode inner_mode
= GET_MODE_INNER (mode
);
2387 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2388 if (inner_type
!= NULL_TREE
)
2389 return build_vector_type_for_mode (inner_type
, mode
);
2392 if (mode
== TYPE_MODE (dfloat32_type_node
))
2393 return dfloat32_type_node
;
2394 if (mode
== TYPE_MODE (dfloat64_type_node
))
2395 return dfloat64_type_node
;
2396 if (mode
== TYPE_MODE (dfloat128_type_node
))
2397 return dfloat128_type_node
;
2399 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
2401 if (mode
== TYPE_MODE (short_fract_type_node
))
2402 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
2403 if (mode
== TYPE_MODE (fract_type_node
))
2404 return unsignedp
? sat_fract_type_node
: fract_type_node
;
2405 if (mode
== TYPE_MODE (long_fract_type_node
))
2406 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
2407 if (mode
== TYPE_MODE (long_long_fract_type_node
))
2408 return unsignedp
? sat_long_long_fract_type_node
2409 : long_long_fract_type_node
;
2411 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
2412 return unsignedp
? sat_unsigned_short_fract_type_node
2413 : unsigned_short_fract_type_node
;
2414 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
2415 return unsignedp
? sat_unsigned_fract_type_node
2416 : unsigned_fract_type_node
;
2417 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
2418 return unsignedp
? sat_unsigned_long_fract_type_node
2419 : unsigned_long_fract_type_node
;
2420 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
2421 return unsignedp
? sat_unsigned_long_long_fract_type_node
2422 : unsigned_long_long_fract_type_node
;
2424 if (mode
== TYPE_MODE (short_accum_type_node
))
2425 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
2426 if (mode
== TYPE_MODE (accum_type_node
))
2427 return unsignedp
? sat_accum_type_node
: accum_type_node
;
2428 if (mode
== TYPE_MODE (long_accum_type_node
))
2429 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
2430 if (mode
== TYPE_MODE (long_long_accum_type_node
))
2431 return unsignedp
? sat_long_long_accum_type_node
2432 : long_long_accum_type_node
;
2434 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
2435 return unsignedp
? sat_unsigned_short_accum_type_node
2436 : unsigned_short_accum_type_node
;
2437 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
2438 return unsignedp
? sat_unsigned_accum_type_node
2439 : unsigned_accum_type_node
;
2440 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
2441 return unsignedp
? sat_unsigned_long_accum_type_node
2442 : unsigned_long_accum_type_node
;
2443 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
2444 return unsignedp
? sat_unsigned_long_long_accum_type_node
2445 : unsigned_long_long_accum_type_node
;
2448 return unsignedp
? sat_qq_type_node
: qq_type_node
;
2450 return unsignedp
? sat_hq_type_node
: hq_type_node
;
2452 return unsignedp
? sat_sq_type_node
: sq_type_node
;
2454 return unsignedp
? sat_dq_type_node
: dq_type_node
;
2456 return unsignedp
? sat_tq_type_node
: tq_type_node
;
2458 if (mode
== UQQmode
)
2459 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
2460 if (mode
== UHQmode
)
2461 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
2462 if (mode
== USQmode
)
2463 return unsignedp
? sat_usq_type_node
: usq_type_node
;
2464 if (mode
== UDQmode
)
2465 return unsignedp
? sat_udq_type_node
: udq_type_node
;
2466 if (mode
== UTQmode
)
2467 return unsignedp
? sat_utq_type_node
: utq_type_node
;
2470 return unsignedp
? sat_ha_type_node
: ha_type_node
;
2472 return unsignedp
? sat_sa_type_node
: sa_type_node
;
2474 return unsignedp
? sat_da_type_node
: da_type_node
;
2476 return unsignedp
? sat_ta_type_node
: ta_type_node
;
2478 if (mode
== UHAmode
)
2479 return unsignedp
? sat_uha_type_node
: uha_type_node
;
2480 if (mode
== USAmode
)
2481 return unsignedp
? sat_usa_type_node
: usa_type_node
;
2482 if (mode
== UDAmode
)
2483 return unsignedp
? sat_uda_type_node
: uda_type_node
;
2484 if (mode
== UTAmode
)
2485 return unsignedp
? sat_uta_type_node
: uta_type_node
;
2488 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
2489 if (TYPE_MODE (TREE_VALUE (t
)) == mode
2490 && !!unsignedp
== !!TYPE_UNSIGNED (TREE_VALUE (t
)))
2491 return TREE_VALUE (t
);
2497 c_common_unsigned_type (tree type
)
2499 return c_common_signed_or_unsigned_type (1, type
);
2502 /* Return a signed type the same as TYPE in other respects. */
2505 c_common_signed_type (tree type
)
2507 return c_common_signed_or_unsigned_type (0, type
);
2510 /* Return a type the same as TYPE except unsigned or
2511 signed according to UNSIGNEDP. */
2514 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
2519 /* This block of code emulates the behavior of the old
2520 c_common_unsigned_type. In particular, it returns
2521 long_unsigned_type_node if passed a long, even when a int would
2522 have the same size. This is necessary for warnings to work
2523 correctly in archs where sizeof(int) == sizeof(long) */
2525 type1
= TYPE_MAIN_VARIANT (type
);
2526 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
2527 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2528 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2529 return unsignedp
? unsigned_type_node
: integer_type_node
;
2530 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2531 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2532 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2533 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2534 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
2535 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2537 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2538 if (int_n_enabled_p
[i
]
2539 && (type1
== int_n_trees
[i
].unsigned_type
2540 || type1
== int_n_trees
[i
].signed_type
))
2541 return (unsignedp
? int_n_trees
[i
].unsigned_type
2542 : int_n_trees
[i
].signed_type
);
2544 #if HOST_BITS_PER_WIDE_INT >= 64
2545 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2546 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2548 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2549 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2550 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2551 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2552 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2553 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2554 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2555 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2557 #define C_COMMON_FIXED_TYPES(NAME) \
2558 if (type1 == short_ ## NAME ## _type_node \
2559 || type1 == unsigned_short_ ## NAME ## _type_node) \
2560 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2561 : short_ ## NAME ## _type_node; \
2562 if (type1 == NAME ## _type_node \
2563 || type1 == unsigned_ ## NAME ## _type_node) \
2564 return unsignedp ? unsigned_ ## NAME ## _type_node \
2565 : NAME ## _type_node; \
2566 if (type1 == long_ ## NAME ## _type_node \
2567 || type1 == unsigned_long_ ## NAME ## _type_node) \
2568 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2569 : long_ ## NAME ## _type_node; \
2570 if (type1 == long_long_ ## NAME ## _type_node \
2571 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2572 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2573 : long_long_ ## NAME ## _type_node;
2575 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
2576 if (type1 == NAME ## _type_node \
2577 || type1 == u ## NAME ## _type_node) \
2578 return unsignedp ? u ## NAME ## _type_node \
2579 : NAME ## _type_node;
2581 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
2582 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2583 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2584 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2585 : sat_ ## short_ ## NAME ## _type_node; \
2586 if (type1 == sat_ ## NAME ## _type_node \
2587 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2588 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2589 : sat_ ## NAME ## _type_node; \
2590 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2591 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2592 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2593 : sat_ ## long_ ## NAME ## _type_node; \
2594 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2595 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2596 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2597 : sat_ ## long_long_ ## NAME ## _type_node;
2599 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
2600 if (type1 == sat_ ## NAME ## _type_node \
2601 || type1 == sat_ ## u ## NAME ## _type_node) \
2602 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2603 : sat_ ## NAME ## _type_node;
2605 C_COMMON_FIXED_TYPES (fract
);
2606 C_COMMON_FIXED_TYPES_SAT (fract
);
2607 C_COMMON_FIXED_TYPES (accum
);
2608 C_COMMON_FIXED_TYPES_SAT (accum
);
2610 C_COMMON_FIXED_MODE_TYPES (qq
);
2611 C_COMMON_FIXED_MODE_TYPES (hq
);
2612 C_COMMON_FIXED_MODE_TYPES (sq
);
2613 C_COMMON_FIXED_MODE_TYPES (dq
);
2614 C_COMMON_FIXED_MODE_TYPES (tq
);
2615 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
2616 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
2617 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
2618 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
2619 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
2620 C_COMMON_FIXED_MODE_TYPES (ha
);
2621 C_COMMON_FIXED_MODE_TYPES (sa
);
2622 C_COMMON_FIXED_MODE_TYPES (da
);
2623 C_COMMON_FIXED_MODE_TYPES (ta
);
2624 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
2625 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
2626 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
2627 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
2629 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2630 the precision; they have precision set to match their range, but
2631 may use a wider mode to match an ABI. If we change modes, we may
2632 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2633 the precision as well, so as to yield correct results for
2634 bit-field types. C++ does not have these separate bit-field
2635 types, and producing a signed or unsigned variant of an
2636 ENUMERAL_TYPE may cause other problems as well. */
2638 if (!INTEGRAL_TYPE_P (type
)
2639 || TYPE_UNSIGNED (type
) == unsignedp
)
2642 #define TYPE_OK(node) \
2643 (TYPE_MODE (type) == TYPE_MODE (node) \
2644 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2645 if (TYPE_OK (signed_char_type_node
))
2646 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2647 if (TYPE_OK (integer_type_node
))
2648 return unsignedp
? unsigned_type_node
: integer_type_node
;
2649 if (TYPE_OK (short_integer_type_node
))
2650 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2651 if (TYPE_OK (long_integer_type_node
))
2652 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2653 if (TYPE_OK (long_long_integer_type_node
))
2654 return (unsignedp
? long_long_unsigned_type_node
2655 : long_long_integer_type_node
);
2657 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2658 if (int_n_enabled_p
[i
]
2659 && TYPE_MODE (type
) == int_n_data
[i
].m
2660 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2661 return (unsignedp
? int_n_trees
[i
].unsigned_type
2662 : int_n_trees
[i
].signed_type
);
2664 #if HOST_BITS_PER_WIDE_INT >= 64
2665 if (TYPE_OK (intTI_type_node
))
2666 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2668 if (TYPE_OK (intDI_type_node
))
2669 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2670 if (TYPE_OK (intSI_type_node
))
2671 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2672 if (TYPE_OK (intHI_type_node
))
2673 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2674 if (TYPE_OK (intQI_type_node
))
2675 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2678 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2681 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2684 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
2688 /* Extended integer types of the same width as a standard type have
2689 lesser rank, so those of the same width as int promote to int or
2690 unsigned int and are valid for printf formats expecting int or
2691 unsigned int. To avoid such special cases, avoid creating
2692 extended integer types for bit-fields if a standard integer type
2694 if (width
== TYPE_PRECISION (integer_type_node
))
2695 return unsignedp
? unsigned_type_node
: integer_type_node
;
2696 if (width
== TYPE_PRECISION (signed_char_type_node
))
2697 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2698 if (width
== TYPE_PRECISION (short_integer_type_node
))
2699 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2700 if (width
== TYPE_PRECISION (long_integer_type_node
))
2701 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2702 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
2703 return (unsignedp
? long_long_unsigned_type_node
2704 : long_long_integer_type_node
);
2705 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2706 if (int_n_enabled_p
[i
]
2707 && width
== int_n_data
[i
].bitsize
)
2708 return (unsignedp
? int_n_trees
[i
].unsigned_type
2709 : int_n_trees
[i
].signed_type
);
2710 return build_nonstandard_integer_type (width
, unsignedp
);
2713 /* The C version of the register_builtin_type langhook. */
2716 c_register_builtin_type (tree type
, const char* name
)
2720 decl
= build_decl (UNKNOWN_LOCATION
,
2721 TYPE_DECL
, get_identifier (name
), type
);
2722 DECL_ARTIFICIAL (decl
) = 1;
2723 if (!TYPE_NAME (type
))
2724 TYPE_NAME (type
) = decl
;
2725 lang_hooks
.decls
.pushdecl (decl
);
2727 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
2730 /* Print an error message for invalid operands to arith operation
2731 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
2732 RICHLOC is a rich location for the message, containing either
2733 three separate locations for each of the operator and operands
2738 (C FE), or one location ranging over all over them
2746 binary_op_error (rich_location
*richloc
, enum tree_code code
,
2747 tree type0
, tree type1
)
2754 opname
= "+"; break;
2756 opname
= "-"; break;
2758 opname
= "*"; break;
2760 opname
= "max"; break;
2762 opname
= "min"; break;
2764 opname
= "=="; break;
2766 opname
= "!="; break;
2768 opname
= "<="; break;
2770 opname
= ">="; break;
2772 opname
= "<"; break;
2774 opname
= ">"; break;
2776 opname
= "<<"; break;
2778 opname
= ">>"; break;
2779 case TRUNC_MOD_EXPR
:
2780 case FLOOR_MOD_EXPR
:
2781 opname
= "%"; break;
2782 case TRUNC_DIV_EXPR
:
2783 case FLOOR_DIV_EXPR
:
2784 opname
= "/"; break;
2786 opname
= "&"; break;
2788 opname
= "|"; break;
2789 case TRUTH_ANDIF_EXPR
:
2790 opname
= "&&"; break;
2791 case TRUTH_ORIF_EXPR
:
2792 opname
= "||"; break;
2794 opname
= "^"; break;
2799 "invalid operands to binary %s (have %qT and %qT)",
2800 opname
, type0
, type1
);
2803 /* Given an expression as a tree, return its original type. Do this
2804 by stripping any conversion that preserves the sign and precision. */
2806 expr_original_type (tree expr
)
2808 STRIP_SIGN_NOPS (expr
);
2809 return TREE_TYPE (expr
);
2812 /* Subroutine of build_binary_op, used for comparison operations.
2813 See if the operands have both been converted from subword integer types
2814 and, if so, perhaps change them both back to their original type.
2815 This function is also responsible for converting the two operands
2816 to the proper common type for comparison.
2818 The arguments of this function are all pointers to local variables
2819 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2820 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2822 LOC is the location of the comparison.
2824 If this function returns non-NULL_TREE, it means that the comparison has
2825 a constant value. What this function returns is an expression for
2829 shorten_compare (location_t loc
, tree
*op0_ptr
, tree
*op1_ptr
,
2830 tree
*restype_ptr
, enum tree_code
*rescode_ptr
)
2833 tree op0
= *op0_ptr
;
2834 tree op1
= *op1_ptr
;
2835 int unsignedp0
, unsignedp1
;
2837 tree primop0
, primop1
;
2838 enum tree_code code
= *rescode_ptr
;
2840 /* Throw away any conversions to wider types
2841 already present in the operands. */
2843 primop0
= c_common_get_narrower (op0
, &unsignedp0
);
2844 primop1
= c_common_get_narrower (op1
, &unsignedp1
);
2846 /* If primopN is first sign-extended from primopN's precision to opN's
2847 precision, then zero-extended from opN's precision to
2848 *restype_ptr precision, shortenings might be invalid. */
2849 if (TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (TREE_TYPE (op0
))
2850 && TYPE_PRECISION (TREE_TYPE (op0
)) < TYPE_PRECISION (*restype_ptr
)
2852 && TYPE_UNSIGNED (TREE_TYPE (op0
)))
2854 if (TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (TREE_TYPE (op1
))
2855 && TYPE_PRECISION (TREE_TYPE (op1
)) < TYPE_PRECISION (*restype_ptr
)
2857 && TYPE_UNSIGNED (TREE_TYPE (op1
)))
2860 /* Handle the case that OP0 does not *contain* a conversion
2861 but it *requires* conversion to FINAL_TYPE. */
2863 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2864 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2865 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2866 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2868 /* If one of the operands must be floated, we cannot optimize. */
2869 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2870 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2872 /* If first arg is constant, swap the args (changing operation
2873 so value is preserved), for canonicalization. Don't do this if
2874 the second arg is 0. */
2876 if (TREE_CONSTANT (primop0
)
2877 && !integer_zerop (primop1
) && !real_zerop (primop1
)
2878 && !fixed_zerop (primop1
))
2880 std::swap (primop0
, primop1
);
2881 std::swap (op0
, op1
);
2884 std::swap (unsignedp0
, unsignedp1
);
2885 std::swap (real1
, real2
);
2904 *rescode_ptr
= code
;
2907 /* If comparing an integer against a constant more bits wide,
2908 maybe we can deduce a value of 1 or 0 independent of the data.
2909 Or else truncate the constant now
2910 rather than extend the variable at run time.
2912 This is only interesting if the constant is the wider arg.
2913 Also, it is not safe if the constant is unsigned and the
2914 variable arg is signed, since in this case the variable
2915 would be sign-extended and then regarded as unsigned.
2916 Our technique fails in this case because the lowest/highest
2917 possible unsigned results don't follow naturally from the
2918 lowest/highest possible values of the variable operand.
2919 For just EQ_EXPR and NE_EXPR there is another technique that
2920 could be used: see if the constant can be faithfully represented
2921 in the other operand's type, by truncating it and reextending it
2922 and see if that preserves the constant's value. */
2924 if (!real1
&& !real2
2925 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
2926 && TREE_CODE (primop1
) == INTEGER_CST
2927 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2929 int min_gt
, max_gt
, min_lt
, max_lt
;
2930 tree maxval
, minval
;
2931 /* 1 if comparison is nominally unsigned. */
2932 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
2935 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2936 TREE_TYPE (primop0
));
2938 maxval
= TYPE_MAX_VALUE (type
);
2939 minval
= TYPE_MIN_VALUE (type
);
2941 if (unsignedp
&& !unsignedp0
)
2942 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2944 if (TREE_TYPE (primop1
) != *restype_ptr
)
2946 /* Convert primop1 to target type, but do not introduce
2947 additional overflow. We know primop1 is an int_cst. */
2948 primop1
= force_fit_type (*restype_ptr
,
2951 TYPE_PRECISION (*restype_ptr
)),
2952 0, TREE_OVERFLOW (primop1
));
2954 if (type
!= *restype_ptr
)
2956 minval
= convert (*restype_ptr
, minval
);
2957 maxval
= convert (*restype_ptr
, maxval
);
2960 min_gt
= tree_int_cst_lt (primop1
, minval
);
2961 max_gt
= tree_int_cst_lt (primop1
, maxval
);
2962 min_lt
= tree_int_cst_lt (minval
, primop1
);
2963 max_lt
= tree_int_cst_lt (maxval
, primop1
);
2966 /* This used to be a switch, but Genix compiler can't handle that. */
2967 if (code
== NE_EXPR
)
2969 if (max_lt
|| min_gt
)
2970 val
= truthvalue_true_node
;
2972 else if (code
== EQ_EXPR
)
2974 if (max_lt
|| min_gt
)
2975 val
= truthvalue_false_node
;
2977 else if (code
== LT_EXPR
)
2980 val
= truthvalue_true_node
;
2982 val
= truthvalue_false_node
;
2984 else if (code
== GT_EXPR
)
2987 val
= truthvalue_true_node
;
2989 val
= truthvalue_false_node
;
2991 else if (code
== LE_EXPR
)
2994 val
= truthvalue_true_node
;
2996 val
= truthvalue_false_node
;
2998 else if (code
== GE_EXPR
)
3001 val
= truthvalue_true_node
;
3003 val
= truthvalue_false_node
;
3006 /* If primop0 was sign-extended and unsigned comparison specd,
3007 we did a signed comparison above using the signed type bounds.
3008 But the comparison we output must be unsigned.
3010 Also, for inequalities, VAL is no good; but if the signed
3011 comparison had *any* fixed result, it follows that the
3012 unsigned comparison just tests the sign in reverse
3013 (positive values are LE, negative ones GE).
3014 So we can generate an unsigned comparison
3015 against an extreme value of the signed type. */
3017 if (unsignedp
&& !unsignedp0
)
3024 primop1
= TYPE_MIN_VALUE (type
);
3030 primop1
= TYPE_MAX_VALUE (type
);
3037 type
= c_common_unsigned_type (type
);
3040 if (TREE_CODE (primop0
) != INTEGER_CST
3041 /* Don't warn if it's from a (non-system) macro. */
3042 && !(from_macro_expansion_at
3043 (expansion_point_location_if_in_system_header
3044 (EXPR_LOCATION (primop0
)))))
3046 if (val
== truthvalue_false_node
)
3047 warning_at (loc
, OPT_Wtype_limits
,
3048 "comparison is always false due to limited range of data type");
3049 if (val
== truthvalue_true_node
)
3050 warning_at (loc
, OPT_Wtype_limits
,
3051 "comparison is always true due to limited range of data type");
3056 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3057 if (TREE_SIDE_EFFECTS (primop0
))
3058 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
3062 /* Value is not predetermined, but do the comparison
3063 in the type of the operand that is not constant.
3064 TYPE is already properly set. */
3067 /* If either arg is decimal float and the other is float, find the
3068 proper common type to use for comparison. */
3069 else if (real1
&& real2
3070 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3071 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
))))
3072 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3074 /* If either arg is decimal float and the other is float, fail. */
3075 else if (real1
&& real2
3076 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3077 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
3080 else if (real1
&& real2
3081 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3082 == TYPE_PRECISION (TREE_TYPE (primop1
))))
3083 type
= TREE_TYPE (primop0
);
3085 /* If args' natural types are both narrower than nominal type
3086 and both extend in the same manner, compare them
3087 in the type of the wider arg.
3088 Otherwise must actually extend both to the nominal
3089 common type lest different ways of extending
3091 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3093 else if (unsignedp0
== unsignedp1
&& real1
== real2
3094 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
3095 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
3097 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3098 type
= c_common_signed_or_unsigned_type (unsignedp0
3099 || TYPE_UNSIGNED (*restype_ptr
),
3101 /* Make sure shorter operand is extended the right way
3102 to match the longer operand. */
3104 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
3105 TREE_TYPE (primop0
)),
3108 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
3109 TREE_TYPE (primop1
)),
3114 /* Here we must do the comparison on the nominal type
3115 using the args exactly as we received them. */
3116 type
= *restype_ptr
;
3120 /* We want to fold unsigned comparisons of >= and < against zero.
3121 For these, we may also issue a warning if we have a non-constant
3122 compared against zero, where the zero was spelled as "0" (rather
3123 than merely folding to it).
3124 If we have at least one constant, then op1 is constant
3125 and we may have a non-constant expression as op0. */
3126 if (!real1
&& !real2
&& integer_zerop (primop1
)
3127 && TYPE_UNSIGNED (*restype_ptr
))
3129 tree value
= NULL_TREE
;
3130 /* All unsigned values are >= 0, so we warn. However,
3131 if OP0 is a constant that is >= 0, the signedness of
3132 the comparison isn't an issue, so suppress the
3134 tree folded_op0
= fold_for_warn (op0
);
3136 warn_type_limits
&& !in_system_header_at (loc
)
3137 && !(TREE_CODE (folded_op0
) == INTEGER_CST
3138 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3140 /* Do not warn for enumeration types. */
3141 && (TREE_CODE (expr_original_type (folded_op0
)) != ENUMERAL_TYPE
);
3147 warning_at (loc
, OPT_Wtype_limits
,
3148 "comparison of unsigned expression >= 0 is always true");
3149 value
= truthvalue_true_node
;
3154 warning_at (loc
, OPT_Wtype_limits
,
3155 "comparison of unsigned expression < 0 is always false");
3156 value
= truthvalue_false_node
;
3163 if (value
!= NULL_TREE
)
3165 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3166 if (TREE_SIDE_EFFECTS (primop0
))
3167 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3174 *op0_ptr
= convert (type
, primop0
);
3175 *op1_ptr
= convert (type
, primop1
);
3177 *restype_ptr
= truthvalue_type_node
;
3182 /* Return a tree for the sum or difference (RESULTCODE says which)
3183 of pointer PTROP and integer INTOP. */
3186 pointer_int_sum (location_t loc
, enum tree_code resultcode
,
3187 tree ptrop
, tree intop
, bool complain
)
3191 /* The result is a pointer of the same type that is being added. */
3192 tree result_type
= TREE_TYPE (ptrop
);
3194 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3196 if (complain
&& warn_pointer_arith
)
3197 pedwarn (loc
, OPT_Wpointer_arith
,
3198 "pointer of type %<void *%> used in arithmetic");
3200 return error_mark_node
;
3201 size_exp
= integer_one_node
;
3203 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3205 if (complain
&& warn_pointer_arith
)
3206 pedwarn (loc
, OPT_Wpointer_arith
,
3207 "pointer to a function used in arithmetic");
3209 return error_mark_node
;
3210 size_exp
= integer_one_node
;
3213 size_exp
= size_in_bytes_loc (loc
, TREE_TYPE (result_type
));
3215 /* We are manipulating pointer values, so we don't need to warn
3216 about relying on undefined signed overflow. We disable the
3217 warning here because we use integer types so fold won't know that
3218 they are really pointers. */
3219 fold_defer_overflow_warnings ();
3221 /* If what we are about to multiply by the size of the elements
3222 contains a constant term, apply distributive law
3223 and multiply that constant term separately.
3224 This helps produce common subexpressions. */
3225 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3226 && !TREE_CONSTANT (intop
)
3227 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3228 && TREE_CONSTANT (size_exp
)
3229 /* If the constant comes from pointer subtraction,
3230 skip this optimization--it would cause an error. */
3231 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
3232 /* If the constant is unsigned, and smaller than the pointer size,
3233 then we must skip this optimization. This is because it could cause
3234 an overflow error if the constant is negative but INTOP is not. */
3235 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
3236 || (TYPE_PRECISION (TREE_TYPE (intop
))
3237 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
3239 enum tree_code subcode
= resultcode
;
3240 tree int_type
= TREE_TYPE (intop
);
3241 if (TREE_CODE (intop
) == MINUS_EXPR
)
3242 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3243 /* Convert both subexpression types to the type of intop,
3244 because weird cases involving pointer arithmetic
3245 can result in a sum or difference with different type args. */
3246 ptrop
= build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop
, 1)),
3248 convert (int_type
, TREE_OPERAND (intop
, 1)),
3250 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
3253 /* Convert the integer argument to a type the same size as sizetype
3254 so the multiply won't overflow spuriously. */
3255 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
3256 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
3257 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
3258 TYPE_UNSIGNED (sizetype
)), intop
);
3260 /* Replace the integer argument with a suitable product by the object size.
3261 Do this multiplication as signed, then convert to the appropriate type
3262 for the pointer operation and disregard an overflow that occurred only
3263 because of the sign-extension change in the latter conversion. */
3265 tree t
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (intop
), intop
,
3266 convert (TREE_TYPE (intop
), size_exp
));
3267 intop
= convert (sizetype
, t
);
3268 if (TREE_OVERFLOW_P (intop
) && !TREE_OVERFLOW (t
))
3269 intop
= wide_int_to_tree (TREE_TYPE (intop
), wi::to_wide (intop
));
3272 /* Create the sum or difference. */
3273 if (resultcode
== MINUS_EXPR
)
3274 intop
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, intop
);
3276 ret
= fold_build_pointer_plus_loc (loc
, ptrop
, intop
);
3278 fold_undefer_and_ignore_overflow_warnings ();
3283 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3284 and if NON_CONST is known not to be permitted in an evaluated part
3285 of a constant expression. */
3288 c_wrap_maybe_const (tree expr
, bool non_const
)
3290 bool nowarning
= TREE_NO_WARNING (expr
);
3291 location_t loc
= EXPR_LOCATION (expr
);
3293 /* This should never be called for C++. */
3294 if (c_dialect_cxx ())
3297 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3298 STRIP_TYPE_NOPS (expr
);
3299 expr
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL
, expr
);
3300 C_MAYBE_CONST_EXPR_NON_CONST (expr
) = non_const
;
3302 TREE_NO_WARNING (expr
) = 1;
3303 protected_set_expr_location (expr
, loc
);
3308 /* Return whether EXPR is a declaration whose address can never be
3312 decl_with_nonnull_addr_p (const_tree expr
)
3314 return (DECL_P (expr
)
3315 && (TREE_CODE (expr
) == PARM_DECL
3316 || TREE_CODE (expr
) == LABEL_DECL
3317 || !DECL_WEAK (expr
)));
3320 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3321 or for an `if' or `while' statement or ?..: exp. It should already
3322 have been validated to be of suitable type; otherwise, a bad
3323 diagnostic may result.
3325 The EXPR is located at LOCATION.
3327 This preparation consists of taking the ordinary
3328 representation of an expression expr and producing a valid tree
3329 boolean expression describing whether expr is nonzero. We could
3330 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3331 but we optimize comparisons, &&, ||, and !.
3333 The resulting type should always be `truthvalue_type_node'. */
3336 c_common_truthvalue_conversion (location_t location
, tree expr
)
3338 STRIP_ANY_LOCATION_WRAPPER (expr
);
3339 switch (TREE_CODE (expr
))
3341 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
3342 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3343 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
3344 case ORDERED_EXPR
: case UNORDERED_EXPR
:
3345 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3347 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3348 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
3351 case TRUTH_ANDIF_EXPR
:
3352 case TRUTH_ORIF_EXPR
:
3353 case TRUTH_AND_EXPR
:
3355 case TRUTH_XOR_EXPR
:
3356 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3358 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3359 c_common_truthvalue_conversion (location
,
3360 TREE_OPERAND (expr
, 0)),
3361 c_common_truthvalue_conversion (location
,
3362 TREE_OPERAND (expr
, 1)));
3365 case TRUTH_NOT_EXPR
:
3366 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3368 expr
= build1 (TREE_CODE (expr
), truthvalue_type_node
,
3369 c_common_truthvalue_conversion (location
,
3370 TREE_OPERAND (expr
, 0)));
3377 if (TREE_CODE (TREE_TYPE (expr
)) == ENUMERAL_TYPE
3378 && !integer_zerop (expr
)
3379 && !integer_onep (expr
))
3380 warning_at (location
, OPT_Wint_in_bool_context
,
3381 "enum constant in boolean context");
3382 return integer_zerop (expr
) ? truthvalue_false_node
3383 : truthvalue_true_node
;
3386 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3387 ? truthvalue_true_node
3388 : truthvalue_false_node
;
3391 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3392 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3393 ? truthvalue_true_node
3394 : truthvalue_false_node
;
3397 expr
= build_unary_op (location
, ADDR_EXPR
, expr
, false);
3402 tree inner
= TREE_OPERAND (expr
, 0);
3403 if (decl_with_nonnull_addr_p (inner
))
3405 /* Common Ada programmer's mistake. */
3406 warning_at (location
,
3408 "the address of %qD will always evaluate as %<true%>",
3410 return truthvalue_true_node
;
3416 expr
= build_binary_op (EXPR_LOCATION (expr
),
3417 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3418 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3419 c_common_truthvalue_conversion (location
,
3420 TREE_OPERAND (expr
, 0)),
3421 c_common_truthvalue_conversion (location
,
3422 TREE_OPERAND (expr
, 1)),
3430 case EXCESS_PRECISION_EXPR
:
3431 /* These don't change whether an object is nonzero or zero. */
3432 return c_common_truthvalue_conversion (location
, TREE_OPERAND (expr
, 0));
3436 /* These don't change whether an object is zero or nonzero, but
3437 we can't ignore them if their second arg has side-effects. */
3438 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3440 expr
= build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3441 TREE_OPERAND (expr
, 1),
3442 c_common_truthvalue_conversion
3443 (location
, TREE_OPERAND (expr
, 0)));
3447 return c_common_truthvalue_conversion (location
,
3448 TREE_OPERAND (expr
, 0));
3451 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3452 "%<*%> in boolean context, suggest %<&&%> instead");
3456 /* We will only warn on signed shifts here, because the majority of
3457 false positive warnings happen in code where unsigned arithmetic
3458 was used in anticipation of a possible overflow.
3459 Furthermore, if we see an unsigned type here we know that the
3460 result of the shift is not subject to integer promotion rules. */
3461 if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
3462 && !TYPE_UNSIGNED (TREE_TYPE (expr
)))
3463 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3464 "%<<<%> in boolean context, did you mean %<<%> ?");
3468 if (warn_int_in_bool_context
3469 && !from_macro_definition_at (EXPR_LOCATION (expr
)))
3471 tree val1
= fold_for_warn (TREE_OPERAND (expr
, 1));
3472 tree val2
= fold_for_warn (TREE_OPERAND (expr
, 2));
3473 if (TREE_CODE (val1
) == INTEGER_CST
3474 && TREE_CODE (val2
) == INTEGER_CST
3475 && !integer_zerop (val1
)
3476 && !integer_zerop (val2
)
3477 && (!integer_onep (val1
)
3478 || !integer_onep (val2
)))
3479 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3480 "?: using integer constants in boolean context, "
3481 "the expression will always evaluate to %<true%>");
3482 else if ((TREE_CODE (val1
) == INTEGER_CST
3483 && !integer_zerop (val1
)
3484 && !integer_onep (val1
))
3485 || (TREE_CODE (val2
) == INTEGER_CST
3486 && !integer_zerop (val2
)
3487 && !integer_onep (val2
)))
3488 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3489 "?: using integer constants in boolean context");
3491 /* Distribute the conversion into the arms of a COND_EXPR. */
3492 if (c_dialect_cxx ())
3493 /* Avoid premature folding. */
3497 int w
= warn_int_in_bool_context
;
3498 warn_int_in_bool_context
= 0;
3499 /* Folding will happen later for C. */
3500 expr
= build3 (COND_EXPR
, truthvalue_type_node
,
3501 TREE_OPERAND (expr
, 0),
3502 c_common_truthvalue_conversion (location
,
3503 TREE_OPERAND (expr
, 1)),
3504 c_common_truthvalue_conversion (location
,
3505 TREE_OPERAND (expr
, 2)));
3506 warn_int_in_bool_context
= w
;
3512 tree totype
= TREE_TYPE (expr
);
3513 tree fromtype
= TREE_TYPE (TREE_OPERAND (expr
, 0));
3515 if (POINTER_TYPE_P (totype
)
3516 && !c_inhibit_evaluation_warnings
3517 && TREE_CODE (fromtype
) == REFERENCE_TYPE
)
3523 warning_at (location
,
3525 "the compiler can assume that the address of "
3526 "%qD will always evaluate to %<true%>",
3530 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3531 since that affects how `default_conversion' will behave. */
3532 if (TREE_CODE (totype
) == REFERENCE_TYPE
3533 || TREE_CODE (fromtype
) == REFERENCE_TYPE
)
3535 /* Don't strip a conversion from C++0x scoped enum, since they
3536 don't implicitly convert to other types. */
3537 if (TREE_CODE (fromtype
) == ENUMERAL_TYPE
3538 && ENUM_IS_SCOPED (fromtype
))
3540 /* If this isn't narrowing the argument, we can ignore it. */
3541 if (TYPE_PRECISION (totype
) >= TYPE_PRECISION (fromtype
))
3542 return c_common_truthvalue_conversion (location
,
3543 TREE_OPERAND (expr
, 0));
3548 if (!TREE_NO_WARNING (expr
)
3550 && warning_at (location
, OPT_Wparentheses
,
3551 "suggest parentheses around assignment used as "
3553 TREE_NO_WARNING (expr
) = 1;
3558 tree folded_expr
= fold_for_warn (expr
);
3559 if (folded_expr
!= expr
)
3560 return c_common_truthvalue_conversion (location
, folded_expr
);
3568 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
3570 tree t
= save_expr (expr
);
3571 expr
= (build_binary_op
3572 (EXPR_LOCATION (expr
),
3573 (TREE_SIDE_EFFECTS (expr
)
3574 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3575 c_common_truthvalue_conversion
3577 build_unary_op (location
, REALPART_EXPR
, t
, false)),
3578 c_common_truthvalue_conversion
3580 build_unary_op (location
, IMAGPART_EXPR
, t
, false)),
3585 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
3587 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
3589 (TREE_TYPE (expr
))));
3590 return build_binary_op (location
, NE_EXPR
, expr
, fixed_zero_node
, true);
3593 return build_binary_op (location
, NE_EXPR
, expr
, integer_zero_node
, true);
3596 protected_set_expr_location (expr
, location
);
3600 static void def_builtin_1 (enum built_in_function fncode
,
3602 enum built_in_class fnclass
,
3603 tree fntype
, tree libtype
,
3604 bool both_p
, bool fallback_p
, bool nonansi_p
,
3605 tree fnattrs
, bool implicit_p
);
3608 /* Apply the TYPE_QUALS to the new DECL. */
3611 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
3613 tree type
= TREE_TYPE (decl
);
3615 if (type
== error_mark_node
)
3618 if ((type_quals
& TYPE_QUAL_CONST
)
3619 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
3620 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
3621 constructor can produce constant init, so rely on cp_finish_decl to
3622 clear TREE_READONLY if the variable has non-constant init. */
3623 TREE_READONLY (decl
) = 1;
3624 if (type_quals
& TYPE_QUAL_VOLATILE
)
3626 TREE_SIDE_EFFECTS (decl
) = 1;
3627 TREE_THIS_VOLATILE (decl
) = 1;
3629 if (type_quals
& TYPE_QUAL_RESTRICT
)
3631 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
3632 /* Allow 'restrict' on arrays of pointers.
3633 FIXME currently we just ignore it. */
3634 type
= TREE_TYPE (type
);
3636 || !POINTER_TYPE_P (type
)
3637 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
3638 error ("invalid use of %<restrict%>");
3642 /* Return the typed-based alias set for T, which may be an expression
3643 or a type. Return -1 if we don't do anything special. */
3646 c_common_get_alias_set (tree t
)
3648 /* For VLAs, use the alias set of the element type rather than the
3649 default of alias set 0 for types compared structurally. */
3650 if (TYPE_P (t
) && TYPE_STRUCTURAL_EQUALITY_P (t
))
3652 if (TREE_CODE (t
) == ARRAY_TYPE
)
3653 return get_alias_set (TREE_TYPE (t
));
3657 /* That's all the expressions we handle specially. */
3661 /* Unlike char, char8_t doesn't alias. */
3662 if (flag_char8_t
&& t
== char8_type_node
)
3665 /* The C standard guarantees that any object may be accessed via an
3666 lvalue that has narrow character type (except char8_t). */
3667 if (t
== char_type_node
3668 || t
== signed_char_type_node
3669 || t
== unsigned_char_type_node
)
3672 /* The C standard specifically allows aliasing between signed and
3673 unsigned variants of the same type. We treat the signed
3674 variant as canonical. */
3675 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
3677 tree t1
= c_common_signed_type (t
);
3679 /* t1 == t can happen for boolean nodes which are always unsigned. */
3681 return get_alias_set (t1
);
3687 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
3688 the IS_SIZEOF parameter indicates which operator is being applied.
3689 The COMPLAIN flag controls whether we should diagnose possibly
3690 ill-formed constructs or not. LOC is the location of the SIZEOF or
3691 TYPEOF operator. If MIN_ALIGNOF, the least alignment required for
3692 a type in any context should be returned, rather than the normal
3693 alignment for that type. */
3696 c_sizeof_or_alignof_type (location_t loc
,
3697 tree type
, bool is_sizeof
, bool min_alignof
,
3700 const char *op_name
;
3702 enum tree_code type_code
= TREE_CODE (type
);
3704 op_name
= is_sizeof
? "sizeof" : "__alignof__";
3706 if (type_code
== FUNCTION_TYPE
)
3710 if (complain
&& warn_pointer_arith
)
3711 pedwarn (loc
, OPT_Wpointer_arith
,
3712 "invalid application of %<sizeof%> to a function type");
3714 return error_mark_node
;
3715 value
= size_one_node
;
3721 if (c_dialect_cxx ())
3722 pedwarn (loc
, OPT_Wpedantic
, "ISO C++ does not permit "
3723 "%<alignof%> applied to a function type");
3725 pedwarn (loc
, OPT_Wpedantic
, "ISO C does not permit "
3726 "%<_Alignof%> applied to a function type");
3728 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3731 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3733 if (type_code
== VOID_TYPE
3734 && complain
&& warn_pointer_arith
)
3735 pedwarn (loc
, OPT_Wpointer_arith
,
3736 "invalid application of %qs to a void type", op_name
);
3738 return error_mark_node
;
3739 value
= size_one_node
;
3741 else if (!COMPLETE_TYPE_P (type
)
3742 && (!c_dialect_cxx () || is_sizeof
|| type_code
!= ARRAY_TYPE
))
3745 error_at (loc
, "invalid application of %qs to incomplete type %qT",
3747 return error_mark_node
;
3749 else if (c_dialect_cxx () && type_code
== ARRAY_TYPE
3750 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
3753 error_at (loc
, "invalid application of %qs to array type %qT of "
3754 "incomplete element type", op_name
, type
);
3755 return error_mark_node
;
3760 /* Convert in case a char is more than one unit. */
3761 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3762 size_int (TYPE_PRECISION (char_type_node
)
3764 else if (min_alignof
)
3765 value
= size_int (min_align_of_type (type
));
3767 value
= size_int (TYPE_ALIGN_UNIT (type
));
3770 /* VALUE will have the middle-end integer type sizetype.
3771 However, we should really return a value of type `size_t',
3772 which is just a typedef for an ordinary integer type. */
3773 value
= fold_convert_loc (loc
, size_type_node
, value
);
3778 /* Implement the __alignof keyword: Return the minimum required
3779 alignment of EXPR, measured in bytes. For VAR_DECLs,
3780 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3781 from an "aligned" __attribute__ specification). LOC is the
3782 location of the ALIGNOF operator. */
3785 c_alignof_expr (location_t loc
, tree expr
)
3789 if (VAR_OR_FUNCTION_DECL_P (expr
))
3790 t
= size_int (DECL_ALIGN_UNIT (expr
));
3792 else if (TREE_CODE (expr
) == COMPONENT_REF
3793 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3795 error_at (loc
, "%<__alignof%> applied to a bit-field");
3798 else if (TREE_CODE (expr
) == COMPONENT_REF
3799 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3800 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
3802 else if (INDIRECT_REF_P (expr
))
3804 tree t
= TREE_OPERAND (expr
, 0);
3806 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3808 while (CONVERT_EXPR_P (t
)
3809 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3813 t
= TREE_OPERAND (t
, 0);
3814 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3815 if (thisalign
> bestalign
)
3816 best
= t
, bestalign
= thisalign
;
3818 return c_alignof (loc
, TREE_TYPE (TREE_TYPE (best
)));
3821 return c_alignof (loc
, TREE_TYPE (expr
));
3823 return fold_convert_loc (loc
, size_type_node
, t
);
3826 /* Handle C and C++ default attributes. */
3828 enum built_in_attribute
3830 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3831 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3832 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
3833 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3834 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3835 #include "builtin-attrs.def"
3836 #undef DEF_ATTR_NULL_TREE
3838 #undef DEF_ATTR_STRING
3839 #undef DEF_ATTR_IDENT
3840 #undef DEF_ATTR_TREE_LIST
3844 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3846 static void c_init_attributes (void);
3850 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3851 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3852 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3853 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3854 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3855 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3856 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3857 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3859 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3861 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3862 ARG6, ARG7, ARG8) NAME,
3863 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3864 ARG6, ARG7, ARG8, ARG9) NAME,
3865 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3866 ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
3867 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3868 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
3869 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3870 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3871 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3872 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3873 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3874 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3876 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3878 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3880 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3881 #include "builtin-types.def"
3882 #undef DEF_PRIMITIVE_TYPE
3883 #undef DEF_FUNCTION_TYPE_0
3884 #undef DEF_FUNCTION_TYPE_1
3885 #undef DEF_FUNCTION_TYPE_2
3886 #undef DEF_FUNCTION_TYPE_3
3887 #undef DEF_FUNCTION_TYPE_4
3888 #undef DEF_FUNCTION_TYPE_5
3889 #undef DEF_FUNCTION_TYPE_6
3890 #undef DEF_FUNCTION_TYPE_7
3891 #undef DEF_FUNCTION_TYPE_8
3892 #undef DEF_FUNCTION_TYPE_9
3893 #undef DEF_FUNCTION_TYPE_10
3894 #undef DEF_FUNCTION_TYPE_11
3895 #undef DEF_FUNCTION_TYPE_VAR_0
3896 #undef DEF_FUNCTION_TYPE_VAR_1
3897 #undef DEF_FUNCTION_TYPE_VAR_2
3898 #undef DEF_FUNCTION_TYPE_VAR_3
3899 #undef DEF_FUNCTION_TYPE_VAR_4
3900 #undef DEF_FUNCTION_TYPE_VAR_5
3901 #undef DEF_FUNCTION_TYPE_VAR_6
3902 #undef DEF_FUNCTION_TYPE_VAR_7
3903 #undef DEF_POINTER_TYPE
3907 typedef enum c_builtin_type builtin_type
;
3909 /* A temporary array for c_common_nodes_and_builtins. Used in
3910 communication with def_fn_type. */
3911 static tree builtin_types
[(int) BT_LAST
+ 1];
3913 /* A helper function for c_common_nodes_and_builtins. Build function type
3914 for DEF with return type RET and N arguments. If VAR is true, then the
3915 function should be variadic after those N arguments.
3917 Takes special care not to ICE if any of the types involved are
3918 error_mark_node, which indicates that said type is not in fact available
3919 (see builtin_type_for_size). In which case the function type as a whole
3920 should be error_mark_node. */
3923 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
3926 tree
*args
= XALLOCAVEC (tree
, n
);
3931 for (i
= 0; i
< n
; ++i
)
3933 builtin_type a
= (builtin_type
) va_arg (list
, int);
3934 t
= builtin_types
[a
];
3935 if (t
== error_mark_node
)
3940 t
= builtin_types
[ret
];
3941 if (t
== error_mark_node
)
3944 t
= build_varargs_function_type_array (t
, n
, args
);
3946 t
= build_function_type_array (t
, n
, args
);
3949 builtin_types
[def
] = t
;
3953 /* Build builtin functions common to both C and C++ language
3957 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
3959 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3960 builtin_types[ENUM] = VALUE;
3961 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3962 def_fn_type (ENUM, RETURN, 0, 0);
3963 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3964 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3965 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3966 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3967 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3968 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3969 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3970 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3971 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3972 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3973 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3975 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3976 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3978 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3979 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3981 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
3983 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3984 ARG6, ARG7, ARG8, ARG9) \
3985 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
3987 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3988 ARG6, ARG7, ARG8, ARG9, ARG10) \
3989 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
3990 ARG7, ARG8, ARG9, ARG10);
3991 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3992 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
3993 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
3994 ARG7, ARG8, ARG9, ARG10, ARG11);
3995 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3996 def_fn_type (ENUM, RETURN, 1, 0);
3997 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3998 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3999 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4000 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4001 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4002 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4003 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4004 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4005 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4006 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4007 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4009 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4010 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4012 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4013 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4014 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4016 #include "builtin-types.def"
4018 #undef DEF_PRIMITIVE_TYPE
4019 #undef DEF_FUNCTION_TYPE_0
4020 #undef DEF_FUNCTION_TYPE_1
4021 #undef DEF_FUNCTION_TYPE_2
4022 #undef DEF_FUNCTION_TYPE_3
4023 #undef DEF_FUNCTION_TYPE_4
4024 #undef DEF_FUNCTION_TYPE_5
4025 #undef DEF_FUNCTION_TYPE_6
4026 #undef DEF_FUNCTION_TYPE_7
4027 #undef DEF_FUNCTION_TYPE_8
4028 #undef DEF_FUNCTION_TYPE_9
4029 #undef DEF_FUNCTION_TYPE_10
4030 #undef DEF_FUNCTION_TYPE_11
4031 #undef DEF_FUNCTION_TYPE_VAR_0
4032 #undef DEF_FUNCTION_TYPE_VAR_1
4033 #undef DEF_FUNCTION_TYPE_VAR_2
4034 #undef DEF_FUNCTION_TYPE_VAR_3
4035 #undef DEF_FUNCTION_TYPE_VAR_4
4036 #undef DEF_FUNCTION_TYPE_VAR_5
4037 #undef DEF_FUNCTION_TYPE_VAR_6
4038 #undef DEF_FUNCTION_TYPE_VAR_7
4039 #undef DEF_POINTER_TYPE
4040 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
4042 c_init_attributes ();
4044 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4045 NONANSI_P, ATTRS, IMPLICIT, COND) \
4047 def_builtin_1 (ENUM, NAME, CLASS, \
4048 builtin_types[(int) TYPE], \
4049 builtin_types[(int) LIBTYPE], \
4050 BOTH_P, FALLBACK_P, NONANSI_P, \
4051 built_in_attributes[(int) ATTRS], IMPLICIT);
4052 #include "builtins.def"
4054 targetm
.init_builtins ();
4056 build_common_builtin_nodes ();
4059 /* Like get_identifier, but avoid warnings about null arguments when
4060 the argument may be NULL for targets where GCC lacks stdint.h type
4064 c_get_ident (const char *id
)
4066 return get_identifier (id
);
4069 /* Build tree nodes and builtin functions common to both C and C++ language
4073 c_common_nodes_and_builtins (void)
4075 int char8_type_size
;
4076 int char16_type_size
;
4077 int char32_type_size
;
4078 int wchar_type_size
;
4079 tree array_domain_type
;
4080 tree va_list_ref_type_node
;
4081 tree va_list_arg_type_node
;
4084 build_common_tree_nodes (flag_signed_char
);
4086 /* Define `int' and `char' first so that dbx will output them first. */
4087 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
4088 record_builtin_type (RID_CHAR
, "char", char_type_node
);
4090 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4091 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4092 but not C. Are the conditionals here needed? */
4093 if (c_dialect_cxx ())
4094 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
4095 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
4096 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
4097 record_builtin_type (RID_MAX
, "long unsigned int",
4098 long_unsigned_type_node
);
4100 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
4104 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
4105 record_builtin_type ((enum rid
)(RID_FIRST_INT_N
+ i
), name
,
4106 int_n_trees
[i
].signed_type
);
4107 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
4108 record_builtin_type (RID_MAX
, name
, int_n_trees
[i
].unsigned_type
);
4111 if (c_dialect_cxx ())
4112 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
4113 record_builtin_type (RID_MAX
, "long long int",
4114 long_long_integer_type_node
);
4115 record_builtin_type (RID_MAX
, "long long unsigned int",
4116 long_long_unsigned_type_node
);
4117 if (c_dialect_cxx ())
4118 record_builtin_type (RID_MAX
, "long long unsigned",
4119 long_long_unsigned_type_node
);
4120 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
4121 record_builtin_type (RID_MAX
, "short unsigned int",
4122 short_unsigned_type_node
);
4123 if (c_dialect_cxx ())
4124 record_builtin_type (RID_MAX
, "unsigned short",
4125 short_unsigned_type_node
);
4127 /* Define both `signed char' and `unsigned char'. */
4128 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
4129 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
4131 /* These are types that c_common_type_for_size and
4132 c_common_type_for_mode use. */
4133 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4134 TYPE_DECL
, NULL_TREE
,
4136 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4137 TYPE_DECL
, NULL_TREE
,
4139 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4140 TYPE_DECL
, NULL_TREE
,
4142 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4143 TYPE_DECL
, NULL_TREE
,
4145 #if HOST_BITS_PER_WIDE_INT >= 64
4146 /* Note that this is different than the __int128 type that's part of
4147 the generic __intN support. */
4148 if (targetm
.scalar_mode_supported_p (TImode
))
4149 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4151 get_identifier ("__int128_t"),
4154 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4155 TYPE_DECL
, NULL_TREE
,
4156 unsigned_intQI_type_node
));
4157 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4158 TYPE_DECL
, NULL_TREE
,
4159 unsigned_intHI_type_node
));
4160 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4161 TYPE_DECL
, NULL_TREE
,
4162 unsigned_intSI_type_node
));
4163 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4164 TYPE_DECL
, NULL_TREE
,
4165 unsigned_intDI_type_node
));
4166 #if HOST_BITS_PER_WIDE_INT >= 64
4167 if (targetm
.scalar_mode_supported_p (TImode
))
4168 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4170 get_identifier ("__uint128_t"),
4171 unsigned_intTI_type_node
));
4174 /* Create the widest literal types. */
4175 if (targetm
.scalar_mode_supported_p (TImode
))
4177 widest_integer_literal_type_node
= intTI_type_node
;
4178 widest_unsigned_literal_type_node
= unsigned_intTI_type_node
;
4182 widest_integer_literal_type_node
= intDI_type_node
;
4183 widest_unsigned_literal_type_node
= unsigned_intDI_type_node
;
4186 signed_size_type_node
= c_common_signed_type (size_type_node
);
4189 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
4191 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
4192 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
4193 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
4195 if (!c_dialect_cxx ())
4196 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
4197 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
)
4198 record_builtin_type ((enum rid
) (RID_FLOATN_NX_FIRST
+ i
), NULL
,
4199 FLOATN_NX_TYPE_NODE (i
));
4201 /* Only supported decimal floating point extension if the target
4202 actually supports underlying modes. */
4203 if (targetm
.scalar_mode_supported_p (SDmode
)
4204 && targetm
.scalar_mode_supported_p (DDmode
)
4205 && targetm
.scalar_mode_supported_p (TDmode
))
4207 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
4208 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
4209 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
4212 if (targetm
.fixed_point_supported_p ())
4214 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
4215 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
4216 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
4217 record_builtin_type (RID_MAX
, "long long _Fract",
4218 long_long_fract_type_node
);
4219 record_builtin_type (RID_MAX
, "unsigned short _Fract",
4220 unsigned_short_fract_type_node
);
4221 record_builtin_type (RID_MAX
, "unsigned _Fract",
4222 unsigned_fract_type_node
);
4223 record_builtin_type (RID_MAX
, "unsigned long _Fract",
4224 unsigned_long_fract_type_node
);
4225 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
4226 unsigned_long_long_fract_type_node
);
4227 record_builtin_type (RID_MAX
, "_Sat short _Fract",
4228 sat_short_fract_type_node
);
4229 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
4230 record_builtin_type (RID_MAX
, "_Sat long _Fract",
4231 sat_long_fract_type_node
);
4232 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
4233 sat_long_long_fract_type_node
);
4234 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
4235 sat_unsigned_short_fract_type_node
);
4236 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
4237 sat_unsigned_fract_type_node
);
4238 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
4239 sat_unsigned_long_fract_type_node
);
4240 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
4241 sat_unsigned_long_long_fract_type_node
);
4242 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
4243 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
4244 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
4245 record_builtin_type (RID_MAX
, "long long _Accum",
4246 long_long_accum_type_node
);
4247 record_builtin_type (RID_MAX
, "unsigned short _Accum",
4248 unsigned_short_accum_type_node
);
4249 record_builtin_type (RID_MAX
, "unsigned _Accum",
4250 unsigned_accum_type_node
);
4251 record_builtin_type (RID_MAX
, "unsigned long _Accum",
4252 unsigned_long_accum_type_node
);
4253 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
4254 unsigned_long_long_accum_type_node
);
4255 record_builtin_type (RID_MAX
, "_Sat short _Accum",
4256 sat_short_accum_type_node
);
4257 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
4258 record_builtin_type (RID_MAX
, "_Sat long _Accum",
4259 sat_long_accum_type_node
);
4260 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
4261 sat_long_long_accum_type_node
);
4262 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
4263 sat_unsigned_short_accum_type_node
);
4264 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
4265 sat_unsigned_accum_type_node
);
4266 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
4267 sat_unsigned_long_accum_type_node
);
4268 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
4269 sat_unsigned_long_long_accum_type_node
);
4273 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4275 get_identifier ("complex int"),
4276 complex_integer_type_node
));
4277 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4279 get_identifier ("complex float"),
4280 complex_float_type_node
));
4281 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4283 get_identifier ("complex double"),
4284 complex_double_type_node
));
4285 lang_hooks
.decls
.pushdecl
4286 (build_decl (UNKNOWN_LOCATION
,
4287 TYPE_DECL
, get_identifier ("complex long double"),
4288 complex_long_double_type_node
));
4290 if (!c_dialect_cxx ())
4291 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
4292 if (COMPLEX_FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
)
4295 sprintf (buf
, "complex _Float%d%s", floatn_nx_types
[i
].n
,
4296 floatn_nx_types
[i
].extended
? "x" : "");
4297 lang_hooks
.decls
.pushdecl
4298 (build_decl (UNKNOWN_LOCATION
,
4300 get_identifier (buf
),
4301 COMPLEX_FLOATN_NX_TYPE_NODE (i
)));
4304 /* Make fileptr_type_node a distinct void * type until
4305 FILE type is defined. Likewise for const struct tm*. */
4306 for (unsigned i
= 0;
4307 i
< sizeof (builtin_structptr_types
) / sizeof (builtin_structptr_type
);
4309 builtin_structptr_types
[i
].node
4310 = build_variant_type_copy (builtin_structptr_types
[i
].base
);
4312 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
4314 /* Set the TYPE_NAME for any variants that were built before
4315 record_builtin_type gave names to the built-in types. */
4317 tree void_name
= TYPE_NAME (void_type_node
);
4318 TYPE_NAME (void_type_node
) = NULL_TREE
;
4319 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
4321 TYPE_NAME (void_type_node
) = void_name
;
4324 void_list_node
= build_void_list_node ();
4326 /* Make a type to be the domain of a few array types
4327 whose domains don't really matter.
4328 200 is small enough that it always fits in size_t
4329 and large enough that it can hold most function names for the
4330 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4331 array_domain_type
= build_index_type (size_int (200));
4333 /* Make a type for arrays of characters.
4334 With luck nothing will ever really depend on the length of this
4336 char_array_type_node
4337 = build_array_type (char_type_node
, array_domain_type
);
4339 string_type_node
= build_pointer_type (char_type_node
);
4340 const_string_type_node
4341 = build_pointer_type (build_qualified_type
4342 (char_type_node
, TYPE_QUAL_CONST
));
4344 /* This is special for C++ so functions can be overloaded. */
4345 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
4346 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
4347 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
4348 underlying_wchar_type_node
= wchar_type_node
;
4349 if (c_dialect_cxx ())
4351 if (TYPE_UNSIGNED (wchar_type_node
))
4352 wchar_type_node
= make_unsigned_type (wchar_type_size
);
4354 wchar_type_node
= make_signed_type (wchar_type_size
);
4355 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
4358 /* This is for wide string constants. */
4359 wchar_array_type_node
4360 = build_array_type (wchar_type_node
, array_domain_type
);
4362 /* Define 'char8_t'. */
4363 char8_type_node
= get_identifier (CHAR8_TYPE
);
4364 char8_type_node
= TREE_TYPE (identifier_global_value (char8_type_node
));
4365 char8_type_size
= TYPE_PRECISION (char8_type_node
);
4366 if (c_dialect_cxx ())
4368 char8_type_node
= make_unsigned_type (char8_type_size
);
4371 record_builtin_type (RID_CHAR8
, "char8_t", char8_type_node
);
4374 /* This is for UTF-8 string constants. */
4375 char8_array_type_node
4376 = build_array_type (char8_type_node
, array_domain_type
);
4378 /* Define 'char16_t'. */
4379 char16_type_node
= get_identifier (CHAR16_TYPE
);
4380 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
4381 char16_type_size
= TYPE_PRECISION (char16_type_node
);
4382 if (c_dialect_cxx ())
4384 char16_type_node
= make_unsigned_type (char16_type_size
);
4386 if (cxx_dialect
>= cxx11
)
4387 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
4390 /* This is for UTF-16 string constants. */
4391 char16_array_type_node
4392 = build_array_type (char16_type_node
, array_domain_type
);
4394 /* Define 'char32_t'. */
4395 char32_type_node
= get_identifier (CHAR32_TYPE
);
4396 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
4397 char32_type_size
= TYPE_PRECISION (char32_type_node
);
4398 if (c_dialect_cxx ())
4400 char32_type_node
= make_unsigned_type (char32_type_size
);
4402 if (cxx_dialect
>= cxx11
)
4403 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
4406 /* This is for UTF-32 string constants. */
4407 char32_array_type_node
4408 = build_array_type (char32_type_node
, array_domain_type
);
4411 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
4414 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
4416 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
4418 if (SIG_ATOMIC_TYPE
)
4419 sig_atomic_type_node
=
4420 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE
)));
4423 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE
)));
4426 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE
)));
4429 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE
)));
4432 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE
)));
4435 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE
)));
4437 c_uint16_type_node
= uint16_type_node
=
4438 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE
)));
4440 c_uint32_type_node
= uint32_type_node
=
4441 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE
)));
4443 c_uint64_type_node
= uint64_type_node
=
4444 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE
)));
4445 if (INT_LEAST8_TYPE
)
4446 int_least8_type_node
=
4447 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE
)));
4448 if (INT_LEAST16_TYPE
)
4449 int_least16_type_node
=
4450 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE
)));
4451 if (INT_LEAST32_TYPE
)
4452 int_least32_type_node
=
4453 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE
)));
4454 if (INT_LEAST64_TYPE
)
4455 int_least64_type_node
=
4456 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE
)));
4457 if (UINT_LEAST8_TYPE
)
4458 uint_least8_type_node
=
4459 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE
)));
4460 if (UINT_LEAST16_TYPE
)
4461 uint_least16_type_node
=
4462 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE
)));
4463 if (UINT_LEAST32_TYPE
)
4464 uint_least32_type_node
=
4465 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE
)));
4466 if (UINT_LEAST64_TYPE
)
4467 uint_least64_type_node
=
4468 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE
)));
4470 int_fast8_type_node
=
4471 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE
)));
4472 if (INT_FAST16_TYPE
)
4473 int_fast16_type_node
=
4474 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE
)));
4475 if (INT_FAST32_TYPE
)
4476 int_fast32_type_node
=
4477 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE
)));
4478 if (INT_FAST64_TYPE
)
4479 int_fast64_type_node
=
4480 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE
)));
4481 if (UINT_FAST8_TYPE
)
4482 uint_fast8_type_node
=
4483 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE
)));
4484 if (UINT_FAST16_TYPE
)
4485 uint_fast16_type_node
=
4486 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE
)));
4487 if (UINT_FAST32_TYPE
)
4488 uint_fast32_type_node
=
4489 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE
)));
4490 if (UINT_FAST64_TYPE
)
4491 uint_fast64_type_node
=
4492 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE
)));
4495 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE
)));
4498 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE
)));
4500 default_function_type
4501 = build_varargs_function_type_list (integer_type_node
, NULL_TREE
);
4502 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
4504 lang_hooks
.decls
.pushdecl
4505 (build_decl (UNKNOWN_LOCATION
,
4506 TYPE_DECL
, get_identifier ("__builtin_va_list"),
4507 va_list_type_node
));
4508 if (targetm
.enum_va_list_p
)
4514 for (l
= 0; targetm
.enum_va_list_p (l
, &pname
, &ptype
); ++l
)
4516 lang_hooks
.decls
.pushdecl
4517 (build_decl (UNKNOWN_LOCATION
,
4518 TYPE_DECL
, get_identifier (pname
),
4524 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4526 va_list_arg_type_node
= va_list_ref_type_node
=
4527 build_pointer_type (TREE_TYPE (va_list_type_node
));
4531 va_list_arg_type_node
= va_list_type_node
;
4532 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
4535 if (!flag_preprocess_only
)
4536 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
4538 main_identifier_node
= get_identifier ("main");
4540 /* Create the built-in __null node. It is important that this is
4542 null_node
= make_int_cst (1, 1);
4543 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
4545 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4546 memset (builtin_types
, 0, sizeof (builtin_types
));
4549 /* The number of named compound-literals generated thus far. */
4550 static GTY(()) int compound_literal_number
;
4552 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4555 set_compound_literal_name (tree decl
)
4558 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
4559 compound_literal_number
);
4560 compound_literal_number
++;
4561 DECL_NAME (decl
) = get_identifier (name
);
4564 /* build_va_arg helper function. Return a VA_ARG_EXPR with location LOC, type
4565 TYPE and operand OP. */
4568 build_va_arg_1 (location_t loc
, tree type
, tree op
)
4570 tree expr
= build1 (VA_ARG_EXPR
, type
, op
);
4571 SET_EXPR_LOCATION (expr
, loc
);
4575 /* Return a VA_ARG_EXPR corresponding to a source-level expression
4576 va_arg (EXPR, TYPE) at source location LOC. */
4579 build_va_arg (location_t loc
, tree expr
, tree type
)
4581 tree va_type
= TREE_TYPE (expr
);
4582 tree canon_va_type
= (va_type
== error_mark_node
4584 : targetm
.canonical_va_list_type (va_type
));
4586 if (va_type
== error_mark_node
4587 || canon_va_type
== NULL_TREE
)
4589 if (canon_va_type
== NULL_TREE
)
4590 error_at (loc
, "first argument to %<va_arg%> not of type %<va_list%>");
4592 /* Let's handle things neutrallly, if expr:
4593 - has undeclared type, or
4594 - is not an va_list type. */
4595 return build_va_arg_1 (loc
, type
, error_mark_node
);
4598 if (TREE_CODE (canon_va_type
) != ARRAY_TYPE
)
4600 /* Case 1: Not an array type. */
4602 /* Take the address, to get '&ap'. Note that &ap is not a va_list
4604 mark_addressable (expr
);
4605 expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (expr
)), expr
);
4607 return build_va_arg_1 (loc
, type
, expr
);
4610 /* Case 2: Array type.
4614 For contrast, let's start with the simple case (case 1). If
4615 canon_va_type is not an array type, but say a char *, then when
4616 passing-by-value a va_list, the type of the va_list param decl is
4617 the same as for another va_list decl (all ap's are char *):
4620 D.1815 = VA_ARG (&ap, 0B, 1);
4626 __builtin_va_start (&ap, 0);
4629 __builtin_va_end (&ap);
4633 However, if canon_va_type is ARRAY_TYPE, then when passing-by-value a
4634 va_list the type of the va_list param decl (case 2b, struct * ap) is not
4635 the same as for another va_list decl (case 2a, struct ap[1]).
4638 D.1844 = VA_ARG (ap, 0B, 0);
4643 __builtin_va_start (&ap, 0);
4645 __builtin_va_end (&ap);
4649 Case 2b is different because:
4650 - on the callee side, the parm decl has declared type va_list, but
4651 grokdeclarator changes the type of the parm decl to a pointer to the
4653 - on the caller side, the pass-by-value uses &ap.
4655 We unify these two cases (case 2a: va_list is array type,
4656 case 2b: va_list is pointer to array elem type), by adding '&' for the
4657 array type case, such that we have a pointer to array elem in both
4660 if (TREE_CODE (va_type
) == ARRAY_TYPE
)
4662 /* Case 2a: va_list is array type. */
4664 /* Take the address, to get '&ap'. Make sure it's a pointer to array
4666 mark_addressable (expr
);
4667 expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (canon_va_type
)),
4670 /* Verify that &ap is still recognized as having va_list type. */
4671 tree canon_expr_type
4672 = targetm
.canonical_va_list_type (TREE_TYPE (expr
));
4673 gcc_assert (canon_expr_type
!= NULL_TREE
);
4677 /* Case 2b: va_list is pointer to array elem type. */
4678 gcc_assert (POINTER_TYPE_P (va_type
));
4680 /* Comparison as in std_canonical_va_list_type. */
4681 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (va_type
))
4682 == TYPE_MAIN_VARIANT (TREE_TYPE (canon_va_type
)));
4684 /* Don't take the address. We've already got '&ap'. */
4688 return build_va_arg_1 (loc
, type
, expr
);
4692 /* Linked list of disabled built-in functions. */
4694 struct disabled_builtin
4697 struct disabled_builtin
*next
;
4699 static disabled_builtin
*disabled_builtins
= NULL
;
4701 static bool builtin_function_disabled_p (const char *);
4703 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4704 begins with "__builtin_", give an error. */
4707 disable_builtin_function (const char *name
)
4709 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
4710 error ("cannot disable built-in function %qs", name
);
4713 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
4714 new_disabled_builtin
->name
= name
;
4715 new_disabled_builtin
->next
= disabled_builtins
;
4716 disabled_builtins
= new_disabled_builtin
;
4721 /* Return true if the built-in function NAME has been disabled, false
4725 builtin_function_disabled_p (const char *name
)
4727 disabled_builtin
*p
;
4728 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
4730 if (strcmp (name
, p
->name
) == 0)
4737 /* Worker for DEF_BUILTIN.
4738 Possibly define a builtin function with one or two names.
4739 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4740 nonansi_p and flag_no_nonansi_builtin. */
4743 def_builtin_1 (enum built_in_function fncode
,
4745 enum built_in_class fnclass
,
4746 tree fntype
, tree libtype
,
4747 bool both_p
, bool fallback_p
, bool nonansi_p
,
4748 tree fnattrs
, bool implicit_p
)
4751 const char *libname
;
4753 if (fntype
== error_mark_node
)
4756 gcc_assert ((!both_p
&& !fallback_p
)
4757 || !strncmp (name
, "__builtin_",
4758 strlen ("__builtin_")));
4760 libname
= name
+ strlen ("__builtin_");
4761 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
4762 (fallback_p
? libname
: NULL
),
4765 set_builtin_decl (fncode
, decl
, implicit_p
);
4768 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
4769 && !(nonansi_p
&& flag_no_nonansi_builtin
))
4770 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
4774 /* Nonzero if the type T promotes to int. This is (nearly) the
4775 integral promotions defined in ISO C99 6.3.1.1/2. */
4778 c_promoting_integer_type_p (const_tree t
)
4780 switch (TREE_CODE (t
))
4783 return (TYPE_MAIN_VARIANT (t
) == char_type_node
4784 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
4785 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
4786 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
4787 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
4788 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
4791 /* ??? Technically all enumerations not larger than an int
4792 promote to an int. But this is used along code paths
4793 that only want to notice a size change. */
4794 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
4804 /* Return 1 if PARMS specifies a fixed number of parameters
4805 and none of their types is affected by default promotions. */
4808 self_promoting_args_p (const_tree parms
)
4811 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
4813 tree type
= TREE_VALUE (t
);
4815 if (type
== error_mark_node
)
4818 if (TREE_CHAIN (t
) == NULL_TREE
&& type
!= void_type_node
)
4821 if (type
== NULL_TREE
)
4824 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
4827 if (c_promoting_integer_type_p (type
))
4833 /* Recursively remove any '*' or '&' operator from TYPE. */
4835 strip_pointer_operator (tree t
)
4837 while (POINTER_TYPE_P (t
))
4842 /* Recursively remove pointer or array type from TYPE. */
4844 strip_pointer_or_array_types (tree t
)
4846 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
4851 /* Used to compare case labels. K1 and K2 are actually tree nodes
4852 representing case labels, or NULL_TREE for a `default' label.
4853 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4854 K2, and 0 if K1 and K2 are equal. */
4857 case_compare (splay_tree_key k1
, splay_tree_key k2
)
4859 /* Consider a NULL key (such as arises with a `default' label) to be
4860 smaller than anything else. */
4866 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4869 /* Process a case label, located at LOC, for the range LOW_VALUE
4870 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
4871 then this case label is actually a `default' label. If only
4872 HIGH_VALUE is NULL_TREE, then case label was declared using the
4873 usual C/C++ syntax, rather than the GNU case range extension.
4874 CASES is a tree containing all the case ranges processed so far;
4875 COND is the condition for the switch-statement itself.
4876 OUTSIDE_RANGE_P says whether there was a case value that doesn't
4877 fit into the range of the ORIG_TYPE. Returns the CASE_LABEL_EXPR
4878 created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
4881 c_add_case_label (location_t loc
, splay_tree cases
, tree cond
, tree orig_type
,
4882 tree low_value
, tree high_value
, bool *outside_range_p
)
4887 splay_tree_node node
;
4889 /* Create the LABEL_DECL itself. */
4890 label
= create_artificial_label (loc
);
4892 /* If there was an error processing the switch condition, bail now
4893 before we get more confused. */
4894 if (!cond
|| cond
== error_mark_node
)
4897 if ((low_value
&& TREE_TYPE (low_value
)
4898 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
4899 || (high_value
&& TREE_TYPE (high_value
)
4900 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
4902 error_at (loc
, "pointers are not permitted as case values");
4906 /* Case ranges are a GNU extension. */
4908 pedwarn (loc
, OPT_Wpedantic
,
4909 "range expressions in switch statements are non-standard");
4911 type
= TREE_TYPE (cond
);
4914 low_value
= check_case_value (loc
, low_value
);
4915 low_value
= convert_and_check (loc
, type
, low_value
);
4916 if (low_value
== error_mark_node
)
4921 high_value
= check_case_value (loc
, high_value
);
4922 high_value
= convert_and_check (loc
, type
, high_value
);
4923 if (high_value
== error_mark_node
)
4927 if (low_value
&& high_value
)
4929 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4930 really a case range, even though it was written that way.
4931 Remove the HIGH_VALUE to simplify later processing. */
4932 if (tree_int_cst_equal (low_value
, high_value
))
4933 high_value
= NULL_TREE
;
4934 else if (!tree_int_cst_lt (low_value
, high_value
))
4935 warning_at (loc
, 0, "empty range specified");
4938 /* See if the case is in range of the type of the original testing
4939 expression. If both low_value and high_value are out of range,
4940 don't insert the case label and return NULL_TREE. */
4942 && !check_case_bounds (loc
, type
, orig_type
,
4943 &low_value
, high_value
? &high_value
: NULL
,
4947 /* Look up the LOW_VALUE in the table of case labels we already
4949 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
4950 /* If there was not an exact match, check for overlapping ranges.
4951 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4952 that's a `default' label and the only overlap is an exact match. */
4953 if (!node
&& (low_value
|| high_value
))
4955 splay_tree_node low_bound
;
4956 splay_tree_node high_bound
;
4958 /* Even though there wasn't an exact match, there might be an
4959 overlap between this case range and another case range.
4960 Since we've (inductively) not allowed any overlapping case
4961 ranges, we simply need to find the greatest low case label
4962 that is smaller that LOW_VALUE, and the smallest low case
4963 label that is greater than LOW_VALUE. If there is an overlap
4964 it will occur in one of these two ranges. */
4965 low_bound
= splay_tree_predecessor (cases
,
4966 (splay_tree_key
) low_value
);
4967 high_bound
= splay_tree_successor (cases
,
4968 (splay_tree_key
) low_value
);
4970 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4971 the LOW_VALUE, so there is no need to check unless the
4972 LOW_BOUND is in fact itself a case range. */
4974 && CASE_HIGH ((tree
) low_bound
->value
)
4975 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
4978 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4979 range is bigger than the low end of the current range, so we
4980 are only interested if the current range is a real range, and
4981 not an ordinary case label. */
4984 && (tree_int_cst_compare ((tree
) high_bound
->key
,
4989 /* If there was an overlap, issue an error. */
4992 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
4996 error_at (loc
, "duplicate (or overlapping) case value");
4997 inform (DECL_SOURCE_LOCATION (duplicate
),
4998 "this is the first entry overlapping that value");
5002 error_at (loc
, "duplicate case value") ;
5003 inform (DECL_SOURCE_LOCATION (duplicate
), "previously used here");
5007 error_at (loc
, "multiple default labels in one switch");
5008 inform (DECL_SOURCE_LOCATION (duplicate
),
5009 "this is the first default label");
5014 /* Add a CASE_LABEL to the statement-tree. */
5015 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
5016 /* Register this case label in the splay tree. */
5017 splay_tree_insert (cases
,
5018 (splay_tree_key
) low_value
,
5019 (splay_tree_value
) case_label
);
5024 /* Add a label so that the back-end doesn't think that the beginning of
5025 the switch is unreachable. Note that we do not add a case label, as
5026 that just leads to duplicates and thence to failure later on. */
5029 tree t
= create_artificial_label (loc
);
5030 add_stmt (build_stmt (loc
, LABEL_EXPR
, t
));
5032 return error_mark_node
;
5035 /* Subroutine of c_switch_covers_all_cases_p, called via
5036 splay_tree_foreach. Return 1 if it doesn't cover all the cases.
5037 ARGS[0] is initially NULL and after the first iteration is the
5038 so far highest case label. ARGS[1] is the minimum of SWITCH_COND's
5042 c_switch_covers_all_cases_p_1 (splay_tree_node node
, void *data
)
5044 tree label
= (tree
) node
->value
;
5045 tree
*args
= (tree
*) data
;
5047 /* If there is a default case, we shouldn't have called this. */
5048 gcc_assert (CASE_LOW (label
));
5050 if (args
[0] == NULL_TREE
)
5052 if (wi::to_widest (args
[1]) < wi::to_widest (CASE_LOW (label
)))
5055 else if (wi::add (wi::to_widest (args
[0]), 1)
5056 != wi::to_widest (CASE_LOW (label
)))
5058 if (CASE_HIGH (label
))
5059 args
[0] = CASE_HIGH (label
);
5061 args
[0] = CASE_LOW (label
);
5065 /* Return true if switch with CASES and switch condition with type
5066 covers all possible values in the case labels. */
5069 c_switch_covers_all_cases_p (splay_tree cases
, tree type
)
5071 /* If there is default:, this is always the case. */
5072 splay_tree_node default_node
5073 = splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
5077 if (!INTEGRAL_TYPE_P (type
))
5080 tree args
[2] = { NULL_TREE
, TYPE_MIN_VALUE (type
) };
5081 if (splay_tree_foreach (cases
, c_switch_covers_all_cases_p_1
, args
))
5084 /* If there are no cases at all, or if the highest case label
5085 is smaller than TYPE_MAX_VALUE, return false. */
5086 if (args
[0] == NULL_TREE
5087 || wi::to_widest (args
[0]) < wi::to_widest (TYPE_MAX_VALUE (type
)))
5093 /* Finish an expression taking the address of LABEL (an
5094 IDENTIFIER_NODE). Returns an expression for the address.
5096 LOC is the location for the expression returned. */
5099 finish_label_address_expr (tree label
, location_t loc
)
5103 pedwarn (input_location
, OPT_Wpedantic
, "taking the address of a label is non-standard");
5105 if (label
== error_mark_node
)
5106 return error_mark_node
;
5108 label
= lookup_label (label
);
5109 if (label
== NULL_TREE
)
5110 result
= null_pointer_node
;
5113 TREE_USED (label
) = 1;
5114 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
5115 /* The current function is not necessarily uninlinable.
5116 Computed gotos are incompatible with inlining, but the value
5117 here could be used only in a diagnostic, for example. */
5118 protected_set_expr_location (result
, loc
);
5125 /* Given a boolean expression ARG, return a tree representing an increment
5126 or decrement (as indicated by CODE) of ARG. The front end must check for
5127 invalid cases (e.g., decrement in C++). */
5129 boolean_increment (enum tree_code code
, tree arg
)
5132 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
5134 arg
= stabilize_reference (arg
);
5137 case PREINCREMENT_EXPR
:
5138 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5140 case POSTINCREMENT_EXPR
:
5141 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5142 arg
= save_expr (arg
);
5143 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5144 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5146 case PREDECREMENT_EXPR
:
5147 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5148 invert_truthvalue_loc (input_location
, arg
));
5150 case POSTDECREMENT_EXPR
:
5151 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5152 invert_truthvalue_loc (input_location
, arg
));
5153 arg
= save_expr (arg
);
5154 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5155 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5160 TREE_SIDE_EFFECTS (val
) = 1;
5164 /* Built-in macros for stddef.h and stdint.h, that require macros
5165 defined in this file. */
5167 c_stddef_cpp_builtins(void)
5169 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
5170 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
5171 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
5172 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
5173 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
5174 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
5176 builtin_define_with_value ("__CHAR8_TYPE__", CHAR8_TYPE
, 0);
5177 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
5178 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
5179 if (SIG_ATOMIC_TYPE
)
5180 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE
, 0);
5182 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE
, 0);
5184 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE
, 0);
5186 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE
, 0);
5188 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE
, 0);
5190 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE
, 0);
5192 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE
, 0);
5194 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE
, 0);
5196 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE
, 0);
5197 if (INT_LEAST8_TYPE
)
5198 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE
, 0);
5199 if (INT_LEAST16_TYPE
)
5200 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE
, 0);
5201 if (INT_LEAST32_TYPE
)
5202 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE
, 0);
5203 if (INT_LEAST64_TYPE
)
5204 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE
, 0);
5205 if (UINT_LEAST8_TYPE
)
5206 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE
, 0);
5207 if (UINT_LEAST16_TYPE
)
5208 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE
, 0);
5209 if (UINT_LEAST32_TYPE
)
5210 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE
, 0);
5211 if (UINT_LEAST64_TYPE
)
5212 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE
, 0);
5214 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE
, 0);
5215 if (INT_FAST16_TYPE
)
5216 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE
, 0);
5217 if (INT_FAST32_TYPE
)
5218 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE
, 0);
5219 if (INT_FAST64_TYPE
)
5220 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE
, 0);
5221 if (UINT_FAST8_TYPE
)
5222 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE
, 0);
5223 if (UINT_FAST16_TYPE
)
5224 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE
, 0);
5225 if (UINT_FAST32_TYPE
)
5226 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE
, 0);
5227 if (UINT_FAST64_TYPE
)
5228 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE
, 0);
5230 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE
, 0);
5232 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE
, 0);
5236 c_init_attributes (void)
5238 /* Fill in the built_in_attributes array. */
5239 #define DEF_ATTR_NULL_TREE(ENUM) \
5240 built_in_attributes[(int) ENUM] = NULL_TREE;
5241 #define DEF_ATTR_INT(ENUM, VALUE) \
5242 built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE);
5243 #define DEF_ATTR_STRING(ENUM, VALUE) \
5244 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
5245 #define DEF_ATTR_IDENT(ENUM, STRING) \
5246 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5247 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5248 built_in_attributes[(int) ENUM] \
5249 = tree_cons (built_in_attributes[(int) PURPOSE], \
5250 built_in_attributes[(int) VALUE], \
5251 built_in_attributes[(int) CHAIN]);
5252 #include "builtin-attrs.def"
5253 #undef DEF_ATTR_NULL_TREE
5255 #undef DEF_ATTR_IDENT
5256 #undef DEF_ATTR_TREE_LIST
5259 /* Check whether the byte alignment ALIGN is a valid user-specified
5260 alignment less than the supported maximum. If so, return ALIGN's
5261 base-2 log; if not, output an error and return -1. If OBJFILE
5262 then reject alignments greater than MAX_OFILE_ALIGNMENT when
5263 converted to bits. Otherwise, consider valid only alignments
5264 that are less than HOST_BITS_PER_INT - LOG2_BITS_PER_UNIT.
5265 Zero is not considered a valid argument (and results in -1 on
5266 return) but it only triggers a warning when WARN_ZERO is set. */
5269 check_user_alignment (const_tree align
, bool objfile
, bool warn_zero
)
5271 if (error_operand_p (align
))
5274 if (TREE_CODE (align
) != INTEGER_CST
5275 || !INTEGRAL_TYPE_P (TREE_TYPE (align
)))
5277 error ("requested alignment is not an integer constant");
5281 if (integer_zerop (align
))
5284 warning (OPT_Wattributes
,
5285 "requested alignment %qE is not a positive power of 2",
5291 if (tree_int_cst_sgn (align
) == -1
5292 || (log2bitalign
= tree_log2 (align
)) == -1)
5294 error ("requested alignment %qE is not a positive power of 2",
5301 unsigned maxalign
= MAX_OFILE_ALIGNMENT
/ BITS_PER_UNIT
;
5302 if (tree_to_shwi (align
) > maxalign
)
5304 error ("requested alignment %qE exceeds object file maximum %u",
5310 if (log2bitalign
>= HOST_BITS_PER_INT
- LOG2_BITS_PER_UNIT
)
5312 error ("requested alignment %qE exceeds maximum %u",
5313 align
, 1U << (HOST_BITS_PER_INT
- 1));
5317 return log2bitalign
;
5320 /* Determine the ELF symbol visibility for DECL, which is either a
5321 variable or a function. It is an error to use this function if a
5322 definition of DECL is not available in this translation unit.
5323 Returns true if the final visibility has been determined by this
5324 function; false if the caller is free to make additional
5328 c_determine_visibility (tree decl
)
5330 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
5332 /* If the user explicitly specified the visibility with an
5333 attribute, honor that. DECL_VISIBILITY will have been set during
5334 the processing of the attribute. We check for an explicit
5335 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5336 to distinguish the use of an attribute from the use of a "#pragma
5337 GCC visibility push(...)"; in the latter case we still want other
5338 considerations to be able to overrule the #pragma. */
5339 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
5340 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5341 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
5342 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
5345 /* Set default visibility to whatever the user supplied with
5346 visibility_specified depending on #pragma GCC visibility. */
5347 if (!DECL_VISIBILITY_SPECIFIED (decl
))
5349 if (visibility_options
.inpragma
5350 || DECL_VISIBILITY (decl
) != default_visibility
)
5352 DECL_VISIBILITY (decl
) = default_visibility
;
5353 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
5354 /* If visibility changed and DECL already has DECL_RTL, ensure
5355 symbol flags are updated. */
5356 if (((VAR_P (decl
) && TREE_STATIC (decl
))
5357 || TREE_CODE (decl
) == FUNCTION_DECL
)
5358 && DECL_RTL_SET_P (decl
))
5359 make_decl_rtl (decl
);
5365 /* Data to communicate through check_function_arguments_recurse between
5366 check_function_nonnull and check_nonnull_arg. */
5368 struct nonnull_arg_ctx
5374 /* Check the argument list of a function call for null in argument slots
5375 that are marked as requiring a non-null pointer argument. The NARGS
5376 arguments are passed in the array ARGARRAY. Return true if we have
5380 check_function_nonnull (location_t loc
, tree attrs
, int nargs
, tree
*argarray
)
5385 attrs
= lookup_attribute ("nonnull", attrs
);
5386 if (attrs
== NULL_TREE
)
5390 /* See if any of the nonnull attributes has no arguments. If so,
5391 then every pointer argument is checked (in which case the check
5392 for pointer type is done in check_nonnull_arg). */
5393 if (TREE_VALUE (a
) != NULL_TREE
)
5395 a
= lookup_attribute ("nonnull", TREE_CHAIN (a
));
5396 while (a
!= NULL_TREE
&& TREE_VALUE (a
) != NULL_TREE
);
5398 struct nonnull_arg_ctx ctx
= { loc
, false };
5400 for (i
= 0; i
< nargs
; i
++)
5401 check_function_arguments_recurse (check_nonnull_arg
, &ctx
, argarray
[i
],
5405 /* Walk the argument list. If we encounter an argument number we
5406 should check for non-null, do it. */
5407 for (i
= 0; i
< nargs
; i
++)
5409 for (a
= attrs
; ; a
= TREE_CHAIN (a
))
5411 a
= lookup_attribute ("nonnull", a
);
5412 if (a
== NULL_TREE
|| nonnull_check_p (TREE_VALUE (a
), i
+ 1))
5417 check_function_arguments_recurse (check_nonnull_arg
, &ctx
,
5418 argarray
[i
], i
+ 1);
5421 return ctx
.warned_p
;
5424 /* Check that the Nth argument of a function call (counting backwards
5425 from the end) is a (pointer)0. The NARGS arguments are passed in the
5429 check_function_sentinel (const_tree fntype
, int nargs
, tree
*argarray
)
5431 tree attr
= lookup_attribute ("sentinel", TYPE_ATTRIBUTES (fntype
));
5438 function_args_iterator iter
;
5441 /* Skip over the named arguments. */
5442 FOREACH_FUNCTION_ARGS (fntype
, t
, iter
)
5449 if (TREE_VALUE (attr
))
5451 tree p
= TREE_VALUE (TREE_VALUE (attr
));
5452 pos
= TREE_INT_CST_LOW (p
);
5455 /* The sentinel must be one of the varargs, i.e.
5456 in position >= the number of fixed arguments. */
5457 if ((nargs
- 1 - pos
) < len
)
5459 warning (OPT_Wformat_
,
5460 "not enough variable arguments to fit a sentinel");
5464 /* Validate the sentinel. */
5465 sentinel
= fold_for_warn (argarray
[nargs
- 1 - pos
]);
5466 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
5467 || !integer_zerop (sentinel
))
5468 /* Although __null (in C++) is only an integer we allow it
5469 nevertheless, as we are guaranteed that it's exactly
5470 as wide as a pointer, and we don't want to force
5471 users to cast the NULL they have written there.
5472 We warn with -Wstrict-null-sentinel, though. */
5473 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
5474 warning (OPT_Wformat_
, "missing sentinel in function call");
5478 /* Check that the same argument isn't passed to two or more
5479 restrict-qualified formal and issue a -Wrestrict warning
5480 if it is. Return true if a warning has been issued. */
5483 check_function_restrict (const_tree fndecl
, const_tree fntype
,
5484 int nargs
, tree
*unfolded_argarray
)
5487 tree parms
= TYPE_ARG_TYPES (fntype
);
5489 /* Call fold_for_warn on all of the arguments. */
5490 auto_vec
<tree
> argarray (nargs
);
5491 for (i
= 0; i
< nargs
; i
++)
5492 argarray
.quick_push (fold_for_warn (unfolded_argarray
[i
]));
5495 && TREE_CODE (fndecl
) == FUNCTION_DECL
)
5497 /* Avoid diagnosing calls built-ins with a zero size/bound
5498 here. They are checked in more detail elsewhere. */
5499 if (fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
5501 && TREE_CODE (argarray
[2]) == INTEGER_CST
5502 && integer_zerop (argarray
[2]))
5505 if (DECL_ARGUMENTS (fndecl
))
5506 parms
= DECL_ARGUMENTS (fndecl
);
5509 for (i
= 0; i
< nargs
; i
++)
5510 TREE_VISITED (argarray
[i
]) = 0;
5512 bool warned
= false;
5514 for (i
= 0; i
< nargs
&& parms
&& parms
!= void_list_node
; i
++)
5517 if (TREE_CODE (parms
) == PARM_DECL
)
5519 type
= TREE_TYPE (parms
);
5520 parms
= DECL_CHAIN (parms
);
5524 type
= TREE_VALUE (parms
);
5525 parms
= TREE_CHAIN (parms
);
5527 if (POINTER_TYPE_P (type
)
5528 && TYPE_RESTRICT (type
)
5529 && !TYPE_READONLY (TREE_TYPE (type
)))
5530 warned
|= warn_for_restrict (i
, argarray
.address (), nargs
);
5533 for (i
= 0; i
< nargs
; i
++)
5534 TREE_VISITED (argarray
[i
]) = 0;
5539 /* Helper for check_function_nonnull; given a list of operands which
5540 must be non-null in ARGS, determine if operand PARAM_NUM should be
5544 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
5546 unsigned HOST_WIDE_INT arg_num
= 0;
5548 for (; args
; args
= TREE_CHAIN (args
))
5550 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
5554 if (arg_num
== param_num
)
5560 /* Check that the function argument PARAM (which is operand number
5561 PARAM_NUM) is non-null. This is called by check_function_nonnull
5562 via check_function_arguments_recurse. */
5565 check_nonnull_arg (void *ctx
, tree param
, unsigned HOST_WIDE_INT param_num
)
5567 struct nonnull_arg_ctx
*pctx
= (struct nonnull_arg_ctx
*) ctx
;
5569 /* Just skip checking the argument if it's not a pointer. This can
5570 happen if the "nonnull" attribute was given without an operand
5571 list (which means to check every pointer argument). */
5573 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
5576 /* Diagnose the simple cases of null arguments. */
5577 if (integer_zerop (fold_for_warn (param
)))
5579 warning_at (pctx
->loc
, OPT_Wnonnull
, "null argument where non-null "
5580 "required (argument %lu)", (unsigned long) param_num
);
5581 pctx
->warned_p
= true;
5585 /* Helper for nonnull attribute handling; fetch the operand number
5586 from the attribute argument list. */
5589 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
5591 /* Verify the arg number is a small constant. */
5592 if (tree_fits_uhwi_p (arg_num_expr
))
5594 *valp
= tree_to_uhwi (arg_num_expr
);
5601 /* Arguments being collected for optimization. */
5602 typedef const char *const_char_p
; /* For DEF_VEC_P. */
5603 static GTY(()) vec
<const_char_p
, va_gc
> *optimize_args
;
5606 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
5607 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
5608 false for #pragma GCC optimize. */
5611 parse_optimize_options (tree args
, bool attr_p
)
5616 const char **opt_argv
;
5617 struct cl_decoded_option
*decoded_options
;
5618 unsigned int decoded_options_count
;
5621 /* Build up argv vector. Just in case the string is stored away, use garbage
5622 collected strings. */
5623 vec_safe_truncate (optimize_args
, 0);
5624 vec_safe_push (optimize_args
, (const char *) NULL
);
5626 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
5628 tree value
= TREE_VALUE (ap
);
5630 if (TREE_CODE (value
) == INTEGER_CST
)
5633 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
5634 vec_safe_push (optimize_args
, ggc_strdup (buffer
));
5637 else if (TREE_CODE (value
) == STRING_CST
)
5639 /* Split string into multiple substrings. */
5640 size_t len
= TREE_STRING_LENGTH (value
);
5641 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
5642 char *end
= p
+ len
;
5646 while (next_p
!= NULL
)
5652 comma
= strchr (p
, ',');
5665 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
5667 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
5671 warning (OPT_Wattributes
,
5672 "bad option %qs to attribute %<optimize%>", p
);
5674 warning (OPT_Wpragmas
,
5675 "bad option %qs to pragma %<optimize%>", p
);
5679 /* Can't use GC memory here, see PR88007. */
5680 r
= q
= XOBNEWVEC (&opts_obstack
, char, len2
+ 3);
5686 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
5687 itself is -Os, and any other switch begins with a -f. */
5688 if ((*p
>= '0' && *p
<= '9')
5689 || (p
[0] == 's' && p
[1] == '\0'))
5695 memcpy (r
, p
, len2
);
5697 vec_safe_push (optimize_args
, (const char *) q
);
5703 opt_argc
= optimize_args
->length ();
5704 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
5706 for (i
= 1; i
< opt_argc
; i
++)
5707 opt_argv
[i
] = (*optimize_args
)[i
];
5709 /* Now parse the options. */
5710 decode_cmdline_options_to_array_default_mask (opt_argc
, opt_argv
,
5712 &decoded_options_count
);
5713 /* Drop non-Optimization options. */
5715 for (i
= 1; i
< decoded_options_count
; ++i
)
5717 if (! (cl_options
[decoded_options
[i
].opt_index
].flags
& CL_OPTIMIZATION
))
5721 warning (OPT_Wattributes
,
5722 "bad option %qs to attribute %<optimize%>",
5723 decoded_options
[i
].orig_option_with_args_text
);
5725 warning (OPT_Wpragmas
,
5726 "bad option %qs to pragma %<optimize%>",
5727 decoded_options
[i
].orig_option_with_args_text
);
5731 decoded_options
[j
] = decoded_options
[i
];
5734 decoded_options_count
= j
;
5735 /* And apply them. */
5736 decode_options (&global_options
, &global_options_set
,
5737 decoded_options
, decoded_options_count
,
5738 input_location
, global_dc
, NULL
);
5740 targetm
.override_options_after_change();
5742 optimize_args
->truncate (0);
5746 /* Check whether ATTR is a valid attribute fallthrough. */
5749 attribute_fallthrough_p (tree attr
)
5751 if (attr
== error_mark_node
)
5753 tree t
= lookup_attribute ("fallthrough", attr
);
5756 /* This attribute shall appear at most once in each attribute-list. */
5757 if (lookup_attribute ("fallthrough", TREE_CHAIN (t
)))
5758 warning (OPT_Wattributes
, "%<fallthrough%> attribute specified multiple "
5760 /* No attribute-argument-clause shall be present. */
5761 else if (TREE_VALUE (t
) != NULL_TREE
)
5762 warning (OPT_Wattributes
, "%<fallthrough%> attribute specified with "
5764 /* Warn if other attributes are found. */
5765 for (t
= attr
; t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
5767 tree name
= get_attribute_name (t
);
5768 if (!is_attribute_p ("fallthrough", name
))
5769 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5775 /* Check for valid arguments being passed to a function with FNTYPE.
5776 There are NARGS arguments in the array ARGARRAY. LOC should be used
5777 for diagnostics. Return true if either -Wnonnull or -Wrestrict has
5780 The arguments in ARGARRAY may not have been folded yet (e.g. for C++,
5781 to preserve location wrappers); checks that require folded arguments
5782 should call fold_for_warn on them. */
5785 check_function_arguments (location_t loc
, const_tree fndecl
, const_tree fntype
,
5786 int nargs
, tree
*argarray
, vec
<location_t
> *arglocs
)
5788 bool warned_p
= false;
5790 /* Check for null being passed in a pointer argument that must be
5791 non-null. We also need to do this if format checking is enabled. */
5794 warned_p
= check_function_nonnull (loc
, TYPE_ATTRIBUTES (fntype
),
5797 /* Check for errors in format strings. */
5799 if (warn_format
|| warn_suggest_attribute_format
)
5800 check_function_format (fntype
, TYPE_ATTRIBUTES (fntype
), nargs
, argarray
,
5804 check_function_sentinel (fntype
, nargs
, argarray
);
5807 warned_p
|= check_function_restrict (fndecl
, fntype
, nargs
, argarray
);
5811 /* Generic argument checking recursion routine. PARAM is the argument to
5812 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5813 once the argument is resolved. CTX is context for the callback. */
5815 check_function_arguments_recurse (void (*callback
)
5816 (void *, tree
, unsigned HOST_WIDE_INT
),
5817 void *ctx
, tree param
,
5818 unsigned HOST_WIDE_INT param_num
)
5820 if (CONVERT_EXPR_P (param
)
5821 && (TYPE_PRECISION (TREE_TYPE (param
))
5822 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
5824 /* Strip coercion. */
5825 check_function_arguments_recurse (callback
, ctx
,
5826 TREE_OPERAND (param
, 0), param_num
);
5830 if (TREE_CODE (param
) == CALL_EXPR
)
5832 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
5834 bool found_format_arg
= false;
5836 /* See if this is a call to a known internationalization function
5837 that modifies a format arg. Such a function may have multiple
5838 format_arg attributes (for example, ngettext). */
5840 for (attrs
= TYPE_ATTRIBUTES (type
);
5842 attrs
= TREE_CHAIN (attrs
))
5843 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
5846 tree format_num_expr
;
5849 call_expr_arg_iterator iter
;
5851 /* Extract the argument number, which was previously checked
5853 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
5855 format_num
= tree_to_uhwi (format_num_expr
);
5857 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
5858 inner_arg
!= NULL_TREE
;
5859 inner_arg
= next_call_expr_arg (&iter
), i
++)
5860 if (i
== format_num
)
5862 check_function_arguments_recurse (callback
, ctx
,
5863 inner_arg
, param_num
);
5864 found_format_arg
= true;
5869 /* If we found a format_arg attribute and did a recursive check,
5870 we are done with checking this argument. Otherwise, we continue
5871 and this will be considered a non-literal. */
5872 if (found_format_arg
)
5876 if (TREE_CODE (param
) == COND_EXPR
)
5878 /* Simplify to avoid warning for an impossible case. */
5879 param
= fold_for_warn (param
);
5880 if (TREE_CODE (param
) == COND_EXPR
)
5882 /* Check both halves of the conditional expression. */
5883 check_function_arguments_recurse (callback
, ctx
,
5884 TREE_OPERAND (param
, 1),
5886 check_function_arguments_recurse (callback
, ctx
,
5887 TREE_OPERAND (param
, 2),
5893 (*callback
) (ctx
, param
, param_num
);
5896 /* Checks for a builtin function FNDECL that the number of arguments
5897 NARGS against the required number REQUIRED and issues an error if
5898 there is a mismatch. Returns true if the number of arguments is
5899 correct, otherwise false. LOC is the location of FNDECL. */
5902 builtin_function_validate_nargs (location_t loc
, tree fndecl
, int nargs
,
5905 if (nargs
< required
)
5907 error_at (loc
, "too few arguments to function %qE", fndecl
);
5910 else if (nargs
> required
)
5912 error_at (loc
, "too many arguments to function %qE", fndecl
);
5918 /* Helper macro for check_builtin_function_arguments. */
5919 #define ARG_LOCATION(N) \
5920 (arg_loc.is_empty () \
5921 ? EXPR_LOC_OR_LOC (args[(N)], input_location) \
5922 : expansion_point_location (arg_loc[(N)]))
5924 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
5925 Returns false if there was an error, otherwise true. LOC is the
5926 location of the function; ARG_LOC is a vector of locations of the
5930 check_builtin_function_arguments (location_t loc
, vec
<location_t
> arg_loc
,
5931 tree fndecl
, int nargs
, tree
*args
)
5933 if (!fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
5936 switch (DECL_FUNCTION_CODE (fndecl
))
5938 case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
:
5939 if (!tree_fits_uhwi_p (args
[2]))
5941 error_at (ARG_LOCATION (2),
5942 "third argument to function %qE must be a constant integer",
5948 case BUILT_IN_ALLOCA_WITH_ALIGN
:
5950 /* Get the requested alignment (in bits) if it's a constant
5951 integer expression. */
5952 unsigned HOST_WIDE_INT align
5953 = tree_fits_uhwi_p (args
[1]) ? tree_to_uhwi (args
[1]) : 0;
5955 /* Determine if the requested alignment is a power of 2. */
5956 if ((align
& (align
- 1)))
5959 /* The maximum alignment in bits corresponding to the same
5960 maximum in bytes enforced in check_user_alignment(). */
5961 unsigned maxalign
= (UINT_MAX
>> 1) + 1;
5963 /* Reject invalid alignments. */
5964 if (align
< BITS_PER_UNIT
|| maxalign
< align
)
5966 error_at (ARG_LOCATION (1),
5967 "second argument to function %qE must be a constant "
5968 "integer power of 2 between %qi and %qu bits",
5969 fndecl
, BITS_PER_UNIT
, maxalign
);
5975 case BUILT_IN_CONSTANT_P
:
5976 return builtin_function_validate_nargs (loc
, fndecl
, nargs
, 1);
5978 case BUILT_IN_ISFINITE
:
5979 case BUILT_IN_ISINF
:
5980 case BUILT_IN_ISINF_SIGN
:
5981 case BUILT_IN_ISNAN
:
5982 case BUILT_IN_ISNORMAL
:
5983 case BUILT_IN_SIGNBIT
:
5984 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 1))
5986 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
5988 error_at (ARG_LOCATION (0), "non-floating-point argument in "
5989 "call to function %qE", fndecl
);
5996 case BUILT_IN_ISGREATER
:
5997 case BUILT_IN_ISGREATEREQUAL
:
5998 case BUILT_IN_ISLESS
:
5999 case BUILT_IN_ISLESSEQUAL
:
6000 case BUILT_IN_ISLESSGREATER
:
6001 case BUILT_IN_ISUNORDERED
:
6002 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 2))
6004 enum tree_code code0
, code1
;
6005 code0
= TREE_CODE (TREE_TYPE (args
[0]));
6006 code1
= TREE_CODE (TREE_TYPE (args
[1]));
6007 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
6008 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
6009 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
6011 error_at (loc
, "non-floating-point arguments in call to "
6012 "function %qE", fndecl
);
6019 case BUILT_IN_FPCLASSIFY
:
6020 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 6))
6022 for (unsigned int i
= 0; i
< 5; i
++)
6023 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
6025 error_at (ARG_LOCATION (i
), "non-const integer argument %u in "
6026 "call to function %qE", i
+ 1, fndecl
);
6030 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
6032 error_at (ARG_LOCATION (5), "non-floating-point argument in "
6033 "call to function %qE", fndecl
);
6040 case BUILT_IN_ASSUME_ALIGNED
:
6041 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 2 + (nargs
> 2)))
6043 if (nargs
>= 3 && TREE_CODE (TREE_TYPE (args
[2])) != INTEGER_TYPE
)
6045 error_at (ARG_LOCATION (2), "non-integer argument 3 in call to "
6046 "function %qE", fndecl
);
6053 case BUILT_IN_ADD_OVERFLOW
:
6054 case BUILT_IN_SUB_OVERFLOW
:
6055 case BUILT_IN_MUL_OVERFLOW
:
6056 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 3))
6059 for (i
= 0; i
< 2; i
++)
6060 if (!INTEGRAL_TYPE_P (TREE_TYPE (args
[i
])))
6062 error_at (ARG_LOCATION (i
), "argument %u in call to function "
6063 "%qE does not have integral type", i
+ 1, fndecl
);
6066 if (TREE_CODE (TREE_TYPE (args
[2])) != POINTER_TYPE
6067 || !INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (args
[2]))))
6069 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
6070 "does not have pointer to integral type", fndecl
);
6073 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args
[2]))) == ENUMERAL_TYPE
)
6075 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
6076 "has pointer to enumerated type", fndecl
);
6079 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args
[2]))) == BOOLEAN_TYPE
)
6081 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
6082 "has pointer to boolean type", fndecl
);
6089 case BUILT_IN_ADD_OVERFLOW_P
:
6090 case BUILT_IN_SUB_OVERFLOW_P
:
6091 case BUILT_IN_MUL_OVERFLOW_P
:
6092 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 3))
6095 for (i
= 0; i
< 3; i
++)
6096 if (!INTEGRAL_TYPE_P (TREE_TYPE (args
[i
])))
6098 error_at (ARG_LOCATION (i
), "argument %u in call to function "
6099 "%qE does not have integral type", i
+ 1, fndecl
);
6102 if (TREE_CODE (TREE_TYPE (args
[2])) == ENUMERAL_TYPE
)
6104 error_at (ARG_LOCATION (2), "argument 3 in call to function "
6105 "%qE has enumerated type", fndecl
);
6108 else if (TREE_CODE (TREE_TYPE (args
[2])) == BOOLEAN_TYPE
)
6110 error_at (ARG_LOCATION (2), "argument 3 in call to function "
6111 "%qE has boolean type", fndecl
);
6123 /* Subroutine of c_parse_error.
6124 Return the result of concatenating LHS and RHS. RHS is really
6125 a string literal, its first character is indicated by RHS_START and
6126 RHS_SIZE is its length (including the terminating NUL character).
6128 The caller is responsible for deleting the returned pointer. */
6131 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
6133 const size_t lhs_size
= strlen (lhs
);
6134 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
6135 memcpy (result
, lhs
, lhs_size
);
6136 memcpy (result
+ lhs_size
, rhs_start
, rhs_size
);
6140 /* Issue the error given by GMSGID at RICHLOC, indicating that it occurred
6141 before TOKEN, which had the associated VALUE. */
6144 c_parse_error (const char *gmsgid
, enum cpp_ttype token_type
,
6145 tree value
, unsigned char token_flags
,
6146 rich_location
*richloc
)
6148 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6150 char *message
= NULL
;
6152 if (token_type
== CPP_EOF
)
6153 message
= catenate_messages (gmsgid
, " at end of input");
6154 else if (token_type
== CPP_CHAR
6155 || token_type
== CPP_WCHAR
6156 || token_type
== CPP_CHAR16
6157 || token_type
== CPP_CHAR32
6158 || token_type
== CPP_UTF8CHAR
)
6160 unsigned int val
= TREE_INT_CST_LOW (value
);
6182 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
6183 message
= catenate_messages (gmsgid
, " before %s'%c'");
6185 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
6187 error_at (richloc
, message
, prefix
, val
);
6191 else if (token_type
== CPP_CHAR_USERDEF
6192 || token_type
== CPP_WCHAR_USERDEF
6193 || token_type
== CPP_CHAR16_USERDEF
6194 || token_type
== CPP_CHAR32_USERDEF
6195 || token_type
== CPP_UTF8CHAR_USERDEF
)
6196 message
= catenate_messages (gmsgid
,
6197 " before user-defined character literal");
6198 else if (token_type
== CPP_STRING_USERDEF
6199 || token_type
== CPP_WSTRING_USERDEF
6200 || token_type
== CPP_STRING16_USERDEF
6201 || token_type
== CPP_STRING32_USERDEF
6202 || token_type
== CPP_UTF8STRING_USERDEF
)
6203 message
= catenate_messages (gmsgid
, " before user-defined string literal");
6204 else if (token_type
== CPP_STRING
6205 || token_type
== CPP_WSTRING
6206 || token_type
== CPP_STRING16
6207 || token_type
== CPP_STRING32
6208 || token_type
== CPP_UTF8STRING
)
6209 message
= catenate_messages (gmsgid
, " before string constant");
6210 else if (token_type
== CPP_NUMBER
)
6211 message
= catenate_messages (gmsgid
, " before numeric constant");
6212 else if (token_type
== CPP_NAME
)
6214 message
= catenate_messages (gmsgid
, " before %qE");
6215 error_at (richloc
, message
, value
);
6219 else if (token_type
== CPP_PRAGMA
)
6220 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
6221 else if (token_type
== CPP_PRAGMA_EOL
)
6222 message
= catenate_messages (gmsgid
, " before end of line");
6223 else if (token_type
== CPP_DECLTYPE
)
6224 message
= catenate_messages (gmsgid
, " before %<decltype%>");
6225 else if (token_type
< N_TTYPES
)
6227 message
= catenate_messages (gmsgid
, " before %qs token");
6228 error_at (richloc
, message
, cpp_type2name (token_type
, token_flags
));
6233 error_at (richloc
, gmsgid
);
6237 error_at (richloc
, message
);
6240 #undef catenate_messages
6243 /* Return the gcc option code associated with the reason for a cpp
6244 message, or 0 if none. */
6247 c_option_controlling_cpp_diagnostic (enum cpp_warning_reason reason
)
6249 const struct cpp_reason_option_codes_t
*entry
;
6251 for (entry
= cpp_reason_option_codes
; entry
->reason
!= CPP_W_NONE
; entry
++)
6253 if (entry
->reason
== reason
)
6254 return entry
->option_code
;
6259 /* Callback from cpp_diagnostic for PFILE to print diagnostics from the
6260 preprocessor. The diagnostic is of type LEVEL, with REASON set
6261 to the reason code if LEVEL is represents a warning, at location
6262 RICHLOC unless this is after lexing and the compiler's location
6263 should be used instead; MSG is the translated message and AP
6264 the arguments. Returns true if a diagnostic was emitted, false
6268 c_cpp_diagnostic (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
6269 enum cpp_diagnostic_level level
,
6270 enum cpp_warning_reason reason
,
6271 rich_location
*richloc
,
6272 const char *msg
, va_list *ap
)
6274 diagnostic_info diagnostic
;
6275 diagnostic_t dlevel
;
6276 bool save_warn_system_headers
= global_dc
->dc_warn_system_headers
;
6281 case CPP_DL_WARNING_SYSHDR
:
6284 global_dc
->dc_warn_system_headers
= 1;
6286 case CPP_DL_WARNING
:
6289 dlevel
= DK_WARNING
;
6291 case CPP_DL_PEDWARN
:
6292 if (flag_no_output
&& !flag_pedantic_errors
)
6294 dlevel
= DK_PEDWARN
;
6312 richloc
->set_range (0, input_location
, SHOW_RANGE_WITH_CARET
);
6313 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
6315 diagnostic_override_option_index
6317 c_option_controlling_cpp_diagnostic (reason
));
6318 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
6319 if (level
== CPP_DL_WARNING_SYSHDR
)
6320 global_dc
->dc_warn_system_headers
= save_warn_system_headers
;
6324 /* Convert a character from the host to the target execution character
6325 set. cpplib handles this, mostly. */
6328 c_common_to_target_charset (HOST_WIDE_INT c
)
6330 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6331 zero-extended under -fno-signed-char. cpplib insists that characters
6332 and character constants are always unsigned. Hence we must convert
6334 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
6336 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
6338 if (flag_signed_char
)
6339 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
6340 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
6345 /* Fold an offsetof-like expression. EXPR is a nested sequence of component
6346 references with an INDIRECT_REF of a constant at the bottom; much like the
6347 traditional rendering of offsetof as a macro. TYPE is the desired type of
6348 the whole expression. Return the folded result. */
6351 fold_offsetof (tree expr
, tree type
, enum tree_code ctx
)
6354 tree_code code
= TREE_CODE (expr
);
6361 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
6362 return error_mark_node
;
6366 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6367 return error_mark_node
;
6371 if (!TREE_CONSTANT (TREE_OPERAND (expr
, 0)))
6373 error ("cannot apply %<offsetof%> to a non constant address");
6374 return error_mark_node
;
6376 return convert (type
, TREE_OPERAND (expr
, 0));
6379 base
= fold_offsetof (TREE_OPERAND (expr
, 0), type
, code
);
6380 if (base
== error_mark_node
)
6383 t
= TREE_OPERAND (expr
, 1);
6384 if (DECL_C_BIT_FIELD (t
))
6386 error ("attempt to take address of bit-field structure "
6388 return error_mark_node
;
6390 off
= size_binop_loc (input_location
, PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
6391 size_int (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (t
))
6396 base
= fold_offsetof (TREE_OPERAND (expr
, 0), type
, code
);
6397 if (base
== error_mark_node
)
6400 t
= TREE_OPERAND (expr
, 1);
6401 STRIP_ANY_LOCATION_WRAPPER (t
);
6403 /* Check if the offset goes beyond the upper bound of the array. */
6404 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) >= 0)
6406 tree upbound
= array_ref_up_bound (expr
);
6407 if (upbound
!= NULL_TREE
6408 && TREE_CODE (upbound
) == INTEGER_CST
6409 && !tree_int_cst_equal (upbound
,
6410 TYPE_MAX_VALUE (TREE_TYPE (upbound
))))
6412 if (ctx
!= ARRAY_REF
&& ctx
!= COMPONENT_REF
)
6413 upbound
= size_binop (PLUS_EXPR
, upbound
,
6414 build_int_cst (TREE_TYPE (upbound
), 1));
6415 if (tree_int_cst_lt (upbound
, t
))
6419 for (v
= TREE_OPERAND (expr
, 0);
6420 TREE_CODE (v
) == COMPONENT_REF
;
6421 v
= TREE_OPERAND (v
, 0))
6422 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v
, 0)))
6425 tree fld_chain
= DECL_CHAIN (TREE_OPERAND (v
, 1));
6426 for (; fld_chain
; fld_chain
= DECL_CHAIN (fld_chain
))
6427 if (TREE_CODE (fld_chain
) == FIELD_DECL
)
6433 /* Don't warn if the array might be considered a poor
6434 man's flexible array member with a very permissive
6435 definition thereof. */
6436 if (TREE_CODE (v
) == ARRAY_REF
6437 || TREE_CODE (v
) == COMPONENT_REF
)
6438 warning (OPT_Warray_bounds
,
6439 "index %E denotes an offset "
6440 "greater than size of %qT",
6441 t
, TREE_TYPE (TREE_OPERAND (expr
, 0)));
6446 t
= convert (sizetype
, t
);
6447 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
6451 /* Handle static members of volatile structs. */
6452 t
= TREE_OPERAND (expr
, 1);
6453 gcc_checking_assert (VAR_P (get_base_address (t
)));
6454 return fold_offsetof (t
, type
);
6460 if (!POINTER_TYPE_P (type
))
6461 return size_binop (PLUS_EXPR
, base
, convert (type
, off
));
6462 return fold_build_pointer_plus (base
, off
);
6465 /* *PTYPE is an incomplete array. Complete it with a domain based on
6466 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6467 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6468 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6471 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
6473 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
6474 int failure
= 0, quals
;
6475 bool overflow_p
= false;
6477 maxindex
= size_zero_node
;
6480 STRIP_ANY_LOCATION_WRAPPER (initial_value
);
6482 if (TREE_CODE (initial_value
) == STRING_CST
)
6485 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
6486 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
6488 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
6490 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
6492 if (vec_safe_is_empty (v
))
6496 maxindex
= ssize_int (-1);
6501 unsigned HOST_WIDE_INT cnt
;
6502 constructor_elt
*ce
;
6503 bool fold_p
= false;
6506 maxindex
= (*v
)[0].index
, fold_p
= true;
6508 curindex
= maxindex
;
6510 for (cnt
= 1; vec_safe_iterate (v
, cnt
, &ce
); cnt
++)
6512 bool curfold_p
= false;
6514 curindex
= ce
->index
, curfold_p
= true;
6519 /* Since we treat size types now as ordinary
6520 unsigned types, we need an explicit overflow
6522 tree orig
= curindex
;
6523 curindex
= fold_convert (sizetype
, curindex
);
6524 overflow_p
|= tree_int_cst_lt (curindex
, orig
);
6526 curindex
= size_binop (PLUS_EXPR
, curindex
,
6529 if (tree_int_cst_lt (maxindex
, curindex
))
6530 maxindex
= curindex
, fold_p
= curfold_p
;
6534 tree orig
= maxindex
;
6535 maxindex
= fold_convert (sizetype
, maxindex
);
6536 overflow_p
|= tree_int_cst_lt (maxindex
, orig
);
6542 /* Make an error message unless that happened already. */
6543 if (initial_value
!= error_mark_node
)
6555 elt
= TREE_TYPE (type
);
6556 quals
= TYPE_QUALS (strip_array_types (elt
));
6560 unqual_elt
= c_build_qualified_type (elt
, KEEP_QUAL_ADDR_SPACE (quals
));
6562 /* Using build_distinct_type_copy and modifying things afterward instead
6563 of using build_array_type to create a new type preserves all of the
6564 TYPE_LANG_FLAG_? bits that the front end may have set. */
6565 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6566 TREE_TYPE (main_type
) = unqual_elt
;
6567 TYPE_DOMAIN (main_type
)
6568 = build_range_type (TREE_TYPE (maxindex
),
6569 build_int_cst (TREE_TYPE (maxindex
), 0), maxindex
);
6570 TYPE_TYPELESS_STORAGE (main_type
) = TYPE_TYPELESS_STORAGE (type
);
6571 layout_type (main_type
);
6573 /* Make sure we have the canonical MAIN_TYPE. */
6574 hashval_t hashcode
= type_hash_canon_hash (main_type
);
6575 main_type
= type_hash_canon (hashcode
, main_type
);
6577 /* Fix the canonical type. */
6578 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
6579 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
6580 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
6581 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
6582 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
6583 != TYPE_DOMAIN (main_type
)))
6584 TYPE_CANONICAL (main_type
)
6585 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
6586 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)),
6587 TYPE_TYPELESS_STORAGE (main_type
));
6589 TYPE_CANONICAL (main_type
) = main_type
;
6594 type
= c_build_qualified_type (main_type
, quals
);
6596 if (COMPLETE_TYPE_P (type
)
6597 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
6598 && (overflow_p
|| TREE_OVERFLOW (TYPE_SIZE_UNIT (type
))))
6600 error ("size of array is too large");
6601 /* If we proceed with the array type as it is, we'll eventually
6602 crash in tree_to_[su]hwi(). */
6603 type
= error_mark_node
;
6610 /* INIT is an constructor of a structure with a flexible array member.
6611 Complete the flexible array member with a domain based on it's value. */
6613 complete_flexible_array_elts (tree init
)
6617 if (init
== NULL_TREE
|| TREE_CODE (init
) != CONSTRUCTOR
)
6620 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
6623 elt
= CONSTRUCTOR_ELTS (init
)->last ().value
;
6624 type
= TREE_TYPE (elt
);
6625 if (TREE_CODE (type
) == ARRAY_TYPE
6626 && TYPE_SIZE (type
) == NULL_TREE
)
6627 complete_array_type (&TREE_TYPE (elt
), elt
, false);
6629 complete_flexible_array_elts (elt
);
6632 /* Like c_mark_addressable but don't check register qualifier. */
6634 c_common_mark_addressable_vec (tree t
)
6636 if (TREE_CODE (t
) == C_MAYBE_CONST_EXPR
)
6637 t
= C_MAYBE_CONST_EXPR_EXPR (t
);
6638 while (handled_component_p (t
))
6639 t
= TREE_OPERAND (t
, 0);
6641 && TREE_CODE (t
) != PARM_DECL
6642 && TREE_CODE (t
) != COMPOUND_LITERAL_EXPR
)
6644 if (!VAR_P (t
) || !DECL_HARD_REGISTER (t
))
6645 TREE_ADDRESSABLE (t
) = 1;
6650 /* Used to help initialize the builtin-types.def table. When a type of
6651 the correct size doesn't exist, use error_mark_node instead of NULL.
6652 The later results in segfaults even when a decl using the type doesn't
6656 builtin_type_for_size (int size
, bool unsignedp
)
6658 tree type
= c_common_type_for_size (size
, unsignedp
);
6659 return type
? type
: error_mark_node
;
6662 /* Work out the size of the first argument of a call to
6663 __builtin_speculation_safe_value. Only pointers and integral types
6664 are permitted. Return -1 if the argument type is not supported or
6665 the size is too large; 0 if the argument type is a pointer or the
6666 size if it is integral. */
6667 static enum built_in_function
6668 speculation_safe_value_resolve_call (tree function
, vec
<tree
, va_gc
> *params
)
6670 /* Type of the argument. */
6674 if (vec_safe_is_empty (params
))
6676 error ("too few arguments to function %qE", function
);
6677 return BUILT_IN_NONE
;
6680 type
= TREE_TYPE ((*params
)[0]);
6681 if (TREE_CODE (type
) == ARRAY_TYPE
&& c_dialect_cxx ())
6683 /* Force array-to-pointer decay for C++. */
6684 (*params
)[0] = default_conversion ((*params
)[0]);
6685 type
= TREE_TYPE ((*params
)[0]);
6688 if (POINTER_TYPE_P (type
))
6689 return BUILT_IN_SPECULATION_SAFE_VALUE_PTR
;
6691 if (!INTEGRAL_TYPE_P (type
))
6694 if (!COMPLETE_TYPE_P (type
))
6697 size
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
6698 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
6699 return ((enum built_in_function
)
6700 ((int) BUILT_IN_SPECULATION_SAFE_VALUE_1
+ exact_log2 (size
)));
6703 /* Issue the diagnostic only if the argument is valid, otherwise
6704 it would be redundant at best and could be misleading. */
6705 if (type
!= error_mark_node
)
6706 error ("operand type %qT is incompatible with argument %d of %qE",
6709 return BUILT_IN_NONE
;
6712 /* Validate and coerce PARAMS, the arguments to ORIG_FUNCTION to fit
6713 the prototype for FUNCTION. The first argument is mandatory, a second
6714 argument, if present, must be type compatible with the first. */
6716 speculation_safe_value_resolve_params (location_t loc
, tree orig_function
,
6717 vec
<tree
, va_gc
> *params
)
6721 if (params
->length () == 0)
6723 error_at (loc
, "too few arguments to function %qE", orig_function
);
6727 else if (params
->length () > 2)
6729 error_at (loc
, "too many arguments to function %qE", orig_function
);
6734 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
)
6735 val
= default_conversion (val
);
6736 if (!(TREE_CODE (TREE_TYPE (val
)) == POINTER_TYPE
6737 || TREE_CODE (TREE_TYPE (val
)) == INTEGER_TYPE
))
6740 "expecting argument of type pointer or of type integer "
6746 if (params
->length () == 2)
6748 tree val2
= (*params
)[1];
6749 if (TREE_CODE (TREE_TYPE (val2
)) == ARRAY_TYPE
)
6750 val2
= default_conversion (val2
);
6751 if (!(TREE_TYPE (val
) == TREE_TYPE (val2
)
6752 || useless_type_conversion_p (TREE_TYPE (val
), TREE_TYPE (val2
))))
6754 error_at (loc
, "both arguments must be compatible");
6757 (*params
)[1] = val2
;
6763 /* Cast the result of the builtin back to the type of the first argument,
6764 preserving any qualifiers that it might have. */
6766 speculation_safe_value_resolve_return (tree first_param
, tree result
)
6768 tree ptype
= TREE_TYPE (first_param
);
6769 tree rtype
= TREE_TYPE (result
);
6770 ptype
= TYPE_MAIN_VARIANT (ptype
);
6772 if (tree_int_cst_equal (TYPE_SIZE (ptype
), TYPE_SIZE (rtype
)))
6773 return convert (ptype
, result
);
6778 /* A helper function for resolve_overloaded_builtin in resolving the
6779 overloaded __sync_ builtins. Returns a positive power of 2 if the
6780 first operand of PARAMS is a pointer to a supported data type.
6781 Returns 0 if an error is encountered.
6782 FETCH is true when FUNCTION is one of the _FETCH_OP_ or _OP_FETCH_
6786 sync_resolve_size (tree function
, vec
<tree
, va_gc
> *params
, bool fetch
)
6788 /* Type of the argument. */
6790 /* Type the argument points to. */
6794 if (vec_safe_is_empty (params
))
6796 error ("too few arguments to function %qE", function
);
6800 argtype
= type
= TREE_TYPE ((*params
)[0]);
6801 if (TREE_CODE (type
) == ARRAY_TYPE
&& c_dialect_cxx ())
6803 /* Force array-to-pointer decay for C++. */
6804 (*params
)[0] = default_conversion ((*params
)[0]);
6805 type
= TREE_TYPE ((*params
)[0]);
6807 if (TREE_CODE (type
) != POINTER_TYPE
)
6810 type
= TREE_TYPE (type
);
6811 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
6814 if (!COMPLETE_TYPE_P (type
))
6817 if (fetch
&& TREE_CODE (type
) == BOOLEAN_TYPE
)
6820 size
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
6821 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
6825 /* Issue the diagnostic only if the argument is valid, otherwise
6826 it would be redundant at best and could be misleading. */
6827 if (argtype
!= error_mark_node
)
6828 error ("operand type %qT is incompatible with argument %d of %qE",
6829 argtype
, 1, function
);
6833 /* A helper function for resolve_overloaded_builtin. Adds casts to
6834 PARAMS to make arguments match up with those of FUNCTION. Drops
6835 the variadic arguments at the end. Returns false if some error
6836 was encountered; true on success. */
6839 sync_resolve_params (location_t loc
, tree orig_function
, tree function
,
6840 vec
<tree
, va_gc
> *params
, bool orig_format
)
6842 function_args_iterator iter
;
6844 unsigned int parmnum
;
6846 function_args_iter_init (&iter
, TREE_TYPE (function
));
6847 /* We've declared the implementation functions to use "volatile void *"
6848 as the pointer parameter, so we shouldn't get any complaints from the
6849 call to check_function_arguments what ever type the user used. */
6850 function_args_iter_next (&iter
);
6851 ptype
= TREE_TYPE (TREE_TYPE ((*params
)[0]));
6852 ptype
= TYPE_MAIN_VARIANT (ptype
);
6854 /* For the rest of the values, we need to cast these to FTYPE, so that we
6855 don't get warnings for passing pointer types, etc. */
6861 arg_type
= function_args_iter_cond (&iter
);
6862 /* XXX void_type_node belies the abstraction. */
6863 if (arg_type
== void_type_node
)
6867 if (params
->length () <= parmnum
)
6869 error_at (loc
, "too few arguments to function %qE", orig_function
);
6873 /* Only convert parameters if arg_type is unsigned integer type with
6874 new format sync routines, i.e. don't attempt to convert pointer
6875 arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n),
6876 bool arguments (e.g. WEAK argument) or signed int arguments (memmodel
6878 if (TREE_CODE (arg_type
) == INTEGER_TYPE
&& TYPE_UNSIGNED (arg_type
))
6880 /* Ideally for the first conversion we'd use convert_for_assignment
6881 so that we get warnings for anything that doesn't match the pointer
6882 type. This isn't portable across the C and C++ front ends atm. */
6883 val
= (*params
)[parmnum
];
6884 val
= convert (ptype
, val
);
6885 val
= convert (arg_type
, val
);
6886 (*params
)[parmnum
] = val
;
6889 function_args_iter_next (&iter
);
6892 /* __atomic routines are not variadic. */
6893 if (!orig_format
&& params
->length () != parmnum
+ 1)
6895 error_at (loc
, "too many arguments to function %qE", orig_function
);
6899 /* The definition of these primitives is variadic, with the remaining
6900 being "an optional list of variables protected by the memory barrier".
6901 No clue what that's supposed to mean, precisely, but we consider all
6902 call-clobbered variables to be protected so we're safe. */
6903 params
->truncate (parmnum
+ 1);
6908 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6909 RESULT to make it match the type of the first pointer argument in
6913 sync_resolve_return (tree first_param
, tree result
, bool orig_format
)
6915 tree ptype
= TREE_TYPE (TREE_TYPE (first_param
));
6916 tree rtype
= TREE_TYPE (result
);
6917 ptype
= TYPE_MAIN_VARIANT (ptype
);
6919 /* New format doesn't require casting unless the types are the same size. */
6920 if (orig_format
|| tree_int_cst_equal (TYPE_SIZE (ptype
), TYPE_SIZE (rtype
)))
6921 return convert (ptype
, result
);
6926 /* This function verifies the PARAMS to generic atomic FUNCTION.
6927 It returns the size if all the parameters are the same size, otherwise
6928 0 is returned if the parameters are invalid. */
6931 get_atomic_generic_size (location_t loc
, tree function
,
6932 vec
<tree
, va_gc
> *params
)
6934 unsigned int n_param
;
6935 unsigned int n_model
;
6940 /* Determine the parameter makeup. */
6941 switch (DECL_FUNCTION_CODE (function
))
6943 case BUILT_IN_ATOMIC_EXCHANGE
:
6947 case BUILT_IN_ATOMIC_LOAD
:
6948 case BUILT_IN_ATOMIC_STORE
:
6952 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
6960 if (vec_safe_length (params
) != n_param
)
6962 error_at (loc
, "incorrect number of arguments to function %qE", function
);
6966 /* Get type of first parameter, and determine its size. */
6967 type_0
= TREE_TYPE ((*params
)[0]);
6968 if (TREE_CODE (type_0
) == ARRAY_TYPE
&& c_dialect_cxx ())
6970 /* Force array-to-pointer decay for C++. */
6971 (*params
)[0] = default_conversion ((*params
)[0]);
6972 type_0
= TREE_TYPE ((*params
)[0]);
6974 if (TREE_CODE (type_0
) != POINTER_TYPE
|| VOID_TYPE_P (TREE_TYPE (type_0
)))
6976 error_at (loc
, "argument 1 of %qE must be a non-void pointer type",
6981 /* Types must be compile time constant sizes. */
6982 if (TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type_0
)))) != INTEGER_CST
)
6985 "argument 1 of %qE must be a pointer to a constant size type",
6990 size_0
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (type_0
)));
6992 /* Zero size objects are not allowed. */
6996 "argument 1 of %qE must be a pointer to a nonzero size object",
7001 /* Check each other parameter is a pointer and the same size. */
7002 for (x
= 0; x
< n_param
- n_model
; x
++)
7005 tree type
= TREE_TYPE ((*params
)[x
]);
7006 /* __atomic_compare_exchange has a bool in the 4th position, skip it. */
7007 if (n_param
== 6 && x
== 3)
7009 if (TREE_CODE (type
) == ARRAY_TYPE
&& c_dialect_cxx ())
7011 /* Force array-to-pointer decay for C++. */
7012 (*params
)[x
] = default_conversion ((*params
)[x
]);
7013 type
= TREE_TYPE ((*params
)[x
]);
7015 if (!POINTER_TYPE_P (type
))
7017 error_at (loc
, "argument %d of %qE must be a pointer type", x
+ 1,
7021 else if (TYPE_SIZE_UNIT (TREE_TYPE (type
))
7022 && TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type
))))
7025 error_at (loc
, "argument %d of %qE must be a pointer to a constant "
7026 "size type", x
+ 1, function
);
7029 else if (FUNCTION_POINTER_TYPE_P (type
))
7031 error_at (loc
, "argument %d of %qE must not be a pointer to a "
7032 "function", x
+ 1, function
);
7035 tree type_size
= TYPE_SIZE_UNIT (TREE_TYPE (type
));
7036 size
= type_size
? tree_to_uhwi (type_size
) : 0;
7039 error_at (loc
, "size mismatch in argument %d of %qE", x
+ 1,
7045 /* Check memory model parameters for validity. */
7046 for (x
= n_param
- n_model
; x
< n_param
; x
++)
7048 tree p
= (*params
)[x
];
7049 if (!INTEGRAL_TYPE_P (TREE_TYPE (p
)))
7051 error_at (loc
, "non-integer memory model argument %d of %qE", x
+ 1,
7055 p
= fold_for_warn (p
);
7056 if (TREE_CODE (p
) == INTEGER_CST
)
7058 /* memmodel_base masks the low 16 bits, thus ignore any bits above
7059 it by using TREE_INT_CST_LOW instead of tree_to_*hwi. Those high
7060 bits will be checked later during expansion in target specific
7062 if (memmodel_base (TREE_INT_CST_LOW (p
)) >= MEMMODEL_LAST
)
7063 warning_at (loc
, OPT_Winvalid_memory_model
,
7064 "invalid memory model argument %d of %qE", x
+ 1,
7073 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N
7074 at the beginning of the parameter list PARAMS representing the size of the
7075 objects. This is to match the library ABI requirement. LOC is the location
7076 of the function call.
7077 The new function is returned if it needed rebuilding, otherwise NULL_TREE is
7078 returned to allow the external call to be constructed. */
7081 add_atomic_size_parameter (unsigned n
, location_t loc
, tree function
,
7082 vec
<tree
, va_gc
> *params
)
7086 /* Insert a SIZE_T parameter as the first param. If there isn't
7087 enough space, allocate a new vector and recursively re-build with that. */
7088 if (!params
->space (1))
7090 unsigned int z
, len
;
7091 vec
<tree
, va_gc
> *v
;
7094 len
= params
->length ();
7095 vec_alloc (v
, len
+ 1);
7096 v
->quick_push (build_int_cst (size_type_node
, n
));
7097 for (z
= 0; z
< len
; z
++)
7098 v
->quick_push ((*params
)[z
]);
7099 f
= build_function_call_vec (loc
, vNULL
, function
, v
, NULL
);
7104 /* Add the size parameter and leave as a function call for processing. */
7105 size_node
= build_int_cst (size_type_node
, n
);
7106 params
->quick_insert (0, size_node
);
7111 /* Return whether atomic operations for naturally aligned N-byte
7112 arguments are supported, whether inline or through libatomic. */
7114 atomic_size_supported_p (int n
)
7125 return targetm
.scalar_mode_supported_p (TImode
);
7132 /* This will process an __atomic_exchange function call, determine whether it
7133 needs to be mapped to the _N variation, or turned into a library call.
7134 LOC is the location of the builtin call.
7135 FUNCTION is the DECL that has been invoked;
7136 PARAMS is the argument list for the call. The return value is non-null
7137 TRUE is returned if it is translated into the proper format for a call to the
7138 external library, and NEW_RETURN is set the tree for that function.
7139 FALSE is returned if processing for the _N variation is required, and
7140 NEW_RETURN is set to the return value the result is copied into. */
7142 resolve_overloaded_atomic_exchange (location_t loc
, tree function
,
7143 vec
<tree
, va_gc
> *params
, tree
*new_return
)
7145 tree p0
, p1
, p2
, p3
;
7146 tree I_type
, I_type_ptr
;
7147 int n
= get_atomic_generic_size (loc
, function
, params
);
7149 /* Size of 0 is an error condition. */
7152 *new_return
= error_mark_node
;
7156 /* If not a lock-free size, change to the library generic format. */
7157 if (!atomic_size_supported_p (n
))
7159 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
7163 /* Otherwise there is a lockfree match, transform the call from:
7164 void fn(T* mem, T* desired, T* return, model)
7166 *return = (T) (fn (In* mem, (In) *desired, model)) */
7173 /* Create pointer to appropriate size. */
7174 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
7175 I_type_ptr
= build_pointer_type (I_type
);
7177 /* Convert object pointer to required type. */
7178 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7180 /* Convert new value to required type, and dereference it. */
7181 p1
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
7182 p1
= build1 (VIEW_CONVERT_EXPR
, I_type
, p1
);
7185 /* Move memory model to the 3rd position, and end param list. */
7187 params
->truncate (3);
7189 /* Convert return pointer and dereference it for later assignment. */
7190 *new_return
= build_indirect_ref (loc
, p2
, RO_UNARY_STAR
);
7196 /* This will process an __atomic_compare_exchange function call, determine
7197 whether it needs to be mapped to the _N variation, or turned into a lib call.
7198 LOC is the location of the builtin call.
7199 FUNCTION is the DECL that has been invoked;
7200 PARAMS is the argument list for the call. The return value is non-null
7201 TRUE is returned if it is translated into the proper format for a call to the
7202 external library, and NEW_RETURN is set the tree for that function.
7203 FALSE is returned if processing for the _N variation is required. */
7206 resolve_overloaded_atomic_compare_exchange (location_t loc
, tree function
,
7207 vec
<tree
, va_gc
> *params
,
7211 tree I_type
, I_type_ptr
;
7212 int n
= get_atomic_generic_size (loc
, function
, params
);
7214 /* Size of 0 is an error condition. */
7217 *new_return
= error_mark_node
;
7221 /* If not a lock-free size, change to the library generic format. */
7222 if (!atomic_size_supported_p (n
))
7224 /* The library generic format does not have the weak parameter, so
7225 remove it from the param list. Since a parameter has been removed,
7226 we can be sure that there is room for the SIZE_T parameter, meaning
7227 there will not be a recursive rebuilding of the parameter list, so
7228 there is no danger this will be done twice. */
7231 (*params
)[3] = (*params
)[4];
7232 (*params
)[4] = (*params
)[5];
7233 params
->truncate (5);
7235 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
7239 /* Otherwise, there is a match, so the call needs to be transformed from:
7240 bool fn(T* mem, T* desired, T* return, weak, success, failure)
7242 bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */
7248 /* Create pointer to appropriate size. */
7249 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
7250 I_type_ptr
= build_pointer_type (I_type
);
7252 /* Convert object pointer to required type. */
7253 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7256 /* Convert expected pointer to required type. */
7257 p1
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p1
);
7260 /* Convert desired value to required type, and dereference it. */
7261 p2
= build_indirect_ref (loc
, p2
, RO_UNARY_STAR
);
7262 p2
= build1 (VIEW_CONVERT_EXPR
, I_type
, p2
);
7265 /* The rest of the parameters are fine. NULL means no special return value
7272 /* This will process an __atomic_load function call, determine whether it
7273 needs to be mapped to the _N variation, or turned into a library call.
7274 LOC is the location of the builtin call.
7275 FUNCTION is the DECL that has been invoked;
7276 PARAMS is the argument list for the call. The return value is non-null
7277 TRUE is returned if it is translated into the proper format for a call to the
7278 external library, and NEW_RETURN is set the tree for that function.
7279 FALSE is returned if processing for the _N variation is required, and
7280 NEW_RETURN is set to the return value the result is copied into. */
7283 resolve_overloaded_atomic_load (location_t loc
, tree function
,
7284 vec
<tree
, va_gc
> *params
, tree
*new_return
)
7287 tree I_type
, I_type_ptr
;
7288 int n
= get_atomic_generic_size (loc
, function
, params
);
7290 /* Size of 0 is an error condition. */
7293 *new_return
= error_mark_node
;
7297 /* If not a lock-free size, change to the library generic format. */
7298 if (!atomic_size_supported_p (n
))
7300 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
7304 /* Otherwise, there is a match, so the call needs to be transformed from:
7305 void fn(T* mem, T* return, model)
7307 *return = (T) (fn ((In *) mem, model)) */
7313 /* Create pointer to appropriate size. */
7314 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
7315 I_type_ptr
= build_pointer_type (I_type
);
7317 /* Convert object pointer to required type. */
7318 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7321 /* Move memory model to the 2nd position, and end param list. */
7323 params
->truncate (2);
7325 /* Convert return pointer and dereference it for later assignment. */
7326 *new_return
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
7332 /* This will process an __atomic_store function call, determine whether it
7333 needs to be mapped to the _N variation, or turned into a library call.
7334 LOC is the location of the builtin call.
7335 FUNCTION is the DECL that has been invoked;
7336 PARAMS is the argument list for the call. The return value is non-null
7337 TRUE is returned if it is translated into the proper format for a call to the
7338 external library, and NEW_RETURN is set the tree for that function.
7339 FALSE is returned if processing for the _N variation is required, and
7340 NEW_RETURN is set to the return value the result is copied into. */
7343 resolve_overloaded_atomic_store (location_t loc
, tree function
,
7344 vec
<tree
, va_gc
> *params
, tree
*new_return
)
7347 tree I_type
, I_type_ptr
;
7348 int n
= get_atomic_generic_size (loc
, function
, params
);
7350 /* Size of 0 is an error condition. */
7353 *new_return
= error_mark_node
;
7357 /* If not a lock-free size, change to the library generic format. */
7358 if (!atomic_size_supported_p (n
))
7360 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
7364 /* Otherwise, there is a match, so the call needs to be transformed from:
7365 void fn(T* mem, T* value, model)
7367 fn ((In *) mem, (In) *value, model) */
7372 /* Create pointer to appropriate size. */
7373 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
7374 I_type_ptr
= build_pointer_type (I_type
);
7376 /* Convert object pointer to required type. */
7377 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7380 /* Convert new value to required type, and dereference it. */
7381 p1
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
7382 p1
= build1 (VIEW_CONVERT_EXPR
, I_type
, p1
);
7385 /* The memory model is in the right spot already. Return is void. */
7386 *new_return
= NULL_TREE
;
7392 /* Some builtin functions are placeholders for other expressions. This
7393 function should be called immediately after parsing the call expression
7394 before surrounding code has committed to the type of the expression.
7396 LOC is the location of the builtin call.
7398 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7399 PARAMS is the argument list for the call. The return value is non-null
7400 when expansion is complete, and null if normal processing should
7404 resolve_overloaded_builtin (location_t loc
, tree function
,
7405 vec
<tree
, va_gc
> *params
)
7407 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
7409 /* Is function one of the _FETCH_OP_ or _OP_FETCH_ built-ins?
7410 Those are not valid to call with a pointer to _Bool (or C++ bool)
7411 and so must be rejected. */
7412 bool fetch_op
= true;
7413 bool orig_format
= true;
7414 tree new_return
= NULL_TREE
;
7416 switch (DECL_BUILT_IN_CLASS (function
))
7418 case BUILT_IN_NORMAL
:
7421 if (targetm
.resolve_overloaded_builtin
)
7422 return targetm
.resolve_overloaded_builtin (loc
, function
, params
);
7429 /* Handle BUILT_IN_NORMAL here. */
7432 case BUILT_IN_SPECULATION_SAFE_VALUE_N
:
7434 tree new_function
, first_param
, result
;
7435 enum built_in_function fncode
7436 = speculation_safe_value_resolve_call (function
, params
);;
7438 first_param
= (*params
)[0];
7439 if (fncode
== BUILT_IN_NONE
7440 || !speculation_safe_value_resolve_params (loc
, function
, params
))
7441 return error_mark_node
;
7443 if (targetm
.have_speculation_safe_value (true))
7445 new_function
= builtin_decl_explicit (fncode
);
7446 result
= build_function_call_vec (loc
, vNULL
, new_function
, params
,
7449 if (result
== error_mark_node
)
7452 return speculation_safe_value_resolve_return (first_param
, result
);
7456 /* This target doesn't have, or doesn't need, active mitigation
7457 against incorrect speculative execution. Simply return the
7458 first parameter to the builtin. */
7459 if (!targetm
.have_speculation_safe_value (false))
7460 /* The user has invoked __builtin_speculation_safe_value
7461 even though __HAVE_SPECULATION_SAFE_VALUE is not
7462 defined: emit a warning. */
7463 warning_at (input_location
, 0,
7464 "this target does not define a speculation barrier; "
7465 "your program will still execute correctly, "
7466 "but incorrect speculation may not be be "
7469 /* If the optional second argument is present, handle any side
7471 if (params
->length () == 2
7472 && TREE_SIDE_EFFECTS ((*params
)[1]))
7473 return build2 (COMPOUND_EXPR
, TREE_TYPE (first_param
),
7474 (*params
)[1], first_param
);
7480 case BUILT_IN_ATOMIC_EXCHANGE
:
7481 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
7482 case BUILT_IN_ATOMIC_LOAD
:
7483 case BUILT_IN_ATOMIC_STORE
:
7485 /* Handle these 4 together so that they can fall through to the next
7486 case if the call is transformed to an _N variant. */
7489 case BUILT_IN_ATOMIC_EXCHANGE
:
7491 if (resolve_overloaded_atomic_exchange (loc
, function
, params
,
7494 /* Change to the _N variant. */
7495 orig_code
= BUILT_IN_ATOMIC_EXCHANGE_N
;
7499 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
7501 if (resolve_overloaded_atomic_compare_exchange (loc
, function
,
7505 /* Change to the _N variant. */
7506 orig_code
= BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
;
7509 case BUILT_IN_ATOMIC_LOAD
:
7511 if (resolve_overloaded_atomic_load (loc
, function
, params
,
7514 /* Change to the _N variant. */
7515 orig_code
= BUILT_IN_ATOMIC_LOAD_N
;
7518 case BUILT_IN_ATOMIC_STORE
:
7520 if (resolve_overloaded_atomic_store (loc
, function
, params
,
7523 /* Change to the _N variant. */
7524 orig_code
= BUILT_IN_ATOMIC_STORE_N
;
7532 case BUILT_IN_ATOMIC_EXCHANGE_N
:
7533 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
:
7534 case BUILT_IN_ATOMIC_LOAD_N
:
7535 case BUILT_IN_ATOMIC_STORE_N
:
7538 case BUILT_IN_ATOMIC_ADD_FETCH_N
:
7539 case BUILT_IN_ATOMIC_SUB_FETCH_N
:
7540 case BUILT_IN_ATOMIC_AND_FETCH_N
:
7541 case BUILT_IN_ATOMIC_NAND_FETCH_N
:
7542 case BUILT_IN_ATOMIC_XOR_FETCH_N
:
7543 case BUILT_IN_ATOMIC_OR_FETCH_N
:
7544 case BUILT_IN_ATOMIC_FETCH_ADD_N
:
7545 case BUILT_IN_ATOMIC_FETCH_SUB_N
:
7546 case BUILT_IN_ATOMIC_FETCH_AND_N
:
7547 case BUILT_IN_ATOMIC_FETCH_NAND_N
:
7548 case BUILT_IN_ATOMIC_FETCH_XOR_N
:
7549 case BUILT_IN_ATOMIC_FETCH_OR_N
:
7550 orig_format
= false;
7552 case BUILT_IN_SYNC_FETCH_AND_ADD_N
:
7553 case BUILT_IN_SYNC_FETCH_AND_SUB_N
:
7554 case BUILT_IN_SYNC_FETCH_AND_OR_N
:
7555 case BUILT_IN_SYNC_FETCH_AND_AND_N
:
7556 case BUILT_IN_SYNC_FETCH_AND_XOR_N
:
7557 case BUILT_IN_SYNC_FETCH_AND_NAND_N
:
7558 case BUILT_IN_SYNC_ADD_AND_FETCH_N
:
7559 case BUILT_IN_SYNC_SUB_AND_FETCH_N
:
7560 case BUILT_IN_SYNC_OR_AND_FETCH_N
:
7561 case BUILT_IN_SYNC_AND_AND_FETCH_N
:
7562 case BUILT_IN_SYNC_XOR_AND_FETCH_N
:
7563 case BUILT_IN_SYNC_NAND_AND_FETCH_N
:
7564 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
:
7565 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N
:
7566 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_N
:
7567 case BUILT_IN_SYNC_LOCK_RELEASE_N
:
7569 /* The following are not _FETCH_OPs and must be accepted with
7570 pointers to _Bool (or C++ bool). */
7573 (orig_code
!= BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
7574 && orig_code
!= BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N
7575 && orig_code
!= BUILT_IN_SYNC_LOCK_TEST_AND_SET_N
7576 && orig_code
!= BUILT_IN_SYNC_LOCK_RELEASE_N
);
7578 int n
= sync_resolve_size (function
, params
, fetch_op
);
7579 tree new_function
, first_param
, result
;
7580 enum built_in_function fncode
;
7583 return error_mark_node
;
7585 fncode
= (enum built_in_function
)((int)orig_code
+ exact_log2 (n
) + 1);
7586 new_function
= builtin_decl_explicit (fncode
);
7587 if (!sync_resolve_params (loc
, function
, new_function
, params
,
7589 return error_mark_node
;
7591 first_param
= (*params
)[0];
7592 result
= build_function_call_vec (loc
, vNULL
, new_function
, params
,
7594 if (result
== error_mark_node
)
7596 if (orig_code
!= BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
7597 && orig_code
!= BUILT_IN_SYNC_LOCK_RELEASE_N
7598 && orig_code
!= BUILT_IN_ATOMIC_STORE_N
7599 && orig_code
!= BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
)
7600 result
= sync_resolve_return (first_param
, result
, orig_format
);
7603 /* Prevent -Wunused-value warning. */
7604 TREE_USED (result
) = true;
7606 /* If new_return is set, assign function to that expr and cast the
7607 result to void since the generic interface returned void. */
7610 /* Cast function result from I{1,2,4,8,16} to the required type. */
7611 result
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (new_return
), result
);
7612 result
= build2 (MODIFY_EXPR
, TREE_TYPE (new_return
), new_return
,
7614 TREE_SIDE_EFFECTS (result
) = 1;
7615 protected_set_expr_location (result
, loc
);
7616 result
= convert (void_type_node
, result
);
7626 /* vector_types_compatible_elements_p is used in type checks of vectors
7627 values used as operands of binary operators. Where it returns true, and
7628 the other checks of the caller succeed (being vector types in he first
7629 place, and matching number of elements), we can just treat the types
7630 as essentially the same.
7631 Contrast with vector_targets_convertible_p, which is used for vector
7632 pointer types, and vector_types_convertible_p, which will allow
7633 language-specific matches under the control of flag_lax_vector_conversions,
7634 and might still require a conversion. */
7635 /* True if vector types T1 and T2 can be inputs to the same binary
7636 operator without conversion.
7637 We don't check the overall vector size here because some of our callers
7638 want to give different error messages when the vectors are compatible
7639 except for the element count. */
7642 vector_types_compatible_elements_p (tree t1
, tree t2
)
7644 bool opaque
= TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
);
7645 t1
= TREE_TYPE (t1
);
7646 t2
= TREE_TYPE (t2
);
7648 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
7650 gcc_assert ((INTEGRAL_TYPE_P (t1
)
7652 || c1
== FIXED_POINT_TYPE
)
7653 && (INTEGRAL_TYPE_P (t2
)
7655 || c2
== FIXED_POINT_TYPE
));
7657 t1
= c_common_signed_type (t1
);
7658 t2
= c_common_signed_type (t2
);
7659 /* Equality works here because c_common_signed_type uses
7660 TYPE_MAIN_VARIANT. */
7663 if (opaque
&& c1
== c2
7664 && (INTEGRAL_TYPE_P (t1
) || c1
== REAL_TYPE
)
7665 && TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
7670 /* Check for missing format attributes on function pointers. LTYPE is
7671 the new type or left-hand side type. RTYPE is the old type or
7672 right-hand side type. Returns TRUE if LTYPE is missing the desired
7676 check_missing_format_attribute (tree ltype
, tree rtype
)
7678 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
7681 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
7682 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
7687 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
7688 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
7696 /* Setup a TYPE_DECL node as a typedef representation.
7698 X is a TYPE_DECL for a typedef statement. Create a brand new
7699 ..._TYPE node (which will be just a variant of the existing
7700 ..._TYPE node with identical properties) and then install X
7701 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
7703 The whole point here is to end up with a situation where each
7704 and every ..._TYPE node the compiler creates will be uniquely
7705 associated with AT MOST one node representing a typedef name.
7706 This way, even though the compiler substitutes corresponding
7707 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
7708 early on, later parts of the compiler can always do the reverse
7709 translation and get back the corresponding typedef name. For
7712 typedef struct S MY_TYPE;
7715 Later parts of the compiler might only know that `object' was of
7716 type `struct S' if it were not for code just below. With this
7717 code however, later parts of the compiler see something like:
7719 struct S' == struct S
7720 typedef struct S' MY_TYPE;
7723 And they can then deduce (from the node for type struct S') that
7724 the original object declaration was:
7728 Being able to do this is important for proper support of protoize,
7729 and also for generating precise symbolic debugging information
7730 which takes full account of the programmer's (typedef) vocabulary.
7732 Obviously, we don't want to generate a duplicate ..._TYPE node if
7733 the TYPE_DECL node that we are now processing really represents a
7734 standard built-in type. */
7737 set_underlying_type (tree x
)
7739 if (x
== error_mark_node
)
7741 if (DECL_IS_BUILTIN (x
) && TREE_CODE (TREE_TYPE (x
)) != ARRAY_TYPE
)
7743 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
7744 TYPE_NAME (TREE_TYPE (x
)) = x
;
7746 else if (TREE_TYPE (x
) != error_mark_node
7747 && DECL_ORIGINAL_TYPE (x
) == NULL_TREE
)
7749 tree tt
= TREE_TYPE (x
);
7750 DECL_ORIGINAL_TYPE (x
) = tt
;
7751 tt
= build_variant_type_copy (tt
);
7752 TYPE_STUB_DECL (tt
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
7755 /* Mark the type as used only when its type decl is decorated
7756 with attribute unused. */
7757 if (lookup_attribute ("unused", DECL_ATTRIBUTES (x
)))
7764 /* Record the types used by the current global variable declaration
7765 being parsed, so that we can decide later to emit their debug info.
7766 Those types are in types_used_by_cur_var_decl, and we are going to
7767 store them in the types_used_by_vars_hash hash table.
7768 DECL is the declaration of the global variable that has been parsed. */
7771 record_types_used_by_current_var_decl (tree decl
)
7773 gcc_assert (decl
&& DECL_P (decl
) && TREE_STATIC (decl
));
7775 while (types_used_by_cur_var_decl
&& !types_used_by_cur_var_decl
->is_empty ())
7777 tree type
= types_used_by_cur_var_decl
->pop ();
7778 types_used_by_var_decl_insert (type
, decl
);
7782 /* The C and C++ parsers both use vectors to hold function arguments.
7783 For efficiency, we keep a cache of unused vectors. This is the
7786 typedef vec
<tree
, va_gc
> *tree_gc_vec
;
7787 static GTY((deletable
)) vec
<tree_gc_vec
, va_gc
> *tree_vector_cache
;
7789 /* Return a new vector from the cache. If the cache is empty,
7790 allocate a new vector. These vectors are GC'ed, so it is OK if the
7791 pointer is not released.. */
7794 make_tree_vector (void)
7796 if (tree_vector_cache
&& !tree_vector_cache
->is_empty ())
7797 return tree_vector_cache
->pop ();
7800 /* Passing 0 to vec::alloc returns NULL, and our callers require
7801 that we always return a non-NULL value. The vector code uses
7802 4 when growing a NULL vector, so we do too. */
7803 vec
<tree
, va_gc
> *v
;
7809 /* Release a vector of trees back to the cache. */
7812 release_tree_vector (vec
<tree
, va_gc
> *vec
)
7817 vec_safe_push (tree_vector_cache
, vec
);
7821 /* Get a new tree vector holding a single tree. */
7824 make_tree_vector_single (tree t
)
7826 vec
<tree
, va_gc
> *ret
= make_tree_vector ();
7827 ret
->quick_push (t
);
7831 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */
7834 make_tree_vector_from_list (tree list
)
7836 vec
<tree
, va_gc
> *ret
= make_tree_vector ();
7837 for (; list
; list
= TREE_CHAIN (list
))
7838 vec_safe_push (ret
, TREE_VALUE (list
));
7842 /* Get a new tree vector of the values of a CONSTRUCTOR. */
7845 make_tree_vector_from_ctor (tree ctor
)
7847 vec
<tree
,va_gc
> *ret
= make_tree_vector ();
7848 vec_safe_reserve (ret
, CONSTRUCTOR_NELTS (ctor
));
7849 for (unsigned i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
7850 ret
->quick_push (CONSTRUCTOR_ELT (ctor
, i
)->value
);
7854 /* Get a new tree vector which is a copy of an existing one. */
7857 make_tree_vector_copy (const vec
<tree
, va_gc
> *orig
)
7859 vec
<tree
, va_gc
> *ret
;
7863 ret
= make_tree_vector ();
7864 vec_safe_reserve (ret
, vec_safe_length (orig
));
7865 FOR_EACH_VEC_SAFE_ELT (orig
, ix
, t
)
7866 ret
->quick_push (t
);
7870 /* Return true if KEYWORD starts a type specifier. */
7873 keyword_begins_type_specifier (enum rid keyword
)
7907 if (keyword
>= RID_FIRST_INT_N
7908 && keyword
< RID_FIRST_INT_N
+ NUM_INT_N_ENTS
7909 && int_n_enabled_p
[keyword
-RID_FIRST_INT_N
])
7915 /* Return true if KEYWORD names a type qualifier. */
7918 keyword_is_type_qualifier (enum rid keyword
)
7932 /* Return true if KEYWORD names a storage class specifier.
7934 RID_TYPEDEF is not included in this list despite `typedef' being
7935 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
7936 such for syntactic convenience only. */
7939 keyword_is_storage_class_specifier (enum rid keyword
)
7955 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
7958 keyword_is_function_specifier (enum rid keyword
)
7972 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
7973 declaration-specifier (C99 6.7). */
7976 keyword_is_decl_specifier (enum rid keyword
)
7978 if (keyword_is_storage_class_specifier (keyword
)
7979 || keyword_is_type_qualifier (keyword
)
7980 || keyword_is_function_specifier (keyword
))
7994 /* Initialize language-specific-bits of tree_contains_struct. */
7997 c_common_init_ts (void)
7999 MARK_TS_TYPED (C_MAYBE_CONST_EXPR
);
8000 MARK_TS_TYPED (EXCESS_PRECISION_EXPR
);
8003 /* Build a user-defined numeric literal out of an integer constant type VALUE
8004 with identifier SUFFIX. */
8007 build_userdef_literal (tree suffix_id
, tree value
,
8008 enum overflow_type overflow
, tree num_string
)
8010 tree literal
= make_node (USERDEF_LITERAL
);
8011 USERDEF_LITERAL_SUFFIX_ID (literal
) = suffix_id
;
8012 USERDEF_LITERAL_VALUE (literal
) = value
;
8013 USERDEF_LITERAL_OVERFLOW (literal
) = overflow
;
8014 USERDEF_LITERAL_NUM_STRING (literal
) = num_string
;
8018 /* For vector[index], convert the vector to an array of the underlying type.
8019 Return true if the resulting ARRAY_REF should not be an lvalue. */
8022 convert_vector_to_array_for_subscript (location_t loc
,
8023 tree
*vecp
, tree index
)
8026 if (VECTOR_TYPE_P (TREE_TYPE (*vecp
)))
8028 tree type
= TREE_TYPE (*vecp
);
8030 ret
= !lvalue_p (*vecp
);
8032 index
= fold_for_warn (index
);
8033 if (TREE_CODE (index
) == INTEGER_CST
)
8034 if (!tree_fits_uhwi_p (index
)
8035 || maybe_ge (tree_to_uhwi (index
), TYPE_VECTOR_SUBPARTS (type
)))
8036 warning_at (loc
, OPT_Warray_bounds
, "index value is out of bound");
8038 /* We are building an ARRAY_REF so mark the vector as addressable
8039 to not run into the gimplifiers premature setting of DECL_GIMPLE_REG_P
8040 for function parameters. */
8041 c_common_mark_addressable_vec (*vecp
);
8043 *vecp
= build1 (VIEW_CONVERT_EXPR
,
8044 build_array_type_nelts (TREE_TYPE (type
),
8045 TYPE_VECTOR_SUBPARTS (type
)),
8051 /* Determine which of the operands, if any, is a scalar that needs to be
8052 converted to a vector, for the range of operations. */
8054 scalar_to_vector (location_t loc
, enum tree_code code
, tree op0
, tree op1
,
8057 tree type0
= TREE_TYPE (op0
);
8058 tree type1
= TREE_TYPE (op1
);
8059 bool integer_only_op
= false;
8060 enum stv_conv ret
= stv_firstarg
;
8062 gcc_assert (VECTOR_TYPE_P (type0
) || VECTOR_TYPE_P (type1
));
8065 /* Most GENERIC binary expressions require homogeneous arguments.
8066 LSHIFT_EXPR and RSHIFT_EXPR are exceptions and accept a first
8067 argument that is a vector and a second one that is a scalar, so
8068 we never return stv_secondarg for them. */
8071 if (TREE_CODE (type0
) == INTEGER_TYPE
8072 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
8074 if (unsafe_conversion_p (loc
, TREE_TYPE (type1
), op0
,
8078 error_at (loc
, "conversion of scalar %qT to vector %qT "
8079 "involves truncation", type0
, type1
);
8083 return stv_firstarg
;
8090 integer_only_op
= true;
8098 case TRUNC_DIV_EXPR
:
8100 case FLOOR_DIV_EXPR
:
8101 case ROUND_DIV_EXPR
:
8102 case EXACT_DIV_EXPR
:
8103 case TRUNC_MOD_EXPR
:
8104 case FLOOR_MOD_EXPR
:
8112 /* What about UNLT_EXPR? */
8113 if (VECTOR_TYPE_P (type0
))
8115 ret
= stv_secondarg
;
8116 std::swap (type0
, type1
);
8117 std::swap (op0
, op1
);
8120 if (TREE_CODE (type0
) == INTEGER_TYPE
8121 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
8123 if (unsafe_conversion_p (loc
, TREE_TYPE (type1
), op0
,
8127 error_at (loc
, "conversion of scalar %qT to vector %qT "
8128 "involves truncation", type0
, type1
);
8133 else if (!integer_only_op
8134 /* Allow integer --> real conversion if safe. */
8135 && (TREE_CODE (type0
) == REAL_TYPE
8136 || TREE_CODE (type0
) == INTEGER_TYPE
)
8137 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (type1
)))
8139 if (unsafe_conversion_p (loc
, TREE_TYPE (type1
), op0
,
8143 error_at (loc
, "conversion of scalar %qT to vector %qT "
8144 "involves truncation", type0
, type1
);
8156 /* Return the alignment of std::max_align_t.
8158 [support.types.layout] The type max_align_t is a POD type whose alignment
8159 requirement is at least as great as that of every scalar type, and whose
8160 alignment requirement is supported in every context. */
8163 max_align_t_align ()
8165 unsigned int max_align
= MAX (TYPE_ALIGN (long_long_integer_type_node
),
8166 TYPE_ALIGN (long_double_type_node
));
8167 if (float128_type_node
!= NULL_TREE
)
8168 max_align
= MAX (max_align
, TYPE_ALIGN (float128_type_node
));
8172 /* Return true iff ALIGN is an integral constant that is a fundamental
8173 alignment, as defined by [basic.align] in the c++-11
8178 [A fundamental alignment is represented by an alignment less than or
8179 equal to the greatest alignment supported by the implementation
8180 in all contexts, which is equal to alignof(max_align_t)]. */
8183 cxx_fundamental_alignment_p (unsigned align
)
8185 return (align
<= max_align_t_align ());
8188 /* Return true if T is a pointer to a zero-sized aggregate. */
8191 pointer_to_zero_sized_aggr_p (tree t
)
8193 if (!POINTER_TYPE_P (t
))
8196 return (TYPE_SIZE (t
) && integer_zerop (TYPE_SIZE (t
)));
8199 /* For an EXPR of a FUNCTION_TYPE that references a GCC built-in function
8200 with no library fallback or for an ADDR_EXPR whose operand is such type
8201 issues an error pointing to the location LOC.
8202 Returns true when the expression has been diagnosed and false
8206 reject_gcc_builtin (const_tree expr
, location_t loc
/* = UNKNOWN_LOCATION */)
8208 if (TREE_CODE (expr
) == ADDR_EXPR
)
8209 expr
= TREE_OPERAND (expr
, 0);
8211 STRIP_ANY_LOCATION_WRAPPER (expr
);
8213 if (TREE_TYPE (expr
)
8214 && TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
8215 && TREE_CODE (expr
) == FUNCTION_DECL
8216 /* The intersection of DECL_BUILT_IN and DECL_IS_BUILTIN avoids
8217 false positives for user-declared built-ins such as abs or
8218 strlen, and for C++ operators new and delete.
8219 The c_decl_implicit() test avoids false positives for implicitly
8220 declared built-ins with library fallbacks (such as abs). */
8221 && fndecl_built_in_p (expr
)
8222 && DECL_IS_BUILTIN (expr
)
8223 && !c_decl_implicit (expr
)
8224 && !DECL_ASSEMBLER_NAME_SET_P (expr
))
8226 if (loc
== UNKNOWN_LOCATION
)
8227 loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
8229 /* Reject arguments that are built-in functions with
8230 no library fallback. */
8231 error_at (loc
, "built-in function %qE must be directly called", expr
);
8239 /* Issue an ERROR for an invalid SIZE of array NAME which is null
8240 for unnamed arrays. */
8243 invalid_array_size_error (location_t loc
, cst_size_error error
,
8244 const_tree size
, const_tree name
)
8246 tree maxsize
= max_object_size ();
8249 case cst_size_not_constant
:
8251 error_at (loc
, "size of array %qE is not a constant expression",
8254 error_at (loc
, "size of array is not a constant expression");
8256 case cst_size_negative
:
8258 error_at (loc
, "size %qE of array %qE is negative",
8261 error_at (loc
, "size %qE of array is negative",
8264 case cst_size_too_big
:
8266 error_at (loc
, "size %qE of array %qE exceeds maximum "
8267 "object size %qE", size
, name
, maxsize
);
8269 error_at (loc
, "size %qE of array exceeds maximum "
8270 "object size %qE", size
, maxsize
);
8272 case cst_size_overflow
:
8274 error_at (loc
, "size of array %qE exceeds maximum "
8275 "object size %qE", name
, maxsize
);
8277 error_at (loc
, "size of array exceeds maximum "
8278 "object size %qE", maxsize
);
8285 /* Check if array size calculations overflow or if the array covers more
8286 than half of the address space. Return true if the size of the array
8287 is valid, false otherwise. T is either the type of the array or its
8288 size, and NAME is the name of the array, or null for unnamed arrays. */
8291 valid_array_size_p (location_t loc
, const_tree t
, tree name
, bool complain
)
8293 if (t
== error_mark_node
)
8299 if (!COMPLETE_TYPE_P (t
))
8301 size
= TYPE_SIZE_UNIT (t
);
8306 if (TREE_CODE (size
) != INTEGER_CST
)
8309 cst_size_error error
;
8310 if (valid_constant_size_p (size
, &error
))
8316 if (TREE_CODE (TREE_TYPE (size
)) == ENUMERAL_TYPE
)
8317 /* Show the value of the enumerator rather than its name. */
8318 size
= convert (ssizetype
, const_cast<tree
> (size
));
8320 invalid_array_size_error (loc
, error
, size
, name
);
8324 /* Read SOURCE_DATE_EPOCH from environment to have a deterministic
8325 timestamp to replace embedded current dates to get reproducible
8326 results. Returns -1 if SOURCE_DATE_EPOCH is not defined. */
8329 cb_get_source_date_epoch (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
8331 char *source_date_epoch
;
8335 source_date_epoch
= getenv ("SOURCE_DATE_EPOCH");
8336 if (!source_date_epoch
)
8340 #if defined(INT64_T_IS_LONG)
8341 epoch
= strtol (source_date_epoch
, &endptr
, 10);
8343 epoch
= strtoll (source_date_epoch
, &endptr
, 10);
8345 if (errno
!= 0 || endptr
== source_date_epoch
|| *endptr
!= '\0'
8346 || epoch
< 0 || epoch
> MAX_SOURCE_DATE_EPOCH
)
8348 error_at (input_location
, "environment variable SOURCE_DATE_EPOCH must "
8349 "expand to a non-negative integer less than or equal to %wd",
8350 MAX_SOURCE_DATE_EPOCH
);
8354 return (time_t) epoch
;
8357 /* Callback for libcpp for offering spelling suggestions for misspelled
8358 directives. GOAL is an unrecognized string; CANDIDATES is a
8359 NULL-terminated array of candidate strings. Return the closest
8360 match to GOAL within CANDIDATES, or NULL if none are good
8364 cb_get_suggestion (cpp_reader
*, const char *goal
,
8365 const char *const *candidates
)
8367 best_match
<const char *, const char *> bm (goal
);
8369 bm
.consider (*candidates
++);
8370 return bm
.get_best_meaningful_candidate ();
8373 /* Return the latice point which is the wider of the two FLT_EVAL_METHOD
8374 modes X, Y. This isn't just >, as the FLT_EVAL_METHOD values added
8375 by C TS 18661-3 for interchange types that are computed in their
8376 native precision are larger than the C11 values for evaluating in the
8377 precision of float/double/long double. If either mode is
8378 FLT_EVAL_METHOD_UNPREDICTABLE, return that. */
8380 enum flt_eval_method
8381 excess_precision_mode_join (enum flt_eval_method x
,
8382 enum flt_eval_method y
)
8384 if (x
== FLT_EVAL_METHOD_UNPREDICTABLE
8385 || y
== FLT_EVAL_METHOD_UNPREDICTABLE
)
8386 return FLT_EVAL_METHOD_UNPREDICTABLE
;
8388 /* GCC only supports one interchange type right now, _Float16. If
8389 we're evaluating _Float16 in 16-bit precision, then flt_eval_method
8390 will be FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */
8391 if (x
== FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
)
8393 if (y
== FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
)
8396 /* Other values for flt_eval_method are directly comparable, and we want
8401 /* Return the value that should be set for FLT_EVAL_METHOD in the
8402 context of ISO/IEC TS 18861-3.
8404 This relates to the effective excess precision seen by the user,
8405 which is the join point of the precision the target requests for
8406 -fexcess-precision={standard,fast} and the implicit excess precision
8409 static enum flt_eval_method
8410 c_ts18661_flt_eval_method (void)
8412 enum flt_eval_method implicit
8413 = targetm
.c
.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT
);
8415 enum excess_precision_type flag_type
8416 = (flag_excess_precision_cmdline
== EXCESS_PRECISION_STANDARD
8417 ? EXCESS_PRECISION_TYPE_STANDARD
8418 : EXCESS_PRECISION_TYPE_FAST
);
8420 enum flt_eval_method requested
8421 = targetm
.c
.excess_precision (flag_type
);
8423 return excess_precision_mode_join (implicit
, requested
);
8426 /* As c_cpp_ts18661_flt_eval_method, but clamps the expected values to
8427 those that were permitted by C11. That is to say, eliminates
8428 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */
8430 static enum flt_eval_method
8431 c_c11_flt_eval_method (void)
8433 return excess_precision_mode_join (c_ts18661_flt_eval_method (),
8434 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
);
8437 /* Return the value that should be set for FLT_EVAL_METHOD.
8438 MAYBE_C11_ONLY_P is TRUE if we should check
8439 FLAG_PERMITTED_EVAL_METHODS as to whether we should limit the possible
8440 values we can return to those from C99/C11, and FALSE otherwise.
8441 See the comments on c_ts18661_flt_eval_method for what value we choose
8445 c_flt_eval_method (bool maybe_c11_only_p
)
8447 if (maybe_c11_only_p
8448 && flag_permitted_flt_eval_methods
8449 == PERMITTED_FLT_EVAL_METHODS_C11
)
8450 return c_c11_flt_eval_method ();
8452 return c_ts18661_flt_eval_method ();
8455 /* An enum for get_missing_token_insertion_kind for describing the best
8456 place to insert a missing token, if there is one. */
8458 enum missing_token_insertion_kind
8461 MTIK_INSERT_BEFORE_NEXT
,
8462 MTIK_INSERT_AFTER_PREV
8465 /* Given a missing token of TYPE, determine if it is reasonable to
8466 emit a fix-it hint suggesting the insertion of the token, and,
8467 if so, where the token should be inserted relative to other tokens.
8469 It only makes sense to do this for values of TYPE that are symbols.
8471 Some symbols should go before the next token, e.g. in:
8473 we want to insert the missing '(' immediately before "flag",
8478 These use MTIK_INSERT_BEFORE_NEXT.
8480 Other symbols should go after the previous token, e.g. in:
8483 we want to insert the missing ')' immediately after the "flag",
8490 These use MTIK_INSERT_AFTER_PREV. */
8492 static enum missing_token_insertion_kind
8493 get_missing_token_insertion_kind (enum cpp_ttype type
)
8497 /* Insert missing "opening" brackets immediately
8498 before the next token. */
8499 case CPP_OPEN_SQUARE
:
8500 case CPP_OPEN_PAREN
:
8501 return MTIK_INSERT_BEFORE_NEXT
;
8503 /* Insert other missing symbols immediately after
8504 the previous token. */
8505 case CPP_CLOSE_PAREN
:
8506 case CPP_CLOSE_SQUARE
:
8510 return MTIK_INSERT_AFTER_PREV
;
8512 /* Other kinds of token don't get fix-it hints. */
8514 return MTIK_IMPOSSIBLE
;
8518 /* Given RICHLOC, a location for a diagnostic describing a missing token
8519 of kind TOKEN_TYPE, potentially add a fix-it hint suggesting the
8520 insertion of the token.
8522 The location of the attempted fix-it hint depends on TOKEN_TYPE:
8524 (a) immediately after PREV_TOKEN_LOC, or
8526 (b) immediately before the primary location within RICHLOC (taken to
8527 be that of the token following where the token was expected).
8529 If we manage to add a fix-it hint, then the location of the
8530 fix-it hint is likely to be more useful as the primary location
8531 of the diagnostic than that of the following token, so we swap
8534 For example, given this bogus code:
8535 123456789012345678901234567890
8536 1 | int missing_semicolon (void)
8543 "expected ';' before '}'"
8545 RICHLOC's primary location is at the closing brace, so before "swapping"
8546 we would emit the error at line 4 column 1:
8548 123456789012345678901234567890
8549 3 | return 42 |< fix-it hint emitted for this line
8551 4 | } |< "expected ';' before '}'" emitted at this line
8554 It's more useful for the location of the diagnostic to be at the
8555 fix-it hint, so we swap the locations, so the primary location
8556 is at the fix-it hint, with the old primary location inserted
8557 as a secondary location, giving this, with the error at line 3
8560 123456789012345678901234567890
8561 3 | return 42 |< "expected ';' before '}'" emitted at this line,
8562 | ^ | with fix-it hint
8564 | } |< secondary range emitted here
8568 maybe_suggest_missing_token_insertion (rich_location
*richloc
,
8569 enum cpp_ttype token_type
,
8570 location_t prev_token_loc
)
8572 gcc_assert (richloc
);
8574 enum missing_token_insertion_kind mtik
8575 = get_missing_token_insertion_kind (token_type
);
8583 case MTIK_IMPOSSIBLE
:
8586 case MTIK_INSERT_BEFORE_NEXT
:
8587 /* Attempt to add the fix-it hint before the primary location
8589 richloc
->add_fixit_insert_before (cpp_type2name (token_type
, 0));
8592 case MTIK_INSERT_AFTER_PREV
:
8593 /* Attempt to add the fix-it hint after PREV_TOKEN_LOC. */
8594 richloc
->add_fixit_insert_after (prev_token_loc
,
8595 cpp_type2name (token_type
, 0));
8599 /* If we were successful, use the fix-it hint's location as the
8600 primary location within RICHLOC, adding the old primary location
8601 back as a secondary location. */
8602 if (!richloc
->seen_impossible_fixit_p ())
8604 fixit_hint
*hint
= richloc
->get_last_fixit_hint ();
8605 location_t hint_loc
= hint
->get_start_loc ();
8606 location_t old_loc
= richloc
->get_loc ();
8608 richloc
->set_range (0, hint_loc
, SHOW_RANGE_WITH_CARET
);
8609 richloc
->add_range (old_loc
);
8615 namespace selftest
{
8617 /* Verify that fold_for_warn on error_mark_node is safe. */
8620 test_fold_for_warn ()
8622 ASSERT_EQ (error_mark_node
, fold_for_warn (error_mark_node
));
8625 /* Run all of the selftests within this file. */
8630 test_fold_for_warn ();
8633 /* Run all of the tests within c-family. */
8636 c_family_tests (void)
8638 c_common_c_tests ();
8639 c_format_c_tests ();
8640 c_indentation_c_tests ();
8641 c_pretty_print_c_tests ();
8642 c_spellcheck_cc_tests ();
8645 } // namespace selftest
8647 #endif /* #if CHECKING_P */
8649 /* Attempt to locate a suitable location within FILE for a
8650 #include directive to be inserted before. FILE should
8651 be a string from libcpp (pointer equality is used).
8652 LOC is the location of the relevant diagnostic.
8654 Attempt to return the location within FILE immediately
8655 after the last #include within that file, or the start of
8656 that file if it has no #include directives.
8658 Return UNKNOWN_LOCATION if no suitable location is found,
8659 or if an error occurs. */
8662 try_to_locate_new_include_insertion_point (const char *file
, location_t loc
)
8664 /* Locate the last ordinary map within FILE that ended with a #include. */
8665 const line_map_ordinary
*last_include_ord_map
= NULL
;
8667 /* ...and the next ordinary map within FILE after that one. */
8668 const line_map_ordinary
*last_ord_map_after_include
= NULL
;
8670 /* ...and the first ordinary map within FILE. */
8671 const line_map_ordinary
*first_ord_map_in_file
= NULL
;
8673 /* Get ordinary map containing LOC (or its expansion). */
8674 const line_map_ordinary
*ord_map_for_loc
= NULL
;
8675 loc
= linemap_resolve_location (line_table
, loc
, LRK_MACRO_EXPANSION_POINT
,
8677 gcc_assert (ord_map_for_loc
);
8679 for (unsigned int i
= 0; i
< LINEMAPS_ORDINARY_USED (line_table
); i
++)
8681 const line_map_ordinary
*ord_map
8682 = LINEMAPS_ORDINARY_MAP_AT (line_table
, i
);
8684 if (const line_map_ordinary
*from
8685 = linemap_included_from_linemap (line_table
, ord_map
))
8686 if (from
->to_file
== file
)
8688 last_include_ord_map
= from
;
8689 last_ord_map_after_include
= NULL
;
8692 if (ord_map
->to_file
== file
)
8694 if (!first_ord_map_in_file
)
8695 first_ord_map_in_file
= ord_map
;
8696 if (last_include_ord_map
&& !last_ord_map_after_include
)
8697 last_ord_map_after_include
= ord_map
;
8700 /* Stop searching when reaching the ord_map containing LOC,
8701 as it makes no sense to provide fix-it hints that appear
8702 after the diagnostic in question. */
8703 if (ord_map
== ord_map_for_loc
)
8707 /* Determine where to insert the #include. */
8708 const line_map_ordinary
*ord_map_for_insertion
;
8710 /* We want the next ordmap in the file after the last one that's a
8711 #include, but failing that, the start of the file. */
8712 if (last_ord_map_after_include
)
8713 ord_map_for_insertion
= last_ord_map_after_include
;
8715 ord_map_for_insertion
= first_ord_map_in_file
;
8717 if (!ord_map_for_insertion
)
8718 return UNKNOWN_LOCATION
;
8720 /* The "start_location" is column 0, meaning "the whole line".
8721 rich_location and edit_context can't cope with this, so use
8722 column 1 instead. */
8723 location_t col_0
= ord_map_for_insertion
->start_location
;
8724 return linemap_position_for_loc_and_offset (line_table
, col_0
, 1);
8727 /* A map from filenames to sets of headers added to them, for
8728 ensuring idempotency within maybe_add_include_fixit. */
8730 /* The values within the map. We need string comparison as there's
8731 no guarantee that two different diagnostics that are recommending
8732 adding e.g. "<stdio.h>" are using the same buffer. */
8734 typedef hash_set
<const char *, nofree_string_hash
> per_file_includes_t
;
8736 /* The map itself. We don't need string comparison for the filename keys,
8737 as they come from libcpp. */
8739 typedef hash_map
<const char *, per_file_includes_t
*> added_includes_t
;
8740 static added_includes_t
*added_includes
;
8742 /* Attempt to add a fix-it hint to RICHLOC, adding "#include HEADER\n"
8743 in a suitable location within the file of RICHLOC's primary
8746 This function is idempotent: a header will be added at most once to
8749 If OVERRIDE_LOCATION is true, then if a fix-it is added and will be
8750 printed, then RICHLOC's primary location will be replaced by that of
8751 the fix-it hint (for use by "inform" notes where the location of the
8752 issue has already been reported). */
8755 maybe_add_include_fixit (rich_location
*richloc
, const char *header
,
8756 bool override_location
)
8758 location_t loc
= richloc
->get_loc ();
8759 const char *file
= LOCATION_FILE (loc
);
8763 /* Idempotency: don't add the same header more than once to a given file. */
8764 if (!added_includes
)
8765 added_includes
= new added_includes_t ();
8766 per_file_includes_t
*&set
= added_includes
->get_or_insert (file
);
8768 if (set
->contains (header
))
8769 /* ...then we've already added HEADER to that file. */
8772 set
= new per_file_includes_t ();
8775 /* Attempt to locate a suitable place for the new directive. */
8776 location_t include_insert_loc
8777 = try_to_locate_new_include_insertion_point (file
, loc
);
8778 if (include_insert_loc
== UNKNOWN_LOCATION
)
8781 char *text
= xasprintf ("#include %s\n", header
);
8782 richloc
->add_fixit_insert_before (include_insert_loc
, text
);
8785 if (override_location
&& global_dc
->show_caret
)
8787 /* Replace the primary location with that of the insertion point for the
8790 We use SHOW_LINES_WITHOUT_RANGE so that we don't meaningless print a
8791 caret for the insertion point (or colorize it).
8793 Hence we print e.g.:
8795 ../x86_64-pc-linux-gnu/libstdc++-v3/include/vector:74:1: note: msg 2
8796 73 | # include <debug/vector>
8797 +++ |+#include <vector>
8802 ../x86_64-pc-linux-gnu/libstdc++-v3/include/vector:74:1: note: msg 2
8803 73 | # include <debug/vector>
8804 +++ |+#include <vector>
8808 avoiding the caret on the first column of line 74. */
8809 richloc
->set_range (0, include_insert_loc
, SHOW_LINES_WITHOUT_RANGE
);
8813 /* Attempt to convert a braced array initializer list CTOR for array
8814 TYPE into a STRING_CST for convenience and efficiency. Return
8815 the converted string on success or the original ctor on failure. */
8818 braced_list_to_string (tree type
, tree ctor
)
8820 if (!tree_fits_uhwi_p (TYPE_SIZE_UNIT (type
)))
8823 /* If the array has an explicit bound, use it to constrain the size
8824 of the string. If it doesn't, be sure to create a string that's
8825 as long as implied by the index of the last zero specified via
8826 a designator, as in:
8827 const char a[] = { [7] = 0 }; */
8828 unsigned HOST_WIDE_INT maxelts
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
8829 maxelts
/= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (type
)));
8831 /* Avoid converting initializers for zero-length arrays. */
8835 unsigned HOST_WIDE_INT nelts
= CONSTRUCTOR_NELTS (ctor
);
8838 str
.reserve (nelts
+ 1);
8840 unsigned HOST_WIDE_INT i
;
8843 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), i
, index
, value
)
8845 unsigned HOST_WIDE_INT idx
= i
;
8848 if (!tree_fits_uhwi_p (index
))
8850 idx
= tree_to_uhwi (index
);
8853 /* auto_vec is limited to UINT_MAX elements. */
8857 /* Avoid non-constant initializers. */
8858 if (!tree_fits_shwi_p (value
))
8861 /* Skip over embedded nuls except the last one (initializer
8862 elements are in ascending order of indices). */
8863 HOST_WIDE_INT val
= tree_to_shwi (value
);
8864 if (!val
&& i
+ 1 < nelts
)
8867 if (idx
< str
.length())
8870 /* Bail if the CTOR has a block of more than 256 embedded nuls
8871 due to implicitly initialized elements. */
8872 unsigned nchars
= (idx
- str
.length ()) + 1;
8879 str
.quick_grow_cleared (idx
);
8885 str
.safe_insert (idx
, val
);
8888 /* Append a nul string termination. */
8889 if (str
.length () < maxelts
)
8892 /* Build a STRING_CST with the same type as the array. */
8893 tree res
= build_string (str
.length (), str
.begin ());
8894 TREE_TYPE (res
) = type
;
8898 #include "gt-c-family-c-common.h"