1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992-2022 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"
51 #include "c-spellcheck.h"
54 #include "tree-vector-builder.h"
55 #include "vec-perm-indices.h"
57 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
59 /* Mode used to build pointers (VOIDmode means ptr_mode). */
61 machine_mode c_default_pointer_mode
= VOIDmode
;
63 /* The following symbols are subsumed in the c_global_trees array, and
64 listed here individually for documentation purposes.
66 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
68 tree short_integer_type_node;
69 tree long_integer_type_node;
70 tree long_long_integer_type_node;
72 tree short_unsigned_type_node;
73 tree long_unsigned_type_node;
74 tree long_long_unsigned_type_node;
76 tree truthvalue_type_node;
77 tree truthvalue_false_node;
78 tree truthvalue_true_node;
80 tree ptrdiff_type_node;
82 tree unsigned_char_type_node;
83 tree signed_char_type_node;
87 tree char16_type_node;
88 tree char32_type_node;
91 tree double_type_node;
92 tree long_double_type_node;
94 tree complex_integer_type_node;
95 tree complex_float_type_node;
96 tree complex_double_type_node;
97 tree complex_long_double_type_node;
99 tree dfloat32_type_node;
100 tree dfloat64_type_node;
101 tree_dfloat128_type_node;
103 tree intQI_type_node;
104 tree intHI_type_node;
105 tree intSI_type_node;
106 tree intDI_type_node;
107 tree intTI_type_node;
109 tree unsigned_intQI_type_node;
110 tree unsigned_intHI_type_node;
111 tree unsigned_intSI_type_node;
112 tree unsigned_intDI_type_node;
113 tree unsigned_intTI_type_node;
115 tree widest_integer_literal_type_node;
116 tree widest_unsigned_literal_type_node;
118 Nodes for types `void *' and `const void *'.
120 tree ptr_type_node, const_ptr_type_node;
122 Nodes for types `char *' and `const char *'.
124 tree string_type_node, const_string_type_node;
126 Type `char[SOMENUMBER]'.
127 Used when an array of char is needed and the size is irrelevant.
129 tree char_array_type_node;
131 Type `wchar_t[SOMENUMBER]' or something like it.
132 Used when a wide string literal is created.
134 tree wchar_array_type_node;
136 Type `char8_t[SOMENUMBER]' or something like it.
137 Used when a UTF-8 string literal is created.
139 tree char8_array_type_node;
141 Type `char16_t[SOMENUMBER]' or something like it.
142 Used when a UTF-16 string literal is created.
144 tree char16_array_type_node;
146 Type `char32_t[SOMENUMBER]' or something like it.
147 Used when a UTF-32 string literal is created.
149 tree char32_array_type_node;
151 Type `int ()' -- used for implicit declaration of functions.
153 tree default_function_type;
155 A VOID_TYPE node, packaged in a TREE_LIST.
159 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
160 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
161 VAR_DECLS, but C++ does.)
163 tree function_name_decl_node;
164 tree pretty_function_name_decl_node;
165 tree c99_function_name_decl_node;
167 Stack of nested function name VAR_DECLs.
169 tree saved_function_name_decls;
173 tree c_global_trees
[CTI_MAX
];
175 /* Switches common to the C front ends. */
177 /* Nonzero means don't output line number information. */
179 char flag_no_line_commands
;
181 /* Nonzero causes -E output not to be done, but directives such as
182 #define that have side effects are still obeyed. */
186 /* Nonzero means dump macros in some fashion. */
188 char flag_dump_macros
;
190 /* Nonzero means pass #include lines through to the output. */
192 char flag_dump_includes
;
194 /* Nonzero means process PCH files while preprocessing. */
196 bool flag_pch_preprocess
;
198 /* The file name to which we should write a precompiled header, or
199 NULL if no header will be written in this compile. */
201 const char *pch_file
;
203 /* Nonzero if an ISO standard was selected. It rejects macros in the
207 /* C/ObjC language option variables. */
210 /* Nonzero means allow type mismatches in conditional expressions;
211 just make their values `void'. */
213 int flag_cond_mismatch
;
215 /* Nonzero means enable C89 Amendment 1 features. */
219 /* Nonzero means use the ISO C99 (or C11) dialect of C. */
223 /* Nonzero means use the ISO C11 dialect of C. */
227 /* Nonzero means use the ISO C2X dialect of C. */
231 /* Nonzero means that we have builtin functions, and main is an int. */
236 /* ObjC language option variables. */
239 /* Tells the compiler that this is a special run. Do not perform any
240 compiling, instead we are to test some platform dependent features
241 and output a C header file with appropriate definitions. */
243 int print_struct_values
;
245 /* Tells the compiler what is the constant string class for ObjC. */
247 const char *constant_string_class_name
;
250 /* C++ language option variables. */
252 /* The reference version of the ABI for -Wabi. */
254 int warn_abi_version
= -1;
256 /* The C++ dialect being used. Default set in c_common_post_options. */
258 enum cxx_dialect cxx_dialect
= cxx_unset
;
260 /* Maximum template instantiation depth. This limit exists to limit the
261 time it takes to notice excessively recursive template instantiations.
263 The default is lower than the 1024 recommended by the C++0x standard
264 because G++ runs out of stack before 1024 with highly recursive template
265 argument deduction substitution (g++.dg/cpp0x/enum11.C). */
267 int max_tinst_depth
= 900;
269 /* The elements of `ridpointers' are identifier nodes for the reserved
270 type names and storage classes. It is indexed by a RID_... value. */
273 tree (*make_fname_decl
) (location_t
, tree
, int);
275 /* Nonzero means don't warn about problems that occur when the code is
277 int c_inhibit_evaluation_warnings
;
279 /* Whether we are building a boolean conversion inside
280 convert_for_assignment, or some other late binary operation. If
281 build_binary_op is called for C (from code shared by C and C++) in
282 this case, then the operands have already been folded and the
283 result will not be folded again, so C_MAYBE_CONST_EXPR should not
285 bool in_late_binary_op
;
287 /* Depending on which phase of processing we are in, we may need
288 to prefer input_location to libcpp's locations. (Specifically,
289 after the C++ lexer is done lexing tokens, but prior to calling
290 cpp_finish (), we need to do so. */
291 bool override_libcpp_locations
;
293 /* Information about how a function name is generated. */
296 tree
*const decl
; /* pointer to the VAR_DECL. */
297 const unsigned rid
; /* RID number for the identifier. */
298 const int pretty
; /* How pretty is it? */
301 /* The three ways of getting then name of the current function. */
303 const struct fname_var_t fname_vars
[] =
305 /* C99 compliant __func__, must be first. */
306 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
307 /* GCC __FUNCTION__ compliant. */
308 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
309 /* GCC __PRETTY_FUNCTION__ compliant. */
310 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
314 /* Global visibility options. */
315 struct visibility_flags visibility_options
;
317 static tree
check_case_value (location_t
, tree
);
320 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
321 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
323 /* Reserved words. The third field is a mask: keywords are disabled
324 if they match the mask.
327 C --std=c89: D_C99 | D_C2X | D_CXXONLY | D_OBJC | D_CXX_OBJC
328 C --std=c99: D_C2X | D_CXXONLY | D_OBJC
329 C --std=c17: D_C2X | D_CXXONLY | D_OBJC
330 C --std=c2x: D_CXXONLY | D_OBJC
331 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
332 C++ --std=c++98: D_CONLY | D_CXX11 | D_CXX20 | D_OBJC
333 C++ --std=c++11: D_CONLY | D_CXX20 | D_OBJC
334 C++ --std=c++20: D_CONLY | D_OBJC
335 ObjC++ is like C++ except that D_OBJC is not set
337 If -fno-asm is used, D_ASM is added to the mask. If
338 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
339 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
340 In C with -Wc++-compat, we warn if D_CXXWARN is set.
342 Note the complication of the D_CXX_OBJC keywords. These are
343 reserved words such as 'class'. In C++, 'class' is a reserved
344 word. In Objective-C++ it is too. In Objective-C, it is a
345 reserved word too, but only if it follows an '@' sign.
347 const struct c_common_resword c_common_reswords
[] =
349 { "_Alignas", RID_ALIGNAS
, D_CONLY
},
350 { "_Alignof", RID_ALIGNOF
, D_CONLY
},
351 { "_Atomic", RID_ATOMIC
, D_CONLY
},
352 { "_Bool", RID_BOOL
, D_CONLY
},
353 { "_Complex", RID_COMPLEX
, 0 },
354 { "_Imaginary", RID_IMAGINARY
, D_CONLY
},
355 { "_Float16", RID_FLOAT16
, 0 },
356 { "_Float32", RID_FLOAT32
, 0 },
357 { "_Float64", RID_FLOAT64
, 0 },
358 { "_Float128", RID_FLOAT128
, 0 },
359 { "_Float32x", RID_FLOAT32X
, 0 },
360 { "_Float64x", RID_FLOAT64X
, 0 },
361 { "_Float128x", RID_FLOAT128X
, 0 },
362 { "_Decimal32", RID_DFLOAT32
, D_CONLY
},
363 { "_Decimal64", RID_DFLOAT64
, D_CONLY
},
364 { "_Decimal128", RID_DFLOAT128
, D_CONLY
},
365 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
366 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
367 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
368 { "_Static_assert", RID_STATIC_ASSERT
, D_CONLY
},
369 { "_Noreturn", RID_NORETURN
, D_CONLY
},
370 { "_Generic", RID_GENERIC
, D_CONLY
},
371 { "_Thread_local", RID_THREAD
, D_CONLY
},
372 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
373 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
374 { "__alignof", RID_ALIGNOF
, 0 },
375 { "__alignof__", RID_ALIGNOF
, 0 },
376 { "__asm", RID_ASM
, 0 },
377 { "__asm__", RID_ASM
, 0 },
378 { "__attribute", RID_ATTRIBUTE
, 0 },
379 { "__attribute__", RID_ATTRIBUTE
, 0 },
380 { "__auto_type", RID_AUTO_TYPE
, D_CONLY
},
381 { "__bases", RID_BASES
, D_CXXONLY
},
382 { "__builtin_addressof", RID_ADDRESSOF
, D_CXXONLY
},
383 { "__builtin_bit_cast", RID_BUILTIN_BIT_CAST
, D_CXXONLY
},
384 { "__builtin_call_with_static_chain",
385 RID_BUILTIN_CALL_WITH_STATIC_CHAIN
, D_CONLY
},
386 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
387 { "__builtin_complex", RID_BUILTIN_COMPLEX
, D_CONLY
},
388 { "__builtin_convertvector", RID_BUILTIN_CONVERTVECTOR
, 0 },
389 { "__builtin_has_attribute", RID_BUILTIN_HAS_ATTRIBUTE
, 0 },
390 { "__builtin_launder", RID_BUILTIN_LAUNDER
, D_CXXONLY
},
391 { "__builtin_assoc_barrier", RID_BUILTIN_ASSOC_BARRIER
, 0 },
392 { "__builtin_shuffle", RID_BUILTIN_SHUFFLE
, 0 },
393 { "__builtin_shufflevector", RID_BUILTIN_SHUFFLEVECTOR
, 0 },
394 { "__builtin_tgmath", RID_BUILTIN_TGMATH
, D_CONLY
},
395 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
396 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
397 { "__builtin_va_arg", RID_VA_ARG
, 0 },
398 { "__complex", RID_COMPLEX
, 0 },
399 { "__complex__", RID_COMPLEX
, 0 },
400 { "__const", RID_CONST
, 0 },
401 { "__const__", RID_CONST
, 0 },
402 { "__constinit", RID_CONSTINIT
, D_CXXONLY
},
403 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
404 { "__direct_bases", RID_DIRECT_BASES
, D_CXXONLY
},
405 { "__extension__", RID_EXTENSION
, 0 },
406 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
407 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
408 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
409 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
410 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
411 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
412 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
413 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
414 { "__has_unique_object_representations", RID_HAS_UNIQUE_OBJ_REPRESENTATIONS
,
416 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
417 { "__imag", RID_IMAGPART
, 0 },
418 { "__imag__", RID_IMAGPART
, 0 },
419 { "__inline", RID_INLINE
, 0 },
420 { "__inline__", RID_INLINE
, 0 },
421 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
422 { "__is_aggregate", RID_IS_AGGREGATE
, D_CXXONLY
},
423 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
424 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
425 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
426 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
427 { "__is_final", RID_IS_FINAL
, D_CXXONLY
},
428 { "__is_layout_compatible", RID_IS_LAYOUT_COMPATIBLE
, D_CXXONLY
},
429 { "__is_literal_type", RID_IS_LITERAL_TYPE
, D_CXXONLY
},
430 { "__is_pointer_interconvertible_base_of",
431 RID_IS_POINTER_INTERCONVERTIBLE_BASE_OF
, D_CXXONLY
},
432 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
433 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
434 { "__is_same", RID_IS_SAME_AS
, D_CXXONLY
},
435 { "__is_same_as", RID_IS_SAME_AS
, D_CXXONLY
},
436 { "__is_standard_layout", RID_IS_STD_LAYOUT
, D_CXXONLY
},
437 { "__is_trivial", RID_IS_TRIVIAL
, D_CXXONLY
},
438 { "__is_trivially_assignable", RID_IS_TRIVIALLY_ASSIGNABLE
, D_CXXONLY
},
439 { "__is_trivially_constructible", RID_IS_TRIVIALLY_CONSTRUCTIBLE
, D_CXXONLY
},
440 { "__is_trivially_copyable", RID_IS_TRIVIALLY_COPYABLE
, D_CXXONLY
},
441 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
442 { "__label__", RID_LABEL
, 0 },
443 { "__null", RID_NULL
, 0 },
444 { "__real", RID_REALPART
, 0 },
445 { "__real__", RID_REALPART
, 0 },
446 { "__restrict", RID_RESTRICT
, 0 },
447 { "__restrict__", RID_RESTRICT
, 0 },
448 { "__signed", RID_SIGNED
, 0 },
449 { "__signed__", RID_SIGNED
, 0 },
450 { "__thread", RID_THREAD
, 0 },
451 { "__transaction_atomic", RID_TRANSACTION_ATOMIC
, 0 },
452 { "__transaction_relaxed", RID_TRANSACTION_RELAXED
, 0 },
453 { "__transaction_cancel", RID_TRANSACTION_CANCEL
, 0 },
454 { "__typeof", RID_TYPEOF
, 0 },
455 { "__typeof__", RID_TYPEOF
, 0 },
456 { "__underlying_type", RID_UNDERLYING_TYPE
, D_CXXONLY
},
457 { "__volatile", RID_VOLATILE
, 0 },
458 { "__volatile__", RID_VOLATILE
, 0 },
459 { "__GIMPLE", RID_GIMPLE
, D_CONLY
},
460 { "__PHI", RID_PHI
, D_CONLY
},
461 { "__RTL", RID_RTL
, D_CONLY
},
462 { "alignas", RID_ALIGNAS
, D_C2X
| D_CXX11
| D_CXXWARN
},
463 { "alignof", RID_ALIGNOF
, D_C2X
| D_CXX11
| D_CXXWARN
},
464 { "asm", RID_ASM
, D_ASM
},
465 { "auto", RID_AUTO
, 0 },
466 { "bool", RID_BOOL
, D_C2X
| D_CXXWARN
},
467 { "break", RID_BREAK
, 0 },
468 { "case", RID_CASE
, 0 },
469 { "catch", RID_CATCH
, D_CXX_OBJC
| D_CXXWARN
},
470 { "char", RID_CHAR
, 0 },
471 { "char8_t", RID_CHAR8
, D_CXX_CHAR8_T_FLAGS
| D_CXXWARN
},
472 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
473 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
474 { "class", RID_CLASS
, D_CXX_OBJC
| D_CXXWARN
},
475 { "const", RID_CONST
, 0 },
476 { "consteval", RID_CONSTEVAL
, D_CXXONLY
| D_CXX20
| D_CXXWARN
},
477 { "constexpr", RID_CONSTEXPR
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
478 { "constinit", RID_CONSTINIT
, D_CXXONLY
| D_CXX20
| D_CXXWARN
},
479 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
480 { "continue", RID_CONTINUE
, 0 },
481 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
482 { "default", RID_DEFAULT
, 0 },
483 { "delete", RID_DELETE
, D_CXXONLY
| D_CXXWARN
},
485 { "double", RID_DOUBLE
, 0 },
486 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
487 { "else", RID_ELSE
, 0 },
488 { "enum", RID_ENUM
, 0 },
489 { "explicit", RID_EXPLICIT
, D_CXXONLY
| D_CXXWARN
},
490 { "export", RID_EXPORT
, D_CXXONLY
| D_CXXWARN
},
491 { "extern", RID_EXTERN
, 0 },
492 { "false", RID_FALSE
, D_C2X
| D_CXXWARN
},
493 { "float", RID_FLOAT
, 0 },
494 { "for", RID_FOR
, 0 },
495 { "friend", RID_FRIEND
, D_CXXONLY
| D_CXXWARN
},
496 { "goto", RID_GOTO
, 0 },
498 { "inline", RID_INLINE
, D_EXT89
},
499 { "int", RID_INT
, 0 },
500 { "long", RID_LONG
, 0 },
501 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
502 { "namespace", RID_NAMESPACE
, D_CXXONLY
| D_CXXWARN
},
503 { "new", RID_NEW
, D_CXXONLY
| D_CXXWARN
},
504 { "noexcept", RID_NOEXCEPT
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
505 { "nullptr", RID_NULLPTR
, D_C2X
| D_CXX11
| D_CXXWARN
},
506 { "operator", RID_OPERATOR
, D_CXXONLY
| D_CXXWARN
},
507 { "private", RID_PRIVATE
, D_CXX_OBJC
| D_CXXWARN
},
508 { "protected", RID_PROTECTED
, D_CXX_OBJC
| D_CXXWARN
},
509 { "public", RID_PUBLIC
, D_CXX_OBJC
| D_CXXWARN
},
510 { "register", RID_REGISTER
, 0 },
511 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
512 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
513 { "return", RID_RETURN
, 0 },
514 { "short", RID_SHORT
, 0 },
515 { "signed", RID_SIGNED
, 0 },
516 { "sizeof", RID_SIZEOF
, 0 },
517 { "static", RID_STATIC
, 0 },
518 { "static_assert", RID_STATIC_ASSERT
, D_C2X
| D_CXX11
| D_CXXWARN
},
519 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
520 { "struct", RID_STRUCT
, 0 },
521 { "switch", RID_SWITCH
, 0 },
522 { "template", RID_TEMPLATE
, D_CXXONLY
| D_CXXWARN
},
523 { "this", RID_THIS
, D_CXXONLY
| D_CXXWARN
},
524 { "thread_local", RID_THREAD
, D_C2X
| D_CXX11
| D_CXXWARN
},
525 { "throw", RID_THROW
, D_CXX_OBJC
| D_CXXWARN
},
526 { "true", RID_TRUE
, D_C2X
| D_CXXWARN
},
527 { "try", RID_TRY
, D_CXX_OBJC
| D_CXXWARN
},
528 { "typedef", RID_TYPEDEF
, 0 },
529 { "typename", RID_TYPENAME
, D_CXXONLY
| D_CXXWARN
},
530 { "typeid", RID_TYPEID
, D_CXXONLY
| D_CXXWARN
},
531 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
532 { "union", RID_UNION
, 0 },
533 { "unsigned", RID_UNSIGNED
, 0 },
534 { "using", RID_USING
, D_CXXONLY
| D_CXXWARN
},
535 { "virtual", RID_VIRTUAL
, D_CXXONLY
| D_CXXWARN
},
536 { "void", RID_VOID
, 0 },
537 { "volatile", RID_VOLATILE
, 0 },
538 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
539 { "while", RID_WHILE
, 0 },
540 { "__is_assignable", RID_IS_ASSIGNABLE
, D_CXXONLY
},
541 { "__is_constructible", RID_IS_CONSTRUCTIBLE
, D_CXXONLY
},
542 { "__is_nothrow_assignable", RID_IS_NOTHROW_ASSIGNABLE
, D_CXXONLY
},
543 { "__is_nothrow_constructible", RID_IS_NOTHROW_CONSTRUCTIBLE
, D_CXXONLY
},
544 { "__is_convertible", RID_IS_CONVERTIBLE
, D_CXXONLY
},
545 { "__is_nothrow_convertible", RID_IS_NOTHROW_CONVERTIBLE
, D_CXXONLY
},
546 { "__reference_constructs_from_temporary", RID_REF_CONSTRUCTS_FROM_TEMPORARY
,
548 { "__reference_converts_from_temporary", RID_REF_CONVERTS_FROM_TEMPORARY
,
551 /* C++ transactional memory. */
552 { "synchronized", RID_SYNCHRONIZED
, D_CXX_OBJC
| D_TRANSMEM
},
553 { "atomic_noexcept", RID_ATOMIC_NOEXCEPT
, D_CXXONLY
| D_TRANSMEM
},
554 { "atomic_cancel", RID_ATOMIC_CANCEL
, D_CXXONLY
| D_TRANSMEM
},
555 { "atomic_commit", RID_TRANSACTION_ATOMIC
, D_CXXONLY
| D_TRANSMEM
},
557 /* Concepts-related keywords */
558 { "concept", RID_CONCEPT
, D_CXX_CONCEPTS_FLAGS
| D_CXXWARN
},
559 { "requires", RID_REQUIRES
, D_CXX_CONCEPTS_FLAGS
| D_CXXWARN
},
561 /* Modules-related keywords, these are internal unspellable tokens,
562 created by the preprocessor. */
563 { "module ", RID__MODULE
, D_CXX_MODULES_FLAGS
| D_CXXWARN
},
564 { "import ", RID__IMPORT
, D_CXX_MODULES_FLAGS
| D_CXXWARN
},
565 { "export ", RID__EXPORT
, D_CXX_MODULES_FLAGS
| D_CXXWARN
},
567 /* Coroutines-related keywords */
568 { "co_await", RID_CO_AWAIT
, D_CXX_COROUTINES_FLAGS
| D_CXXWARN
},
569 { "co_yield", RID_CO_YIELD
, D_CXX_COROUTINES_FLAGS
| D_CXXWARN
},
570 { "co_return", RID_CO_RETURN
, D_CXX_COROUTINES_FLAGS
| D_CXXWARN
},
572 /* These Objective-C keywords are recognized only immediately after
574 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
575 { "defs", RID_AT_DEFS
, D_OBJC
},
576 { "encode", RID_AT_ENCODE
, D_OBJC
},
577 { "end", RID_AT_END
, D_OBJC
},
578 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
579 { "interface", RID_AT_INTERFACE
, D_OBJC
},
580 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
581 { "selector", RID_AT_SELECTOR
, D_OBJC
},
582 { "finally", RID_AT_FINALLY
, D_OBJC
},
583 { "optional", RID_AT_OPTIONAL
, D_OBJC
},
584 { "required", RID_AT_REQUIRED
, D_OBJC
},
585 { "property", RID_AT_PROPERTY
, D_OBJC
},
586 { "package", RID_AT_PACKAGE
, D_OBJC
},
587 { "synthesize", RID_AT_SYNTHESIZE
, D_OBJC
},
588 { "dynamic", RID_AT_DYNAMIC
, D_OBJC
},
589 /* These are recognized only in protocol-qualifier context
591 { "bycopy", RID_BYCOPY
, D_OBJC
},
592 { "byref", RID_BYREF
, D_OBJC
},
593 { "in", RID_IN
, D_OBJC
},
594 { "inout", RID_INOUT
, D_OBJC
},
595 { "oneway", RID_ONEWAY
, D_OBJC
},
596 { "out", RID_OUT
, D_OBJC
},
597 /* These are recognized inside a property attribute list */
598 { "assign", RID_ASSIGN
, D_OBJC
},
599 { "atomic", RID_PROPATOMIC
, D_OBJC
},
600 { "copy", RID_COPY
, D_OBJC
},
601 { "getter", RID_GETTER
, D_OBJC
},
602 { "nonatomic", RID_NONATOMIC
, D_OBJC
},
603 { "readonly", RID_READONLY
, D_OBJC
},
604 { "readwrite", RID_READWRITE
, D_OBJC
},
605 { "retain", RID_RETAIN
, D_OBJC
},
606 { "setter", RID_SETTER
, D_OBJC
},
607 /* These are Objective C implementation of nullability, accepted only in
608 specific contexts. */
609 { "null_unspecified", RID_NULL_UNSPECIFIED
, D_OBJC
},
610 { "nullable", RID_NULLABLE
, D_OBJC
},
611 { "nonnull", RID_NONNULL
, D_OBJC
},
612 { "null_resettable", RID_NULL_RESETTABLE
, D_OBJC
},
615 const unsigned int num_c_common_reswords
= ARRAY_SIZE (c_common_reswords
);
617 /* Return identifier for address space AS. */
620 c_addr_space_name (addr_space_t as
)
622 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
623 gcc_assert (ridpointers
[rid
]);
624 return IDENTIFIER_POINTER (ridpointers
[rid
]);
627 /* Push current bindings for the function name VAR_DECLS. */
630 start_fname_decls (void)
633 tree saved
= NULL_TREE
;
635 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
637 tree decl
= *fname_vars
[ix
].decl
;
641 saved
= tree_cons (decl
, build_int_cst (integer_type_node
, ix
),
643 *fname_vars
[ix
].decl
= NULL_TREE
;
646 if (saved
|| saved_function_name_decls
)
647 /* Normally they'll have been NULL, so only push if we've got a
648 stack, or they are non-NULL. */
649 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
650 saved_function_name_decls
);
653 /* Finish up the current bindings, adding them into the current function's
654 statement tree. This must be done _before_ finish_stmt_tree is called.
655 If there is no current function, we must be at file scope and no statements
656 are involved. Pop the previous bindings. */
659 finish_fname_decls (void)
662 tree stmts
= NULL_TREE
;
663 tree stack
= saved_function_name_decls
;
665 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
666 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
670 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
672 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
673 bodyp
= &BIND_EXPR_BODY (*bodyp
);
675 append_to_statement_list_force (*bodyp
, &stmts
);
679 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
680 *fname_vars
[ix
].decl
= NULL_TREE
;
684 /* We had saved values, restore them. */
687 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
689 tree decl
= TREE_PURPOSE (saved
);
690 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
692 *fname_vars
[ix
].decl
= decl
;
694 stack
= TREE_CHAIN (stack
);
696 saved_function_name_decls
= stack
;
699 /* Return the text name of the current function, suitably prettified
700 by PRETTY_P. Return string must be freed by caller. */
703 fname_as_string (int pretty_p
)
705 const char *name
= "top level";
708 cpp_string cstr
= { 0, 0 }, strname
;
716 if (current_function_decl
)
717 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
719 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
721 namep
= XNEWVEC (char, len
);
722 snprintf (namep
, len
, "\"%s\"", name
);
723 strname
.text
= (unsigned char *) namep
;
724 strname
.len
= len
- 1;
726 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
729 return (const char *) cstr
.text
;
735 /* Return the VAR_DECL for a const char array naming the current
736 function. If the VAR_DECL has not yet been created, create it
737 now. RID indicates how it should be formatted and IDENTIFIER_NODE
738 ID is its name (unfortunately C and C++ hold the RID values of
739 keywords in different places, so we can't derive RID from ID in
740 this language independent code. LOC is the location of the
744 fname_decl (location_t loc
, unsigned int rid
, tree id
)
747 tree decl
= NULL_TREE
;
749 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
750 if (fname_vars
[ix
].rid
== rid
)
753 decl
= *fname_vars
[ix
].decl
;
756 /* If a tree is built here, it would normally have the lineno of
757 the current statement. Later this tree will be moved to the
758 beginning of the function and this line number will be wrong.
759 To avoid this problem set the lineno to 0 here; that prevents
760 it from appearing in the RTL. */
762 location_t saved_location
= input_location
;
763 input_location
= UNKNOWN_LOCATION
;
765 stmts
= push_stmt_list ();
766 decl
= (*make_fname_decl
) (loc
, id
, fname_vars
[ix
].pretty
);
767 stmts
= pop_stmt_list (stmts
);
768 if (!IS_EMPTY_STMT (stmts
))
769 saved_function_name_decls
770 = tree_cons (decl
, stmts
, saved_function_name_decls
);
771 *fname_vars
[ix
].decl
= decl
;
772 input_location
= saved_location
;
774 if (!ix
&& !current_function_decl
)
775 pedwarn (loc
, 0, "%qD is not defined outside of function scope", decl
);
780 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
783 fix_string_type (tree value
)
785 int length
= TREE_STRING_LENGTH (value
);
787 tree e_type
, i_type
, a_type
;
789 /* Compute the number of elements, for the array type. */
790 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
793 e_type
= char_type_node
;
795 else if (flag_char8_t
&& TREE_TYPE (value
) == char8_array_type_node
)
797 charsz
= TYPE_PRECISION (char8_type_node
) / BITS_PER_UNIT
;
798 e_type
= char8_type_node
;
800 else if (TREE_TYPE (value
) == char16_array_type_node
)
802 charsz
= TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
;
803 e_type
= char16_type_node
;
805 else if (TREE_TYPE (value
) == char32_array_type_node
)
807 charsz
= TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
;
808 e_type
= char32_type_node
;
812 charsz
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
813 e_type
= wchar_type_node
;
816 /* This matters only for targets where ssizetype has smaller precision
818 if (wi::lts_p (wi::to_wide (TYPE_MAX_VALUE (ssizetype
)), length
))
820 error ("size of string literal is too large");
821 length
= tree_to_shwi (TYPE_MAX_VALUE (ssizetype
)) / charsz
* charsz
;
822 char *str
= CONST_CAST (char *, TREE_STRING_POINTER (value
));
823 memset (str
+ length
, '\0',
824 MIN (TREE_STRING_LENGTH (value
) - length
, charsz
));
825 TREE_STRING_LENGTH (value
) = length
;
827 nchars
= length
/ charsz
;
829 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
830 limit in C++98 Annex B is very large (65536) and is not normative,
831 so we do not diagnose it (warn_overlength_strings is forced off
832 in c_common_post_options). */
833 if (warn_overlength_strings
)
835 const int nchars_max
= flag_isoc99
? 4095 : 509;
836 const int relevant_std
= flag_isoc99
? 99 : 90;
837 if (nchars
- 1 > nchars_max
)
838 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
839 separate the %d from the 'C'. 'ISO' should not be
840 translated, but it may be moved after 'C%d' in languages
841 where modifiers follow nouns. */
842 pedwarn (input_location
, OPT_Woverlength_strings
,
843 "string length %qd is greater than the length %qd "
844 "ISO C%d compilers are required to support",
845 nchars
- 1, nchars_max
, relevant_std
);
848 /* Create the array type for the string constant. The ISO C++
849 standard says that a string literal has type `const char[N]' or
850 `const wchar_t[N]'. We use the same logic when invoked as a C
851 front-end with -Wwrite-strings.
852 ??? We should change the type of an expression depending on the
853 state of a warning flag. We should just be warning -- see how
854 this is handled in the C++ front-end for the deprecated implicit
855 conversion from string literals to `char*' or `wchar_t*'.
857 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
858 array type being the unqualified version of that type.
859 Therefore, if we are constructing an array of const char, we must
860 construct the matching unqualified array type first. The C front
861 end does not require this, but it does no harm, so we do it
863 i_type
= build_index_type (size_int (nchars
- 1));
864 a_type
= build_array_type (e_type
, i_type
);
865 if (c_dialect_cxx() || warn_write_strings
)
866 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
868 TREE_TYPE (value
) = a_type
;
869 TREE_CONSTANT (value
) = 1;
870 TREE_READONLY (value
) = 1;
871 TREE_STATIC (value
) = 1;
875 /* Given a string of type STRING_TYPE, determine what kind of string
876 token would give an equivalent execution encoding: CPP_STRING,
877 CPP_STRING16, or CPP_STRING32. Return CPP_OTHER in case of error.
878 This may not be exactly the string token type that initially created
879 the string, since CPP_WSTRING is indistinguishable from the 16/32 bit
880 string type, and CPP_UTF8STRING is indistinguishable from CPP_STRING
883 This effectively reverses part of the logic in lex_string and
886 static enum cpp_ttype
887 get_cpp_ttype_from_string_type (tree string_type
)
889 gcc_assert (string_type
);
890 if (TREE_CODE (string_type
) == POINTER_TYPE
)
891 string_type
= TREE_TYPE (string_type
);
893 if (TREE_CODE (string_type
) != ARRAY_TYPE
)
896 tree element_type
= TREE_TYPE (string_type
);
897 if (TREE_CODE (element_type
) != INTEGER_TYPE
)
900 int bits_per_character
= TYPE_PRECISION (element_type
);
901 switch (bits_per_character
)
904 return CPP_STRING
; /* It could have also been CPP_UTF8STRING. */
914 /* The global record of string concatentations, for use in
915 extracting locations within string literals. */
917 GTY(()) string_concat_db
*g_string_concat_db
;
919 /* Implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */
922 c_get_substring_location (const substring_loc
&substr_loc
,
925 enum cpp_ttype tok_type
926 = get_cpp_ttype_from_string_type (substr_loc
.get_string_type ());
927 if (tok_type
== CPP_OTHER
)
928 return "unrecognized string type";
930 return get_location_within_string (parse_in
, g_string_concat_db
,
931 substr_loc
.get_fmt_string_loc (),
933 substr_loc
.get_caret_idx (),
934 substr_loc
.get_start_idx (),
935 substr_loc
.get_end_idx (),
940 /* Return true iff T is a boolean promoted to int. */
943 bool_promoted_to_int_p (tree t
)
945 return (CONVERT_EXPR_P (t
)
946 && TREE_TYPE (t
) == integer_type_node
947 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == BOOLEAN_TYPE
);
950 /* vector_targets_convertible_p is used for vector pointer types. The
951 callers perform various checks that the qualifiers are satisfactory,
952 while OTOH vector_targets_convertible_p ignores the number of elements
953 in the vectors. That's fine with vector pointers as we can consider,
954 say, a vector of 8 elements as two consecutive vectors of 4 elements,
955 and that does not require and conversion of the pointer values.
956 In contrast, vector_types_convertible_p and
957 vector_types_compatible_elements_p are used for vector value types. */
958 /* True if pointers to distinct types T1 and T2 can be converted to
959 each other without an explicit cast. Only returns true for opaque
962 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
964 if (VECTOR_TYPE_P (t1
) && VECTOR_TYPE_P (t2
)
965 && (TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
966 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
972 /* vector_types_convertible_p is used for vector value types.
973 It could in principle call vector_targets_convertible_p as a subroutine,
974 but then the check for vector type would be duplicated with its callers,
975 and also the purpose of vector_targets_convertible_p would become
977 Where vector_types_convertible_p returns true, a conversion might still be
978 needed to make the types match.
979 In contrast, vector_targets_convertible_p is used for vector pointer
980 values, and vector_types_compatible_elements_p is used specifically
981 in the context for binary operators, as a check if use is possible without
983 /* True if vector types T1 and T2 can be converted to each other
984 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
985 can only be converted with -flax-vector-conversions yet that is not
986 in effect, emit a note telling the user about that option if such
987 a note has not previously been emitted. */
989 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
991 static bool emitted_lax_note
= false;
992 bool convertible_lax
;
994 if ((TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
995 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
999 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1000 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
1001 || known_eq (TYPE_VECTOR_SUBPARTS (t1
),
1002 TYPE_VECTOR_SUBPARTS (t2
)))
1003 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1004 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
1006 if (!convertible_lax
|| flag_lax_vector_conversions
)
1007 return convertible_lax
;
1009 if (known_eq (TYPE_VECTOR_SUBPARTS (t1
), TYPE_VECTOR_SUBPARTS (t2
))
1010 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1013 if (emit_lax_note
&& !emitted_lax_note
)
1015 emitted_lax_note
= true;
1016 inform (input_location
, "use %<-flax-vector-conversions%> to permit "
1017 "conversions between vectors with differing "
1018 "element types or numbers of subparts");
1024 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes
1025 and have vector types, V0 has the same type as V1, and the number of
1026 elements of V0, V1, MASK is the same.
1028 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
1029 called with two arguments. In this case implementation passes the
1030 first argument twice in order to share the same tree code. This fact
1031 could enable the mask-values being twice the vector length. This is
1032 an implementation accident and this semantics is not guaranteed to
1035 c_build_vec_perm_expr (location_t loc
, tree v0
, tree v1
, tree mask
,
1040 bool maybe_const
= false;
1041 bool two_arguments
= false;
1043 if (v1
== NULL_TREE
)
1045 two_arguments
= true;
1049 if (v0
== error_mark_node
|| v1
== error_mark_node
1050 || mask
== error_mark_node
)
1051 return error_mark_node
;
1053 if (!gnu_vector_type_p (TREE_TYPE (mask
))
1054 || !VECTOR_INTEGER_TYPE_P (TREE_TYPE (mask
)))
1057 error_at (loc
, "%<__builtin_shuffle%> last argument must "
1058 "be an integer vector");
1059 return error_mark_node
;
1062 if (!gnu_vector_type_p (TREE_TYPE (v0
))
1063 || !gnu_vector_type_p (TREE_TYPE (v1
)))
1066 error_at (loc
, "%<__builtin_shuffle%> arguments must be vectors");
1067 return error_mark_node
;
1070 if (TYPE_MAIN_VARIANT (TREE_TYPE (v0
)) != TYPE_MAIN_VARIANT (TREE_TYPE (v1
)))
1073 error_at (loc
, "%<__builtin_shuffle%> argument vectors must be of "
1075 return error_mark_node
;
1078 if (maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v0
)),
1079 TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask
)))
1080 && maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v1
)),
1081 TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask
))))
1084 error_at (loc
, "%<__builtin_shuffle%> number of elements of the "
1085 "argument vector(s) and the mask vector should "
1087 return error_mark_node
;
1090 if (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (TREE_TYPE (v0
))))
1091 != GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (TREE_TYPE (mask
)))))
1094 error_at (loc
, "%<__builtin_shuffle%> argument vector(s) inner type "
1095 "must have the same size as inner type of the mask");
1096 return error_mark_node
;
1099 if (!c_dialect_cxx ())
1101 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
1102 v0
= c_fully_fold (v0
, false, &maybe_const
);
1103 wrap
&= maybe_const
;
1106 v1
= v0
= save_expr (v0
);
1109 v1
= c_fully_fold (v1
, false, &maybe_const
);
1110 wrap
&= maybe_const
;
1113 mask
= c_fully_fold (mask
, false, &maybe_const
);
1114 wrap
&= maybe_const
;
1116 else if (two_arguments
)
1117 v1
= v0
= save_expr (v0
);
1119 ret
= build3_loc (loc
, VEC_PERM_EXPR
, TREE_TYPE (v0
), v0
, v1
, mask
);
1121 if (!c_dialect_cxx () && !wrap
)
1122 ret
= c_wrap_maybe_const (ret
, true);
1127 /* Build a VEC_PERM_EXPR if V0, V1 are not error_mark_nodes
1128 and have vector types, V0 has the same element type as V1, and the
1129 number of elements the result is that of MASK. */
1131 c_build_shufflevector (location_t loc
, tree v0
, tree v1
,
1132 const vec
<tree
> &mask
, bool complain
)
1136 bool maybe_const
= false;
1138 if (v0
== error_mark_node
|| v1
== error_mark_node
)
1139 return error_mark_node
;
1141 if (!gnu_vector_type_p (TREE_TYPE (v0
))
1142 || !gnu_vector_type_p (TREE_TYPE (v1
)))
1145 error_at (loc
, "%<__builtin_shufflevector%> arguments must be vectors");
1146 return error_mark_node
;
1149 /* ??? In principle one could select a constant part of a variable size
1150 vector but things get a bit awkward with trying to support this here. */
1151 unsigned HOST_WIDE_INT v0n
, v1n
;
1152 if (!TYPE_VECTOR_SUBPARTS (TREE_TYPE (v0
)).is_constant (&v0n
)
1153 || !TYPE_VECTOR_SUBPARTS (TREE_TYPE (v1
)).is_constant (&v1n
))
1156 error_at (loc
, "%<__builtin_shufflevector%> arguments must be constant"
1158 return error_mark_node
;
1161 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (v0
)))
1162 != TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (v1
))))
1165 error_at (loc
, "%<__builtin_shufflevector%> argument vectors must "
1166 "have the same element type");
1167 return error_mark_node
;
1170 if (!pow2p_hwi (mask
.length ()))
1173 error_at (loc
, "%<__builtin_shufflevector%> must specify a result "
1174 "with a power of two number of elements");
1175 return error_mark_node
;
1178 if (!c_dialect_cxx ())
1180 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
1181 v0
= c_fully_fold (v0
, false, &maybe_const
);
1182 wrap
&= maybe_const
;
1184 v1
= c_fully_fold (v1
, false, &maybe_const
);
1185 wrap
&= maybe_const
;
1188 unsigned HOST_WIDE_INT maskl
= MAX (mask
.length (), MAX (v0n
, v1n
));
1189 unsigned HOST_WIDE_INT pad
= (v0n
< maskl
? maskl
- v0n
: 0);
1190 vec_perm_builder
sel (maskl
, maskl
, 1);
1192 for (i
= 0; i
< mask
.length (); ++i
)
1195 if (!tree_fits_shwi_p (idx
))
1198 error_at (loc
, "invalid element index %qE to "
1199 "%<__builtin_shufflevector%>", idx
);
1200 return error_mark_node
;
1202 HOST_WIDE_INT iidx
= tree_to_shwi (idx
);
1205 && (unsigned HOST_WIDE_INT
) iidx
>= v0n
+ v1n
))
1208 error_at (loc
, "invalid element index %qE to "
1209 "%<__builtin_shufflevector%>", idx
);
1210 return error_mark_node
;
1212 /* ??? Our VEC_PERM_EXPR does not allow for -1 yet. */
1215 /* ??? Our VEC_PERM_EXPR does not allow different sized inputs,
1216 so pad out a smaller v0. */
1217 else if ((unsigned HOST_WIDE_INT
) iidx
>= v0n
)
1219 sel
.quick_push (iidx
);
1221 /* ??? VEC_PERM_EXPR does not support a result that is smaller than
1222 the inputs, so we have to pad id out. */
1223 for (; i
< maskl
; ++i
)
1226 vec_perm_indices
indices (sel
, 2, maskl
);
1228 tree ret_type
= build_vector_type (TREE_TYPE (TREE_TYPE (v0
)), maskl
);
1229 tree mask_type
= build_vector_type (build_nonstandard_integer_type
1230 (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (ret_type
))), 1),
1232 /* Pad out arguments to the common vector size. */
1235 constructor_elt elt
= { NULL_TREE
, build_zero_cst (TREE_TYPE (v0
)) };
1236 v0
= build_constructor_single (ret_type
, NULL_TREE
, v0
);
1237 for (i
= 1; i
< maskl
/ v0n
; ++i
)
1238 vec_safe_push (CONSTRUCTOR_ELTS (v0
), elt
);
1242 constructor_elt elt
= { NULL_TREE
, build_zero_cst (TREE_TYPE (v1
)) };
1243 v1
= build_constructor_single (ret_type
, NULL_TREE
, v1
);
1244 for (i
= 1; i
< maskl
/ v1n
; ++i
)
1245 vec_safe_push (CONSTRUCTOR_ELTS (v1
), elt
);
1247 ret
= build3_loc (loc
, VEC_PERM_EXPR
, ret_type
, v0
, v1
,
1248 vec_perm_indices_to_tree (mask_type
, indices
));
1249 /* Get the lowpart we are interested in. */
1250 if (mask
.length () < maskl
)
1252 tree lpartt
= build_vector_type (TREE_TYPE (ret_type
), mask
.length ());
1253 ret
= build3_loc (loc
, BIT_FIELD_REF
,
1254 lpartt
, ret
, TYPE_SIZE (lpartt
), bitsize_zero_node
);
1255 /* Wrap the lowpart operation in a TARGET_EXPR so it gets a separate
1256 temporary during gimplification. See PR101530 for cases where
1257 we'd otherwise end up with non-toplevel BIT_FIELD_REFs. */
1258 tree tem
= create_tmp_var_raw (lpartt
);
1259 DECL_CONTEXT (tem
) = current_function_decl
;
1260 ret
= build4 (TARGET_EXPR
, lpartt
, tem
, ret
, NULL_TREE
, NULL_TREE
);
1261 TREE_SIDE_EFFECTS (ret
) = 1;
1264 if (!c_dialect_cxx () && !wrap
)
1265 ret
= c_wrap_maybe_const (ret
, true);
1270 /* Build a VEC_CONVERT ifn for __builtin_convertvector builtin. */
1273 c_build_vec_convert (location_t loc1
, tree expr
, location_t loc2
, tree type
,
1276 if (error_operand_p (type
))
1277 return error_mark_node
;
1278 if (error_operand_p (expr
))
1279 return error_mark_node
;
1281 if (!gnu_vector_type_p (TREE_TYPE (expr
))
1282 || (!VECTOR_INTEGER_TYPE_P (TREE_TYPE (expr
))
1283 && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (expr
))))
1286 error_at (loc1
, "%<__builtin_convertvector%> first argument must "
1287 "be an integer or floating vector");
1288 return error_mark_node
;
1291 if (!gnu_vector_type_p (type
)
1292 || (!VECTOR_INTEGER_TYPE_P (type
) && !VECTOR_FLOAT_TYPE_P (type
)))
1295 error_at (loc2
, "%<__builtin_convertvector%> second argument must "
1296 "be an integer or floating vector type");
1297 return error_mark_node
;
1300 if (maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr
)),
1301 TYPE_VECTOR_SUBPARTS (type
)))
1304 error_at (loc1
, "%<__builtin_convertvector%> number of elements "
1305 "of the first argument vector and the second argument "
1306 "vector type should be the same");
1307 return error_mark_node
;
1310 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (expr
)))
1311 == TYPE_MAIN_VARIANT (TREE_TYPE (type
)))
1312 || (VECTOR_INTEGER_TYPE_P (TREE_TYPE (expr
))
1313 && VECTOR_INTEGER_TYPE_P (type
)
1314 && (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (expr
)))
1315 == TYPE_PRECISION (TREE_TYPE (type
)))))
1316 return build1_loc (loc1
, VIEW_CONVERT_EXPR
, type
, expr
);
1319 bool maybe_const
= false;
1321 if (!c_dialect_cxx ())
1323 /* Avoid C_MAYBE_CONST_EXPRs inside of VEC_CONVERT argument. */
1324 expr
= c_fully_fold (expr
, false, &maybe_const
);
1325 wrap
&= maybe_const
;
1328 ret
= build_call_expr_internal_loc (loc1
, IFN_VEC_CONVERT
, type
, 1, expr
);
1331 ret
= c_wrap_maybe_const (ret
, true);
1336 /* Like tree.cc:get_narrower, but retain conversion from C++0x scoped enum
1337 to integral type. */
1340 c_common_get_narrower (tree op
, int *unsignedp_ptr
)
1342 op
= get_narrower (op
, unsignedp_ptr
);
1344 if (TREE_CODE (TREE_TYPE (op
)) == ENUMERAL_TYPE
1345 && ENUM_IS_SCOPED (TREE_TYPE (op
)))
1347 /* C++0x scoped enumerations don't implicitly convert to integral
1348 type; if we stripped an explicit conversion to a larger type we
1349 need to replace it so common_type will still work. */
1350 tree type
= c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op
)),
1351 TYPE_UNSIGNED (TREE_TYPE (op
)));
1352 op
= fold_convert (type
, op
);
1357 /* This is a helper function of build_binary_op.
1359 For certain operations if both args were extended from the same
1360 smaller type, do the arithmetic in that type and then extend.
1362 BITWISE indicates a bitwise operation.
1363 For them, this optimization is safe only if
1364 both args are zero-extended or both are sign-extended.
1365 Otherwise, we might change the result.
1366 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1367 but calculated in (unsigned short) it would be (unsigned short)-1.
1370 shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
1372 int unsigned0
, unsigned1
;
1377 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1378 excessive narrowing when we call get_narrower below. For
1379 example, suppose that OP0 is of unsigned int extended
1380 from signed char and that RESULT_TYPE is long long int.
1381 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1384 (long long int) (unsigned int) signed_char
1386 which get_narrower would narrow down to
1388 (unsigned int) signed char
1390 If we do not cast OP0 first, get_narrower would return
1391 signed_char, which is inconsistent with the case of the
1393 op0
= convert (result_type
, op0
);
1394 op1
= convert (result_type
, op1
);
1396 arg0
= c_common_get_narrower (op0
, &unsigned0
);
1397 arg1
= c_common_get_narrower (op1
, &unsigned1
);
1399 /* UNS is 1 if the operation to be done is an unsigned one. */
1400 uns
= TYPE_UNSIGNED (result_type
);
1402 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1403 but it *requires* conversion to FINAL_TYPE. */
1405 if ((TYPE_PRECISION (TREE_TYPE (op0
))
1406 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1407 && TREE_TYPE (op0
) != result_type
)
1408 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1409 if ((TYPE_PRECISION (TREE_TYPE (op1
))
1410 == TYPE_PRECISION (TREE_TYPE (arg1
)))
1411 && TREE_TYPE (op1
) != result_type
)
1412 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1414 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1416 /* For bitwise operations, signedness of nominal type
1417 does not matter. Consider only how operands were extended. */
1421 /* Note that in all three cases below we refrain from optimizing
1422 an unsigned operation on sign-extended args.
1423 That would not be valid. */
1425 /* Both args variable: if both extended in same way
1426 from same width, do it in that width.
1427 Do it unsigned if args were zero-extended. */
1428 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
1429 < TYPE_PRECISION (result_type
))
1430 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1431 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1432 && unsigned0
== unsigned1
1433 && (unsigned0
|| !uns
))
1435 tree ctype
= common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
));
1436 if (ctype
!= error_mark_node
)
1437 return c_common_signed_or_unsigned_type (unsigned0
, ctype
);
1440 else if (TREE_CODE (arg0
) == INTEGER_CST
1441 && (unsigned1
|| !uns
)
1442 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1443 < TYPE_PRECISION (result_type
))
1445 = c_common_signed_or_unsigned_type (unsigned1
,
1447 && !POINTER_TYPE_P (type
)
1448 && int_fits_type_p (arg0
, type
))
1451 else if (TREE_CODE (arg1
) == INTEGER_CST
1452 && (unsigned0
|| !uns
)
1453 && (TYPE_PRECISION (TREE_TYPE (arg0
))
1454 < TYPE_PRECISION (result_type
))
1456 = c_common_signed_or_unsigned_type (unsigned0
,
1458 && !POINTER_TYPE_P (type
)
1459 && int_fits_type_p (arg1
, type
))
1465 /* Returns true iff any integer value of type FROM_TYPE can be represented as
1466 real of type TO_TYPE. This is a helper function for unsafe_conversion_p. */
1469 int_safely_convertible_to_real_p (const_tree from_type
, const_tree to_type
)
1471 tree type_low_bound
= TYPE_MIN_VALUE (from_type
);
1472 tree type_high_bound
= TYPE_MAX_VALUE (from_type
);
1473 REAL_VALUE_TYPE real_low_bound
=
1474 real_value_from_int_cst (0, type_low_bound
);
1475 REAL_VALUE_TYPE real_high_bound
=
1476 real_value_from_int_cst (0, type_high_bound
);
1478 return exact_real_truncate (TYPE_MODE (to_type
), &real_low_bound
)
1479 && exact_real_truncate (TYPE_MODE (to_type
), &real_high_bound
);
1482 /* Checks if expression EXPR of complex/real/integer type cannot be converted
1483 to the complex/real/integer type TYPE. Function returns non-zero when:
1484 * EXPR is a constant which cannot be exactly converted to TYPE.
1485 * EXPR is not a constant and size of EXPR's type > than size of TYPE,
1486 for EXPR type and TYPE being both integers or both real, or both
1488 * EXPR is not a constant of complex type and TYPE is a real or
1490 * EXPR is not a constant of real type and TYPE is an integer.
1491 * EXPR is not a constant of integer type which cannot be
1492 exactly converted to real type.
1494 Function allows conversions between types of different signedness if
1495 CHECK_SIGN is false and can return SAFE_CONVERSION (zero) in that
1496 case. Function can return UNSAFE_SIGN if CHECK_SIGN is true.
1498 RESULT, when non-null is the result of the conversion. When constant
1499 it is included in the text of diagnostics.
1501 Function allows conversions from complex constants to non-complex types,
1502 provided that imaginary part is zero and real part can be safely converted
1505 enum conversion_safety
1506 unsafe_conversion_p (tree type
, tree expr
, tree result
, bool check_sign
)
1508 enum conversion_safety give_warning
= SAFE_CONVERSION
; /* is 0 or false */
1509 tree expr_type
= TREE_TYPE (expr
);
1511 expr
= fold_for_warn (expr
);
1513 if (TREE_CODE (expr
) == REAL_CST
|| TREE_CODE (expr
) == INTEGER_CST
)
1515 /* If type is complex, we are interested in compatibility with
1517 if (TREE_CODE (type
) == COMPLEX_TYPE
)
1518 type
= TREE_TYPE (type
);
1520 /* Warn for real constant that is not an exact integer converted
1522 if (TREE_CODE (expr_type
) == REAL_TYPE
1523 && TREE_CODE (type
) == INTEGER_TYPE
)
1525 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (expr_type
)))
1526 give_warning
= UNSAFE_REAL
;
1528 /* Warn for an integer constant that does not fit into integer type. */
1529 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1530 && TREE_CODE (type
) == INTEGER_TYPE
1531 && !int_fits_type_p (expr
, type
))
1533 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)
1534 && tree_int_cst_sgn (expr
) < 0)
1537 give_warning
= UNSAFE_SIGN
;
1539 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (expr_type
))
1542 give_warning
= UNSAFE_SIGN
;
1545 give_warning
= UNSAFE_OTHER
;
1547 else if (TREE_CODE (type
) == REAL_TYPE
)
1549 /* Warn for an integer constant that does not fit into real type. */
1550 if (TREE_CODE (expr_type
) == INTEGER_TYPE
)
1552 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
1553 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1554 give_warning
= UNSAFE_REAL
;
1556 /* Warn for a real constant that does not fit into a smaller
1558 else if (TREE_CODE (expr_type
) == REAL_TYPE
1559 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1561 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
1562 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1563 give_warning
= UNSAFE_REAL
;
1568 else if (TREE_CODE (expr
) == COMPLEX_CST
)
1570 tree imag_part
= TREE_IMAGPART (expr
);
1571 /* Conversion from complex constant with zero imaginary part,
1572 perform check for conversion of real part. */
1573 if ((TREE_CODE (imag_part
) == REAL_CST
1574 && real_zerop (imag_part
))
1575 || (TREE_CODE (imag_part
) == INTEGER_CST
1576 && integer_zerop (imag_part
)))
1577 /* Note: in this branch we use recursive call to unsafe_conversion_p
1578 with different type of EXPR, but it is still safe, because when EXPR
1579 is a constant, it's type is not used in text of generated warnings
1580 (otherwise they could sound misleading). */
1581 return unsafe_conversion_p (type
, TREE_REALPART (expr
), result
,
1583 /* Conversion from complex constant with non-zero imaginary part. */
1586 /* Conversion to complex type.
1587 Perform checks for both real and imaginary parts. */
1588 if (TREE_CODE (type
) == COMPLEX_TYPE
)
1590 enum conversion_safety re_safety
=
1591 unsafe_conversion_p (type
, TREE_REALPART (expr
),
1592 result
, check_sign
);
1593 enum conversion_safety im_safety
=
1594 unsafe_conversion_p (type
, imag_part
, result
, check_sign
);
1596 /* Merge the results into appropriate single warning. */
1598 /* Note: this case includes SAFE_CONVERSION, i.e. success. */
1599 if (re_safety
== im_safety
)
1600 give_warning
= re_safety
;
1601 else if (!re_safety
&& im_safety
)
1602 give_warning
= im_safety
;
1603 else if (re_safety
&& !im_safety
)
1604 give_warning
= re_safety
;
1606 give_warning
= UNSAFE_OTHER
;
1608 /* Warn about conversion from complex to real or integer type. */
1610 give_warning
= UNSAFE_IMAGINARY
;
1614 /* Checks for remaining case: EXPR is not constant. */
1617 /* Warn for real types converted to integer types. */
1618 if (TREE_CODE (expr_type
) == REAL_TYPE
1619 && TREE_CODE (type
) == INTEGER_TYPE
)
1620 give_warning
= UNSAFE_REAL
;
1622 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1623 && TREE_CODE (type
) == INTEGER_TYPE
)
1625 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1626 expr
= get_unwidened (expr
, 0);
1627 expr_type
= TREE_TYPE (expr
);
1629 /* Don't warn for short y; short x = ((int)y & 0xff); */
1630 if (TREE_CODE (expr
) == BIT_AND_EXPR
1631 || TREE_CODE (expr
) == BIT_IOR_EXPR
1632 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
1634 /* If both args were extended from a shortest type,
1635 use that type if that is safe. */
1636 expr_type
= shorten_binary_op (expr_type
,
1637 TREE_OPERAND (expr
, 0),
1638 TREE_OPERAND (expr
, 1),
1641 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
1643 tree op0
= TREE_OPERAND (expr
, 0);
1644 tree op1
= TREE_OPERAND (expr
, 1);
1645 bool unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1646 bool unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1648 /* If one of the operands is a non-negative constant
1649 that fits in the target type, then the type of the
1650 other operand does not matter. */
1651 if ((TREE_CODE (op0
) == INTEGER_CST
1652 && int_fits_type_p (op0
, c_common_signed_type (type
))
1653 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
1654 || (TREE_CODE (op1
) == INTEGER_CST
1655 && int_fits_type_p (op1
, c_common_signed_type (type
))
1656 && int_fits_type_p (op1
,
1657 c_common_unsigned_type (type
))))
1658 return SAFE_CONVERSION
;
1659 /* If constant is unsigned and fits in the target
1660 type, then the result will also fit. */
1661 else if ((TREE_CODE (op0
) == INTEGER_CST
1663 && int_fits_type_p (op0
, type
))
1664 || (TREE_CODE (op1
) == INTEGER_CST
1666 && int_fits_type_p (op1
, type
)))
1667 return SAFE_CONVERSION
;
1670 /* Warn for integer types converted to smaller integer types. */
1671 if (TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1672 give_warning
= UNSAFE_OTHER
;
1674 /* When they are the same width but different signedness,
1675 then the value may change. */
1676 else if (((TYPE_PRECISION (type
) == TYPE_PRECISION (expr_type
)
1677 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
1678 /* Even when converted to a bigger type, if the type is
1679 unsigned but expr is signed, then negative values
1681 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
1683 give_warning
= UNSAFE_SIGN
;
1686 /* Warn for integer types converted to real types if and only if
1687 all the range of values of the integer type cannot be
1688 represented by the real type. */
1689 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1690 && TREE_CODE (type
) == REAL_TYPE
)
1692 /* Don't warn about char y = 0xff; float x = (int) y; */
1693 expr
= get_unwidened (expr
, 0);
1694 expr_type
= TREE_TYPE (expr
);
1696 if (!int_safely_convertible_to_real_p (expr_type
, type
))
1697 give_warning
= UNSAFE_OTHER
;
1700 /* Warn for real types converted to smaller real types. */
1701 else if (TREE_CODE (expr_type
) == REAL_TYPE
1702 && TREE_CODE (type
) == REAL_TYPE
1703 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1704 give_warning
= UNSAFE_REAL
;
1706 /* Check conversion between two complex types. */
1707 else if (TREE_CODE (expr_type
) == COMPLEX_TYPE
1708 && TREE_CODE (type
) == COMPLEX_TYPE
)
1710 /* Extract underlying types (i.e., type of real and imaginary
1711 parts) of expr_type and type. */
1712 tree from_type
= TREE_TYPE (expr_type
);
1713 tree to_type
= TREE_TYPE (type
);
1715 /* Warn for real types converted to integer types. */
1716 if (TREE_CODE (from_type
) == REAL_TYPE
1717 && TREE_CODE (to_type
) == INTEGER_TYPE
)
1718 give_warning
= UNSAFE_REAL
;
1720 /* Warn for real types converted to smaller real types. */
1721 else if (TREE_CODE (from_type
) == REAL_TYPE
1722 && TREE_CODE (to_type
) == REAL_TYPE
1723 && TYPE_PRECISION (to_type
) < TYPE_PRECISION (from_type
))
1724 give_warning
= UNSAFE_REAL
;
1726 /* Check conversion for complex integer types. Here implementation
1727 is simpler than for real-domain integers because it does not
1728 involve sophisticated cases, such as bitmasks, casts, etc. */
1729 else if (TREE_CODE (from_type
) == INTEGER_TYPE
1730 && TREE_CODE (to_type
) == INTEGER_TYPE
)
1732 /* Warn for integer types converted to smaller integer types. */
1733 if (TYPE_PRECISION (to_type
) < TYPE_PRECISION (from_type
))
1734 give_warning
= UNSAFE_OTHER
;
1736 /* Check for different signedness, see case for real-domain
1737 integers (above) for a more detailed comment. */
1738 else if (((TYPE_PRECISION (to_type
) == TYPE_PRECISION (from_type
)
1739 && TYPE_UNSIGNED (to_type
) != TYPE_UNSIGNED (from_type
))
1740 || (TYPE_UNSIGNED (to_type
) && !TYPE_UNSIGNED (from_type
)))
1742 give_warning
= UNSAFE_SIGN
;
1744 else if (TREE_CODE (from_type
) == INTEGER_TYPE
1745 && TREE_CODE (to_type
) == REAL_TYPE
1746 && !int_safely_convertible_to_real_p (from_type
, to_type
))
1747 give_warning
= UNSAFE_OTHER
;
1750 /* Warn for complex types converted to real or integer types. */
1751 else if (TREE_CODE (expr_type
) == COMPLEX_TYPE
1752 && TREE_CODE (type
) != COMPLEX_TYPE
)
1753 give_warning
= UNSAFE_IMAGINARY
;
1756 return give_warning
;
1760 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1761 Invoke this function on every expression that is converted implicitly,
1762 i.e. because of language rules and not because of an explicit cast.
1763 INIT_CONST is true if the conversion is for arithmetic types for a static
1764 initializer and folding must apply accordingly (discarding floating-point
1765 exceptions and assuming the default rounding mode is in effect). */
1768 convert_and_check (location_t loc
, tree type
, tree expr
, bool init_const
)
1771 tree expr_for_warning
;
1773 /* Convert from a value with possible excess precision rather than
1774 via the semantic type, but do not warn about values not fitting
1775 exactly in the semantic type. */
1776 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
1778 tree orig_type
= TREE_TYPE (expr
);
1779 expr
= TREE_OPERAND (expr
, 0);
1780 expr_for_warning
= (init_const
1781 ? convert_init (orig_type
, expr
)
1782 : convert (orig_type
, expr
));
1783 if (orig_type
== type
)
1784 return expr_for_warning
;
1787 expr_for_warning
= expr
;
1789 if (TREE_TYPE (expr
) == type
)
1792 result
= init_const
? convert_init (type
, expr
) : convert (type
, expr
);
1794 if (c_inhibit_evaluation_warnings
== 0
1795 && !TREE_OVERFLOW_P (expr
)
1796 && result
!= error_mark_node
)
1797 warnings_for_convert_and_check (loc
, type
, expr_for_warning
, result
);
1802 /* A node in a list that describes references to variables (EXPR), which are
1803 either read accesses if WRITER is zero, or write accesses, in which case
1804 WRITER is the parent of EXPR. */
1811 /* Used to implement a cache the results of a call to verify_tree. We only
1812 use this for SAVE_EXPRs. */
1815 struct tlist_cache
*next
;
1816 struct tlist
*cache_before_sp
;
1817 struct tlist
*cache_after_sp
;
1821 /* Obstack to use when allocating tlist structures, and corresponding
1823 static struct obstack tlist_obstack
;
1824 static char *tlist_firstobj
= 0;
1826 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1828 static struct tlist
*warned_ids
;
1829 /* SAVE_EXPRs need special treatment. We process them only once and then
1830 cache the results. */
1831 static struct tlist_cache
*save_expr_cache
;
1833 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
1834 static void merge_tlist (struct tlist
**, struct tlist
*, int);
1835 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
1836 static bool warning_candidate_p (tree
);
1837 static bool candidate_equal_p (const_tree
, const_tree
);
1838 static void warn_for_collisions (struct tlist
*);
1839 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
1840 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
1842 /* Create a new struct tlist and fill in its fields. */
1843 static struct tlist
*
1844 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1847 l
= XOBNEW (&tlist_obstack
, struct tlist
);
1854 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1855 is nonnull, we ignore any node we find which has a writer equal to it. */
1858 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1862 struct tlist
*next
= add
->next
;
1865 if (!exclude_writer
|| !candidate_equal_p (add
->writer
, exclude_writer
))
1866 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1871 /* Merge the nodes of ADD into TO. This merging process is done so that for
1872 each variable that already exists in TO, no new node is added; however if
1873 there is a write access recorded in ADD, and an occurrence on TO is only
1874 a read access, then the occurrence in TO will be modified to record the
1878 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1880 struct tlist
**end
= to
;
1883 end
= &(*end
)->next
;
1889 struct tlist
*next
= add
->next
;
1891 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1892 if (candidate_equal_p (tmp2
->expr
, add
->expr
))
1896 tmp2
->writer
= add
->writer
;
1900 *end
= copy
? new_tlist (NULL
, add
->expr
, add
->writer
) : add
;
1901 end
= &(*end
)->next
;
1908 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1909 references in list LIST conflict with it, excluding reads if ONLY writers
1913 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1918 /* Avoid duplicate warnings. */
1919 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1920 if (candidate_equal_p (tmp
->expr
, written
))
1925 if (candidate_equal_p (list
->expr
, written
)
1926 && !candidate_equal_p (list
->writer
, writer
)
1927 && (!only_writes
|| list
->writer
))
1929 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1930 warning_at (EXPR_LOC_OR_LOC (writer
, input_location
),
1931 OPT_Wsequence_point
, "operation on %qE may be undefined",
1938 /* Given a list LIST of references to variables, find whether any of these
1939 can cause conflicts due to missing sequence points. */
1942 warn_for_collisions (struct tlist
*list
)
1946 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1949 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1953 /* Return nonzero if X is a tree that can be verified by the sequence point
1957 warning_candidate_p (tree x
)
1959 if (DECL_P (x
) && DECL_ARTIFICIAL (x
))
1962 if (TREE_CODE (x
) == BLOCK
)
1965 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.cc
1966 (lvalue_p) crash on TRY/CATCH. */
1967 if (TREE_TYPE (x
) == NULL_TREE
|| VOID_TYPE_P (TREE_TYPE (x
)))
1973 /* No point to track non-const calls, they will never satisfy
1975 if (TREE_CODE (x
) == CALL_EXPR
&& (call_expr_flags (x
) & ECF_CONST
) == 0)
1978 if (TREE_CODE (x
) == STRING_CST
)
1984 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
1986 candidate_equal_p (const_tree x
, const_tree y
)
1988 return (x
== y
) || (x
&& y
&& operand_equal_p (x
, y
, 0));
1991 /* Walk the tree X, and record accesses to variables. If X is written by the
1992 parent tree, WRITER is the parent.
1993 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1994 expression or its only operand forces a sequence point, then everything up
1995 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1997 Once we return, we will have emitted warnings if any subexpression before
1998 such a sequence point could be undefined. On a higher level, however, the
1999 sequence point may not be relevant, and we'll merge the two lists.
2001 Example: (b++, a) + b;
2002 The call that processes the COMPOUND_EXPR will store the increment of B
2003 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2004 processes the PLUS_EXPR will need to merge the two lists so that
2005 eventually, all accesses end up on the same list (and we'll warn about the
2006 unordered subexpressions b++ and b.
2008 A note on merging. If we modify the former example so that our expression
2011 care must be taken not simply to add all three expressions into the final
2012 PNO_SP list. The function merge_tlist takes care of that by merging the
2013 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2014 way, so that no more than one access to B is recorded. */
2017 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
2020 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
2021 enum tree_code code
;
2022 enum tree_code_class cl
;
2025 /* X may be NULL if it is the operand of an empty statement expression
2030 code
= TREE_CODE (x
);
2031 cl
= TREE_CODE_CLASS (code
);
2033 if (warning_candidate_p (x
))
2034 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
2040 case PAREN_SIZEOF_EXPR
:
2044 case TRUTH_ANDIF_EXPR
:
2045 case TRUTH_ORIF_EXPR
:
2047 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
2048 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2049 warn_for_collisions (tmp_nosp
);
2050 merge_tlist (pbefore_sp
, tmp_before
, 0);
2051 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
2052 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_list2
, NULL_TREE
);
2053 warn_for_collisions (tmp_list2
);
2054 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2055 merge_tlist (pno_sp
, tmp_list2
, 0);
2059 tmp_before
= tmp_list2
= 0;
2060 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
2061 warn_for_collisions (tmp_list2
);
2062 merge_tlist (pbefore_sp
, tmp_before
, 0);
2063 merge_tlist (pbefore_sp
, tmp_list2
, 0);
2065 tmp_list3
= tmp_nosp
= 0;
2066 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
2067 warn_for_collisions (tmp_nosp
);
2068 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2070 tmp_list3
= tmp_list2
= 0;
2071 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
2072 warn_for_collisions (tmp_list2
);
2073 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2074 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2075 two first, to avoid warning for (a ? b++ : b++). */
2076 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
2077 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2080 case PREDECREMENT_EXPR
:
2081 case PREINCREMENT_EXPR
:
2082 case POSTDECREMENT_EXPR
:
2083 case POSTINCREMENT_EXPR
:
2084 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
2088 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2089 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2090 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
2091 /* Expressions inside the LHS are not ordered wrt. the sequence points
2092 in the RHS. Example:
2094 Despite the fact that the modification of "a" is in the before_sp
2095 list (tmp_before), it conflicts with the use of "a" in the LHS.
2096 We can handle this by adding the contents of tmp_list3
2097 to those of tmp_before, and redoing the collision warnings for that
2099 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
2100 warn_for_collisions (tmp_before
);
2101 /* Exclude the LHS itself here; we first have to merge it into the
2102 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2103 didn't exclude the LHS, we'd get it twice, once as a read and once
2105 add_tlist (pno_sp
, tmp_list3
, x
, 0);
2106 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
2108 merge_tlist (pbefore_sp
, tmp_before
, 0);
2109 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
2110 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
2111 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
2115 /* We need to warn about conflicts among arguments and conflicts between
2116 args and the function address. Side effects of the function address,
2117 however, are not ordered by the sequence point of the call. */
2119 call_expr_arg_iterator iter
;
2121 tmp_before
= tmp_nosp
= 0;
2122 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2123 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
2125 tmp_list2
= tmp_list3
= 0;
2126 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
2127 merge_tlist (&tmp_list3
, tmp_list2
, 0);
2128 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
2130 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
2131 warn_for_collisions (tmp_before
);
2132 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
2137 /* Scan all the list, e.g. indices of multi dimensional array. */
2140 tmp_before
= tmp_nosp
= 0;
2141 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2142 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2143 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2150 struct tlist_cache
*t
;
2151 for (t
= save_expr_cache
; t
; t
= t
->next
)
2152 if (candidate_equal_p (t
->expr
, x
))
2157 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
2158 t
->next
= save_expr_cache
;
2160 save_expr_cache
= t
;
2162 tmp_before
= tmp_nosp
= 0;
2163 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2164 warn_for_collisions (tmp_nosp
);
2167 merge_tlist (&tmp_list3
, tmp_nosp
, 0);
2168 t
->cache_before_sp
= tmp_before
;
2169 t
->cache_after_sp
= tmp_list3
;
2171 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
2172 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
2177 x
= TREE_OPERAND (x
, 0);
2183 case VIEW_CONVERT_EXPR
:
2184 if (location_wrapper_p (x
))
2186 x
= TREE_OPERAND (x
, 0);
2195 if (cxx_dialect
>= cxx17
)
2196 goto sequenced_binary
;
2201 /* For other expressions, simply recurse on their operands.
2202 Manual tail recursion for unary expressions.
2203 Other non-expressions need not be processed. */
2204 if (cl
== tcc_unary
)
2206 x
= TREE_OPERAND (x
, 0);
2210 else if (IS_EXPR_CODE_CLASS (cl
))
2213 int max
= TREE_OPERAND_LENGTH (x
);
2214 for (lp
= 0; lp
< max
; lp
++)
2216 tmp_before
= tmp_nosp
= 0;
2217 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
2218 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2219 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2226 static constexpr size_t verify_sequence_points_limit
= 1024;
2228 /* Called from verify_sequence_points via walk_tree. */
2231 verify_tree_lim_r (tree
*tp
, int *walk_subtrees
, void *data
)
2233 if (++*((size_t *) data
) > verify_sequence_points_limit
)
2234 return integer_zero_node
;
2242 /* Try to warn for undefined behavior in EXPR due to missing sequence
2246 verify_sequence_points (tree expr
)
2248 tlist
*before_sp
= nullptr, *after_sp
= nullptr;
2250 /* verify_tree is highly recursive, and merge_tlist is O(n^2),
2251 so we return early if the expression is too big. */
2253 if (walk_tree (&expr
, verify_tree_lim_r
, &n
, nullptr))
2256 warned_ids
= nullptr;
2257 save_expr_cache
= nullptr;
2258 if (!tlist_firstobj
)
2260 gcc_obstack_init (&tlist_obstack
);
2261 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
2264 verify_tree (expr
, &before_sp
, &after_sp
, NULL_TREE
);
2265 warn_for_collisions (after_sp
);
2266 obstack_free (&tlist_obstack
, tlist_firstobj
);
2269 /* Validate the expression after `case' and apply default promotions. */
2272 check_case_value (location_t loc
, tree value
)
2274 if (value
== NULL_TREE
)
2277 if (TREE_CODE (value
) == INTEGER_CST
)
2278 /* Promote char or short to int. */
2279 value
= perform_integral_promotions (value
);
2280 else if (value
!= error_mark_node
)
2282 error_at (loc
, "case label does not reduce to an integer constant");
2283 value
= error_mark_node
;
2286 constant_expression_warning (value
);
2291 /* Return an integer type with BITS bits of precision,
2292 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2295 c_common_type_for_size (unsigned int bits
, int unsignedp
)
2299 if (bits
== TYPE_PRECISION (integer_type_node
))
2300 return unsignedp
? unsigned_type_node
: integer_type_node
;
2302 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2303 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2305 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2306 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2308 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2309 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2311 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2312 return (unsignedp
? long_long_unsigned_type_node
2313 : long_long_integer_type_node
);
2315 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2316 if (int_n_enabled_p
[i
]
2317 && bits
== int_n_data
[i
].bitsize
)
2318 return (unsignedp
? int_n_trees
[i
].unsigned_type
2319 : int_n_trees
[i
].signed_type
);
2321 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2322 return (unsignedp
? widest_unsigned_literal_type_node
2323 : widest_integer_literal_type_node
);
2325 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2326 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2328 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2329 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2331 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2332 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2334 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2335 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2340 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2341 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2342 and saturating if SATP is nonzero, otherwise not saturating. */
2345 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
2346 int unsignedp
, int satp
)
2348 enum mode_class mclass
;
2350 mclass
= unsignedp
? MODE_UFRACT
: MODE_FRACT
;
2352 mclass
= unsignedp
? MODE_UACCUM
: MODE_ACCUM
;
2354 opt_scalar_mode opt_mode
;
2356 FOR_EACH_MODE_IN_CLASS (opt_mode
, mclass
)
2358 mode
= opt_mode
.require ();
2359 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2363 if (!opt_mode
.exists (&mode
) || !targetm
.scalar_mode_supported_p (mode
))
2365 sorry ("GCC cannot support operators with integer types and "
2366 "fixed-point types that have too many integral and "
2367 "fractional bits together");
2371 return c_common_type_for_mode (mode
, satp
);
2374 /* Used for communication between c_common_type_for_mode and
2375 c_register_builtin_type. */
2376 tree registered_builtin_types
;
2378 /* Return a data type that has machine mode MODE.
2379 If the mode is an integer,
2380 then UNSIGNEDP selects between signed and unsigned types.
2381 If the mode is a fixed-point mode,
2382 then UNSIGNEDP selects between saturating and nonsaturating types. */
2385 c_common_type_for_mode (machine_mode mode
, int unsignedp
)
2390 if (mode
== TYPE_MODE (integer_type_node
))
2391 return unsignedp
? unsigned_type_node
: integer_type_node
;
2393 if (mode
== TYPE_MODE (signed_char_type_node
))
2394 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2396 if (mode
== TYPE_MODE (short_integer_type_node
))
2397 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2399 if (mode
== TYPE_MODE (long_integer_type_node
))
2400 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2402 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2403 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2405 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2406 if (int_n_enabled_p
[i
]
2407 && mode
== int_n_data
[i
].m
)
2408 return (unsignedp
? int_n_trees
[i
].unsigned_type
2409 : int_n_trees
[i
].signed_type
);
2412 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2415 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2418 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2421 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2423 #if HOST_BITS_PER_WIDE_INT >= 64
2424 if (mode
== TYPE_MODE (intTI_type_node
))
2425 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2428 if (mode
== TYPE_MODE (float_type_node
))
2429 return float_type_node
;
2431 if (mode
== TYPE_MODE (double_type_node
))
2432 return double_type_node
;
2434 if (mode
== TYPE_MODE (long_double_type_node
))
2435 return long_double_type_node
;
2437 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
2438 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
2439 && mode
== TYPE_MODE (FLOATN_NX_TYPE_NODE (i
)))
2440 return FLOATN_NX_TYPE_NODE (i
);
2442 if (mode
== TYPE_MODE (void_type_node
))
2443 return void_type_node
;
2445 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
))
2446 || mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2448 unsigned int precision
2449 = GET_MODE_PRECISION (as_a
<scalar_int_mode
> (mode
));
2451 ? make_unsigned_type (precision
)
2452 : make_signed_type (precision
));
2455 if (COMPLEX_MODE_P (mode
))
2457 machine_mode inner_mode
;
2460 if (mode
== TYPE_MODE (complex_float_type_node
))
2461 return complex_float_type_node
;
2462 if (mode
== TYPE_MODE (complex_double_type_node
))
2463 return complex_double_type_node
;
2464 if (mode
== TYPE_MODE (complex_long_double_type_node
))
2465 return complex_long_double_type_node
;
2467 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
2468 if (COMPLEX_FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
2469 && mode
== TYPE_MODE (COMPLEX_FLOATN_NX_TYPE_NODE (i
)))
2470 return COMPLEX_FLOATN_NX_TYPE_NODE (i
);
2472 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
2473 return complex_integer_type_node
;
2475 inner_mode
= GET_MODE_INNER (mode
);
2476 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2477 if (inner_type
!= NULL_TREE
)
2478 return build_complex_type (inner_type
);
2480 else if (GET_MODE_CLASS (mode
) == MODE_VECTOR_BOOL
2481 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
2483 unsigned int elem_bits
= vector_element_size (GET_MODE_BITSIZE (mode
),
2484 GET_MODE_NUNITS (mode
));
2485 tree bool_type
= build_nonstandard_boolean_type (elem_bits
);
2486 return build_vector_type_for_mode (bool_type
, mode
);
2488 else if (VECTOR_MODE_P (mode
)
2489 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
2491 machine_mode inner_mode
= GET_MODE_INNER (mode
);
2492 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2493 if (inner_type
!= NULL_TREE
)
2494 return build_vector_type_for_mode (inner_type
, mode
);
2497 if (dfloat32_type_node
!= NULL_TREE
2498 && mode
== TYPE_MODE (dfloat32_type_node
))
2499 return dfloat32_type_node
;
2500 if (dfloat64_type_node
!= NULL_TREE
2501 && mode
== TYPE_MODE (dfloat64_type_node
))
2502 return dfloat64_type_node
;
2503 if (dfloat128_type_node
!= NULL_TREE
2504 && mode
== TYPE_MODE (dfloat128_type_node
))
2505 return dfloat128_type_node
;
2507 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
2509 if (mode
== TYPE_MODE (short_fract_type_node
))
2510 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
2511 if (mode
== TYPE_MODE (fract_type_node
))
2512 return unsignedp
? sat_fract_type_node
: fract_type_node
;
2513 if (mode
== TYPE_MODE (long_fract_type_node
))
2514 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
2515 if (mode
== TYPE_MODE (long_long_fract_type_node
))
2516 return unsignedp
? sat_long_long_fract_type_node
2517 : long_long_fract_type_node
;
2519 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
2520 return unsignedp
? sat_unsigned_short_fract_type_node
2521 : unsigned_short_fract_type_node
;
2522 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
2523 return unsignedp
? sat_unsigned_fract_type_node
2524 : unsigned_fract_type_node
;
2525 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
2526 return unsignedp
? sat_unsigned_long_fract_type_node
2527 : unsigned_long_fract_type_node
;
2528 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
2529 return unsignedp
? sat_unsigned_long_long_fract_type_node
2530 : unsigned_long_long_fract_type_node
;
2532 if (mode
== TYPE_MODE (short_accum_type_node
))
2533 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
2534 if (mode
== TYPE_MODE (accum_type_node
))
2535 return unsignedp
? sat_accum_type_node
: accum_type_node
;
2536 if (mode
== TYPE_MODE (long_accum_type_node
))
2537 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
2538 if (mode
== TYPE_MODE (long_long_accum_type_node
))
2539 return unsignedp
? sat_long_long_accum_type_node
2540 : long_long_accum_type_node
;
2542 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
2543 return unsignedp
? sat_unsigned_short_accum_type_node
2544 : unsigned_short_accum_type_node
;
2545 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
2546 return unsignedp
? sat_unsigned_accum_type_node
2547 : unsigned_accum_type_node
;
2548 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
2549 return unsignedp
? sat_unsigned_long_accum_type_node
2550 : unsigned_long_accum_type_node
;
2551 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
2552 return unsignedp
? sat_unsigned_long_long_accum_type_node
2553 : unsigned_long_long_accum_type_node
;
2556 return unsignedp
? sat_qq_type_node
: qq_type_node
;
2558 return unsignedp
? sat_hq_type_node
: hq_type_node
;
2560 return unsignedp
? sat_sq_type_node
: sq_type_node
;
2562 return unsignedp
? sat_dq_type_node
: dq_type_node
;
2564 return unsignedp
? sat_tq_type_node
: tq_type_node
;
2566 if (mode
== UQQmode
)
2567 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
2568 if (mode
== UHQmode
)
2569 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
2570 if (mode
== USQmode
)
2571 return unsignedp
? sat_usq_type_node
: usq_type_node
;
2572 if (mode
== UDQmode
)
2573 return unsignedp
? sat_udq_type_node
: udq_type_node
;
2574 if (mode
== UTQmode
)
2575 return unsignedp
? sat_utq_type_node
: utq_type_node
;
2578 return unsignedp
? sat_ha_type_node
: ha_type_node
;
2580 return unsignedp
? sat_sa_type_node
: sa_type_node
;
2582 return unsignedp
? sat_da_type_node
: da_type_node
;
2584 return unsignedp
? sat_ta_type_node
: ta_type_node
;
2586 if (mode
== UHAmode
)
2587 return unsignedp
? sat_uha_type_node
: uha_type_node
;
2588 if (mode
== USAmode
)
2589 return unsignedp
? sat_usa_type_node
: usa_type_node
;
2590 if (mode
== UDAmode
)
2591 return unsignedp
? sat_uda_type_node
: uda_type_node
;
2592 if (mode
== UTAmode
)
2593 return unsignedp
? sat_uta_type_node
: uta_type_node
;
2596 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
2598 tree type
= TREE_VALUE (t
);
2599 if (TYPE_MODE (type
) == mode
2600 && VECTOR_TYPE_P (type
) == VECTOR_MODE_P (mode
)
2601 && !!unsignedp
== !!TYPE_UNSIGNED (type
))
2608 c_common_unsigned_type (tree type
)
2610 return c_common_signed_or_unsigned_type (1, type
);
2613 /* Return a signed type the same as TYPE in other respects. */
2616 c_common_signed_type (tree type
)
2618 return c_common_signed_or_unsigned_type (0, type
);
2621 /* Return a type the same as TYPE except unsigned or
2622 signed according to UNSIGNEDP. */
2625 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
2630 /* This block of code emulates the behavior of the old
2631 c_common_unsigned_type. In particular, it returns
2632 long_unsigned_type_node if passed a long, even when a int would
2633 have the same size. This is necessary for warnings to work
2634 correctly in archs where sizeof(int) == sizeof(long) */
2636 type1
= TYPE_MAIN_VARIANT (type
);
2637 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
2638 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2639 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2640 return unsignedp
? unsigned_type_node
: integer_type_node
;
2641 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2642 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2643 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2644 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2645 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
2646 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2648 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2649 if (int_n_enabled_p
[i
]
2650 && (type1
== int_n_trees
[i
].unsigned_type
2651 || type1
== int_n_trees
[i
].signed_type
))
2652 return (unsignedp
? int_n_trees
[i
].unsigned_type
2653 : int_n_trees
[i
].signed_type
);
2655 #if HOST_BITS_PER_WIDE_INT >= 64
2656 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2657 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2659 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2660 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2661 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2662 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2663 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2664 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2665 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2666 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2668 #define C_COMMON_FIXED_TYPES(NAME) \
2669 if (type1 == short_ ## NAME ## _type_node \
2670 || type1 == unsigned_short_ ## NAME ## _type_node) \
2671 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2672 : short_ ## NAME ## _type_node; \
2673 if (type1 == NAME ## _type_node \
2674 || type1 == unsigned_ ## NAME ## _type_node) \
2675 return unsignedp ? unsigned_ ## NAME ## _type_node \
2676 : NAME ## _type_node; \
2677 if (type1 == long_ ## NAME ## _type_node \
2678 || type1 == unsigned_long_ ## NAME ## _type_node) \
2679 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2680 : long_ ## NAME ## _type_node; \
2681 if (type1 == long_long_ ## NAME ## _type_node \
2682 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2683 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2684 : long_long_ ## NAME ## _type_node;
2686 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
2687 if (type1 == NAME ## _type_node \
2688 || type1 == u ## NAME ## _type_node) \
2689 return unsignedp ? u ## NAME ## _type_node \
2690 : NAME ## _type_node;
2692 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
2693 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2694 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2695 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2696 : sat_ ## short_ ## NAME ## _type_node; \
2697 if (type1 == sat_ ## NAME ## _type_node \
2698 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2699 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2700 : sat_ ## NAME ## _type_node; \
2701 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2702 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2703 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2704 : sat_ ## long_ ## NAME ## _type_node; \
2705 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2706 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2707 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2708 : sat_ ## long_long_ ## NAME ## _type_node;
2710 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
2711 if (type1 == sat_ ## NAME ## _type_node \
2712 || type1 == sat_ ## u ## NAME ## _type_node) \
2713 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2714 : sat_ ## NAME ## _type_node;
2716 C_COMMON_FIXED_TYPES (fract
);
2717 C_COMMON_FIXED_TYPES_SAT (fract
);
2718 C_COMMON_FIXED_TYPES (accum
);
2719 C_COMMON_FIXED_TYPES_SAT (accum
);
2721 C_COMMON_FIXED_MODE_TYPES (qq
);
2722 C_COMMON_FIXED_MODE_TYPES (hq
);
2723 C_COMMON_FIXED_MODE_TYPES (sq
);
2724 C_COMMON_FIXED_MODE_TYPES (dq
);
2725 C_COMMON_FIXED_MODE_TYPES (tq
);
2726 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
2727 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
2728 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
2729 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
2730 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
2731 C_COMMON_FIXED_MODE_TYPES (ha
);
2732 C_COMMON_FIXED_MODE_TYPES (sa
);
2733 C_COMMON_FIXED_MODE_TYPES (da
);
2734 C_COMMON_FIXED_MODE_TYPES (ta
);
2735 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
2736 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
2737 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
2738 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
2740 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2741 the precision; they have precision set to match their range, but
2742 may use a wider mode to match an ABI. If we change modes, we may
2743 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2744 the precision as well, so as to yield correct results for
2745 bit-field types. C++ does not have these separate bit-field
2746 types, and producing a signed or unsigned variant of an
2747 ENUMERAL_TYPE may cause other problems as well. */
2749 if (!INTEGRAL_TYPE_P (type
)
2750 || TYPE_UNSIGNED (type
) == unsignedp
)
2753 #define TYPE_OK(node) \
2754 (TYPE_MODE (type) == TYPE_MODE (node) \
2755 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2756 if (TYPE_OK (signed_char_type_node
))
2757 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2758 if (TYPE_OK (integer_type_node
))
2759 return unsignedp
? unsigned_type_node
: integer_type_node
;
2760 if (TYPE_OK (short_integer_type_node
))
2761 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2762 if (TYPE_OK (long_integer_type_node
))
2763 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2764 if (TYPE_OK (long_long_integer_type_node
))
2765 return (unsignedp
? long_long_unsigned_type_node
2766 : long_long_integer_type_node
);
2768 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2769 if (int_n_enabled_p
[i
]
2770 && TYPE_MODE (type
) == int_n_data
[i
].m
2771 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2772 return (unsignedp
? int_n_trees
[i
].unsigned_type
2773 : int_n_trees
[i
].signed_type
);
2775 #if HOST_BITS_PER_WIDE_INT >= 64
2776 if (TYPE_OK (intTI_type_node
))
2777 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2779 if (TYPE_OK (intDI_type_node
))
2780 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2781 if (TYPE_OK (intSI_type_node
))
2782 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2783 if (TYPE_OK (intHI_type_node
))
2784 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2785 if (TYPE_OK (intQI_type_node
))
2786 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2789 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2792 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2795 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
2799 /* Extended integer types of the same width as a standard type have
2800 lesser rank, so those of the same width as int promote to int or
2801 unsigned int and are valid for printf formats expecting int or
2802 unsigned int. To avoid such special cases, avoid creating
2803 extended integer types for bit-fields if a standard integer type
2805 if (width
== TYPE_PRECISION (integer_type_node
))
2806 return unsignedp
? unsigned_type_node
: integer_type_node
;
2807 if (width
== TYPE_PRECISION (signed_char_type_node
))
2808 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2809 if (width
== TYPE_PRECISION (short_integer_type_node
))
2810 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2811 if (width
== TYPE_PRECISION (long_integer_type_node
))
2812 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2813 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
2814 return (unsignedp
? long_long_unsigned_type_node
2815 : long_long_integer_type_node
);
2816 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2817 if (int_n_enabled_p
[i
]
2818 && width
== int_n_data
[i
].bitsize
)
2819 return (unsignedp
? int_n_trees
[i
].unsigned_type
2820 : int_n_trees
[i
].signed_type
);
2821 return build_nonstandard_integer_type (width
, unsignedp
);
2824 /* The C version of the register_builtin_type langhook. */
2827 c_register_builtin_type (tree type
, const char* name
)
2831 decl
= build_decl (UNKNOWN_LOCATION
,
2832 TYPE_DECL
, get_identifier (name
), type
);
2833 DECL_ARTIFICIAL (decl
) = 1;
2834 if (!TYPE_NAME (type
))
2835 TYPE_NAME (type
) = decl
;
2836 lang_hooks
.decls
.pushdecl (decl
);
2838 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
2841 /* Print an error message for invalid operands to arith operation
2842 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
2843 RICHLOC is a rich location for the message, containing either
2844 three separate locations for each of the operator and operands
2849 (C FE), or one location ranging over all over them
2857 binary_op_error (rich_location
*richloc
, enum tree_code code
,
2858 tree type0
, tree type1
)
2865 opname
= "+"; break;
2867 opname
= "-"; break;
2869 opname
= "*"; break;
2871 opname
= "max"; break;
2873 opname
= "min"; break;
2875 opname
= "=="; break;
2877 opname
= "!="; break;
2879 opname
= "<="; break;
2881 opname
= ">="; break;
2883 opname
= "<"; break;
2885 opname
= ">"; break;
2887 opname
= "<<"; break;
2889 opname
= ">>"; break;
2890 case TRUNC_MOD_EXPR
:
2891 case FLOOR_MOD_EXPR
:
2892 opname
= "%"; break;
2893 case TRUNC_DIV_EXPR
:
2894 case FLOOR_DIV_EXPR
:
2895 opname
= "/"; break;
2897 opname
= "&"; break;
2899 opname
= "|"; break;
2900 case TRUTH_ANDIF_EXPR
:
2901 opname
= "&&"; break;
2902 case TRUTH_ORIF_EXPR
:
2903 opname
= "||"; break;
2905 opname
= "^"; break;
2910 "invalid operands to binary %s (have %qT and %qT)",
2911 opname
, type0
, type1
);
2914 /* Given an expression as a tree, return its original type. Do this
2915 by stripping any conversion that preserves the sign and precision. */
2917 expr_original_type (tree expr
)
2919 STRIP_SIGN_NOPS (expr
);
2920 return TREE_TYPE (expr
);
2923 /* Subroutine of build_binary_op, used for comparison operations.
2924 See if the operands have both been converted from subword integer types
2925 and, if so, perhaps change them both back to their original type.
2926 This function is also responsible for converting the two operands
2927 to the proper common type for comparison.
2929 The arguments of this function are all pointers to local variables
2930 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2931 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2933 LOC is the location of the comparison.
2935 If this function returns non-NULL_TREE, it means that the comparison has
2936 a constant value. What this function returns is an expression for
2940 shorten_compare (location_t loc
, tree
*op0_ptr
, tree
*op1_ptr
,
2941 tree
*restype_ptr
, enum tree_code
*rescode_ptr
)
2944 tree op0
= *op0_ptr
;
2945 tree op1
= *op1_ptr
;
2946 int unsignedp0
, unsignedp1
;
2948 tree primop0
, primop1
;
2949 enum tree_code code
= *rescode_ptr
;
2951 /* Throw away any conversions to wider types
2952 already present in the operands. */
2954 primop0
= c_common_get_narrower (op0
, &unsignedp0
);
2955 primop1
= c_common_get_narrower (op1
, &unsignedp1
);
2957 /* If primopN is first sign-extended from primopN's precision to opN's
2958 precision, then zero-extended from opN's precision to
2959 *restype_ptr precision, shortenings might be invalid. */
2960 if (TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (TREE_TYPE (op0
))
2961 && TYPE_PRECISION (TREE_TYPE (op0
)) < TYPE_PRECISION (*restype_ptr
)
2963 && TYPE_UNSIGNED (TREE_TYPE (op0
)))
2965 if (TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (TREE_TYPE (op1
))
2966 && TYPE_PRECISION (TREE_TYPE (op1
)) < TYPE_PRECISION (*restype_ptr
)
2968 && TYPE_UNSIGNED (TREE_TYPE (op1
)))
2971 /* Handle the case that OP0 does not *contain* a conversion
2972 but it *requires* conversion to FINAL_TYPE. */
2974 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2975 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2976 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2977 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2979 /* If one of the operands must be floated, we cannot optimize. */
2980 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2981 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2983 /* If first arg is constant, swap the args (changing operation
2984 so value is preserved), for canonicalization. Don't do this if
2985 the second arg is 0. */
2987 if (TREE_CONSTANT (primop0
)
2988 && !integer_zerop (primop1
) && !real_zerop (primop1
)
2989 && !fixed_zerop (primop1
))
2991 std::swap (primop0
, primop1
);
2992 std::swap (op0
, op1
);
2995 std::swap (unsignedp0
, unsignedp1
);
2996 std::swap (real1
, real2
);
3015 *rescode_ptr
= code
;
3018 /* If comparing an integer against a constant more bits wide,
3019 maybe we can deduce a value of 1 or 0 independent of the data.
3020 Or else truncate the constant now
3021 rather than extend the variable at run time.
3023 This is only interesting if the constant is the wider arg.
3024 Also, it is not safe if the constant is unsigned and the
3025 variable arg is signed, since in this case the variable
3026 would be sign-extended and then regarded as unsigned.
3027 Our technique fails in this case because the lowest/highest
3028 possible unsigned results don't follow naturally from the
3029 lowest/highest possible values of the variable operand.
3030 For just EQ_EXPR and NE_EXPR there is another technique that
3031 could be used: see if the constant can be faithfully represented
3032 in the other operand's type, by truncating it and reextending it
3033 and see if that preserves the constant's value. */
3035 if (!real1
&& !real2
3036 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
3037 && TREE_CODE (primop1
) == INTEGER_CST
3038 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
3040 int min_gt
, max_gt
, min_lt
, max_lt
;
3041 tree maxval
, minval
;
3042 /* 1 if comparison is nominally unsigned. */
3043 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
3046 type
= c_common_signed_or_unsigned_type (unsignedp0
,
3047 TREE_TYPE (primop0
));
3049 maxval
= TYPE_MAX_VALUE (type
);
3050 minval
= TYPE_MIN_VALUE (type
);
3052 if (unsignedp
&& !unsignedp0
)
3053 *restype_ptr
= c_common_signed_type (*restype_ptr
);
3055 if (TREE_TYPE (primop1
) != *restype_ptr
)
3057 /* Convert primop1 to target type, but do not introduce
3058 additional overflow. We know primop1 is an int_cst. */
3059 primop1
= force_fit_type (*restype_ptr
,
3062 TYPE_PRECISION (*restype_ptr
)),
3063 0, TREE_OVERFLOW (primop1
));
3065 if (type
!= *restype_ptr
)
3067 minval
= convert (*restype_ptr
, minval
);
3068 maxval
= convert (*restype_ptr
, maxval
);
3071 min_gt
= tree_int_cst_lt (primop1
, minval
);
3072 max_gt
= tree_int_cst_lt (primop1
, maxval
);
3073 min_lt
= tree_int_cst_lt (minval
, primop1
);
3074 max_lt
= tree_int_cst_lt (maxval
, primop1
);
3077 /* This used to be a switch, but Genix compiler can't handle that. */
3078 if (code
== NE_EXPR
)
3080 if (max_lt
|| min_gt
)
3081 val
= truthvalue_true_node
;
3083 else if (code
== EQ_EXPR
)
3085 if (max_lt
|| min_gt
)
3086 val
= truthvalue_false_node
;
3088 else if (code
== LT_EXPR
)
3091 val
= truthvalue_true_node
;
3093 val
= truthvalue_false_node
;
3095 else if (code
== GT_EXPR
)
3098 val
= truthvalue_true_node
;
3100 val
= truthvalue_false_node
;
3102 else if (code
== LE_EXPR
)
3105 val
= truthvalue_true_node
;
3107 val
= truthvalue_false_node
;
3109 else if (code
== GE_EXPR
)
3112 val
= truthvalue_true_node
;
3114 val
= truthvalue_false_node
;
3117 /* If primop0 was sign-extended and unsigned comparison specd,
3118 we did a signed comparison above using the signed type bounds.
3119 But the comparison we output must be unsigned.
3121 Also, for inequalities, VAL is no good; but if the signed
3122 comparison had *any* fixed result, it follows that the
3123 unsigned comparison just tests the sign in reverse
3124 (positive values are LE, negative ones GE).
3125 So we can generate an unsigned comparison
3126 against an extreme value of the signed type. */
3128 if (unsignedp
&& !unsignedp0
)
3135 primop1
= TYPE_MIN_VALUE (type
);
3141 primop1
= TYPE_MAX_VALUE (type
);
3148 type
= c_common_unsigned_type (type
);
3151 if (TREE_CODE (primop0
) != INTEGER_CST
3152 /* Don't warn if it's from a (non-system) macro. */
3153 && !(from_macro_expansion_at
3154 (expansion_point_location_if_in_system_header
3155 (EXPR_LOCATION (primop0
)))))
3157 if (val
== truthvalue_false_node
)
3158 warning_at (loc
, OPT_Wtype_limits
,
3159 "comparison is always false due to limited range of data type");
3160 if (val
== truthvalue_true_node
)
3161 warning_at (loc
, OPT_Wtype_limits
,
3162 "comparison is always true due to limited range of data type");
3167 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3168 if (TREE_SIDE_EFFECTS (primop0
))
3169 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
3173 /* Value is not predetermined, but do the comparison
3174 in the type of the operand that is not constant.
3175 TYPE is already properly set. */
3178 /* If either arg is decimal float and the other is float, find the
3179 proper common type to use for comparison. */
3180 else if (real1
&& real2
3181 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3182 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
))))
3183 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3185 /* If either arg is decimal float and the other is float, fail. */
3186 else if (real1
&& real2
3187 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3188 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
3190 type
= *restype_ptr
;
3195 else if (real1
&& real2
3196 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3197 == TYPE_PRECISION (TREE_TYPE (primop1
))))
3198 type
= TREE_TYPE (primop0
);
3200 /* If args' natural types are both narrower than nominal type
3201 and both extend in the same manner, compare them
3202 in the type of the wider arg.
3203 Otherwise must actually extend both to the nominal
3204 common type lest different ways of extending
3206 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3208 else if (unsignedp0
== unsignedp1
&& real1
== real2
3209 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
3210 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
)
3211 && (type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
)))
3214 type
= c_common_signed_or_unsigned_type (unsignedp0
3215 || TYPE_UNSIGNED (*restype_ptr
),
3217 /* Make sure shorter operand is extended the right way
3218 to match the longer operand. */
3220 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
3221 TREE_TYPE (primop0
)),
3224 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
3225 TREE_TYPE (primop1
)),
3230 /* Here we must do the comparison on the nominal type
3231 using the args exactly as we received them. */
3232 type
= *restype_ptr
;
3236 /* We want to fold unsigned comparisons of >= and < against zero.
3237 For these, we may also issue a warning if we have a non-constant
3238 compared against zero, where the zero was spelled as "0" (rather
3239 than merely folding to it).
3240 If we have at least one constant, then op1 is constant
3241 and we may have a non-constant expression as op0. */
3242 if (!real1
&& !real2
&& integer_zerop (primop1
)
3243 && TYPE_UNSIGNED (*restype_ptr
))
3245 tree value
= NULL_TREE
;
3246 /* All unsigned values are >= 0, so we warn. However,
3247 if OP0 is a constant that is >= 0, the signedness of
3248 the comparison isn't an issue, so suppress the
3250 tree folded_op0
= fold_for_warn (op0
);
3252 warn_type_limits
&& !in_system_header_at (loc
)
3253 && !(TREE_CODE (folded_op0
) == INTEGER_CST
3254 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3256 /* Do not warn for enumeration types. */
3257 && (TREE_CODE (expr_original_type (folded_op0
)) != ENUMERAL_TYPE
);
3263 warning_at (loc
, OPT_Wtype_limits
,
3264 "comparison of unsigned expression in %<>= 0%> "
3266 value
= truthvalue_true_node
;
3271 warning_at (loc
, OPT_Wtype_limits
,
3272 "comparison of unsigned expression in %<< 0%> "
3274 value
= truthvalue_false_node
;
3281 if (value
!= NULL_TREE
)
3283 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3284 if (TREE_SIDE_EFFECTS (primop0
))
3285 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3292 *op0_ptr
= convert (type
, primop0
);
3293 *op1_ptr
= convert (type
, primop1
);
3295 *restype_ptr
= truthvalue_type_node
;
3300 /* Return a tree for the sum or difference (RESULTCODE says which)
3301 of pointer PTROP and integer INTOP. */
3304 pointer_int_sum (location_t loc
, enum tree_code resultcode
,
3305 tree ptrop
, tree intop
, bool complain
)
3309 /* The result is a pointer of the same type that is being added. */
3310 tree result_type
= TREE_TYPE (ptrop
);
3312 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3314 if (complain
&& warn_pointer_arith
)
3315 pedwarn (loc
, OPT_Wpointer_arith
,
3316 "pointer of type %<void *%> used in arithmetic");
3318 return error_mark_node
;
3319 size_exp
= integer_one_node
;
3321 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3323 if (complain
&& warn_pointer_arith
)
3324 pedwarn (loc
, OPT_Wpointer_arith
,
3325 "pointer to a function used in arithmetic");
3327 return error_mark_node
;
3328 size_exp
= integer_one_node
;
3330 else if (!verify_type_context (loc
, TCTX_POINTER_ARITH
,
3331 TREE_TYPE (result_type
)))
3332 size_exp
= integer_one_node
;
3335 if (!complain
&& !COMPLETE_TYPE_P (TREE_TYPE (result_type
)))
3336 return error_mark_node
;
3337 size_exp
= size_in_bytes_loc (loc
, TREE_TYPE (result_type
));
3338 /* Wrap the pointer expression in a SAVE_EXPR to make sure it
3339 is evaluated first when the size expression may depend
3340 on it for VM types. */
3341 if (TREE_SIDE_EFFECTS (size_exp
)
3342 && TREE_SIDE_EFFECTS (ptrop
)
3343 && variably_modified_type_p (TREE_TYPE (ptrop
), NULL
))
3345 ptrop
= save_expr (ptrop
);
3346 size_exp
= build2 (COMPOUND_EXPR
, TREE_TYPE (intop
), ptrop
, size_exp
);
3350 /* We are manipulating pointer values, so we don't need to warn
3351 about relying on undefined signed overflow. We disable the
3352 warning here because we use integer types so fold won't know that
3353 they are really pointers. */
3354 fold_defer_overflow_warnings ();
3356 /* If what we are about to multiply by the size of the elements
3357 contains a constant term, apply distributive law
3358 and multiply that constant term separately.
3359 This helps produce common subexpressions. */
3360 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3361 && !TREE_CONSTANT (intop
)
3362 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3363 && TREE_CONSTANT (size_exp
)
3364 /* If the constant comes from pointer subtraction,
3365 skip this optimization--it would cause an error. */
3366 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
3367 /* If the constant is unsigned, and smaller than the pointer size,
3368 then we must skip this optimization. This is because it could cause
3369 an overflow error if the constant is negative but INTOP is not. */
3370 && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (intop
))
3371 || (TYPE_PRECISION (TREE_TYPE (intop
))
3372 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
3374 enum tree_code subcode
= resultcode
;
3375 tree int_type
= TREE_TYPE (intop
);
3376 if (TREE_CODE (intop
) == MINUS_EXPR
)
3377 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3378 /* Convert both subexpression types to the type of intop,
3379 because weird cases involving pointer arithmetic
3380 can result in a sum or difference with different type args. */
3381 ptrop
= build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop
, 1)),
3383 convert (int_type
, TREE_OPERAND (intop
, 1)),
3385 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
3388 /* Convert the integer argument to a type the same size as sizetype
3389 so the multiply won't overflow spuriously. */
3390 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
3391 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
3392 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
3393 TYPE_UNSIGNED (sizetype
)), intop
);
3395 /* Replace the integer argument with a suitable product by the object size.
3396 Do this multiplication as signed, then convert to the appropriate type
3397 for the pointer operation and disregard an overflow that occurred only
3398 because of the sign-extension change in the latter conversion. */
3400 tree t
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (intop
), intop
,
3401 convert (TREE_TYPE (intop
), size_exp
));
3402 intop
= convert (sizetype
, t
);
3403 if (TREE_OVERFLOW_P (intop
) && !TREE_OVERFLOW (t
))
3404 intop
= wide_int_to_tree (TREE_TYPE (intop
), wi::to_wide (intop
));
3407 /* Create the sum or difference. */
3408 if (resultcode
== MINUS_EXPR
)
3409 intop
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, intop
);
3411 ret
= fold_build_pointer_plus_loc (loc
, ptrop
, intop
);
3413 fold_undefer_and_ignore_overflow_warnings ();
3418 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3419 and if NON_CONST is known not to be permitted in an evaluated part
3420 of a constant expression. */
3423 c_wrap_maybe_const (tree expr
, bool non_const
)
3425 location_t loc
= EXPR_LOCATION (expr
);
3427 /* This should never be called for C++. */
3428 if (c_dialect_cxx ())
3431 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3432 STRIP_TYPE_NOPS (expr
);
3433 expr
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL
, expr
);
3434 C_MAYBE_CONST_EXPR_NON_CONST (expr
) = non_const
;
3435 protected_set_expr_location (expr
, loc
);
3440 /* Return whether EXPR is a declaration whose address can never be NULL.
3441 The address of the first struct member could be NULL only if it were
3442 accessed through a NULL pointer, and such an access would be invalid.
3443 The address of a weak symbol may be null unless it has a definition. */
3446 decl_with_nonnull_addr_p (const_tree expr
)
3451 if (TREE_CODE (expr
) == FIELD_DECL
3452 || TREE_CODE (expr
) == PARM_DECL
3453 || TREE_CODE (expr
) == LABEL_DECL
)
3456 if (!VAR_OR_FUNCTION_DECL_P (expr
))
3459 if (!DECL_WEAK (expr
))
3460 /* Ordinary (non-weak) symbols have nonnull addresses. */
3463 if (DECL_INITIAL (expr
) && DECL_INITIAL (expr
) != error_mark_node
)
3464 /* Initialized weak symbols have nonnull addresses. */
3467 if (DECL_EXTERNAL (expr
) || !TREE_STATIC (expr
))
3468 /* Uninitialized extern weak symbols and weak symbols with no
3469 allocated storage might have a null address. */
3472 tree attribs
= DECL_ATTRIBUTES (expr
);
3473 if (lookup_attribute ("weakref", attribs
))
3474 /* Weakref symbols might have a null address unless their referent
3475 is known not to. Don't bother following weakref targets here. */
3481 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3482 or for an `if' or `while' statement or ?..: exp. It should already
3483 have been validated to be of suitable type; otherwise, a bad
3484 diagnostic may result.
3486 The EXPR is located at LOCATION.
3488 This preparation consists of taking the ordinary
3489 representation of an expression expr and producing a valid tree
3490 boolean expression describing whether expr is nonzero. We could
3491 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3492 but we optimize comparisons, &&, ||, and !.
3494 The resulting type should always be `truthvalue_type_node'. */
3497 c_common_truthvalue_conversion (location_t location
, tree expr
)
3499 STRIP_ANY_LOCATION_WRAPPER (expr
);
3500 switch (TREE_CODE (expr
))
3502 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
3503 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3504 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
3505 case ORDERED_EXPR
: case UNORDERED_EXPR
:
3506 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3508 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3509 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
3512 case TRUTH_ANDIF_EXPR
:
3513 case TRUTH_ORIF_EXPR
:
3514 case TRUTH_AND_EXPR
:
3516 case TRUTH_XOR_EXPR
:
3517 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3519 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3520 c_common_truthvalue_conversion (location
,
3521 TREE_OPERAND (expr
, 0)),
3522 c_common_truthvalue_conversion (location
,
3523 TREE_OPERAND (expr
, 1)));
3526 case TRUTH_NOT_EXPR
:
3527 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3529 expr
= build1 (TREE_CODE (expr
), truthvalue_type_node
,
3530 c_common_truthvalue_conversion (location
,
3531 TREE_OPERAND (expr
, 0)));
3538 if (TREE_CODE (TREE_TYPE (expr
)) == ENUMERAL_TYPE
3539 && !integer_zerop (expr
)
3540 && !integer_onep (expr
))
3541 warning_at (location
, OPT_Wint_in_bool_context
,
3542 "enum constant in boolean context");
3543 return integer_zerop (expr
) ? truthvalue_false_node
3544 : truthvalue_true_node
;
3547 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3548 ? truthvalue_true_node
3549 : truthvalue_false_node
;
3552 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3553 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3554 ? truthvalue_true_node
3555 : truthvalue_false_node
;
3558 expr
= build_unary_op (location
, ADDR_EXPR
, expr
, false);
3563 tree inner
= TREE_OPERAND (expr
, 0);
3564 if (decl_with_nonnull_addr_p (inner
)
3565 /* Check both EXPR and INNER for suppression. */
3566 && !warning_suppressed_p (expr
, OPT_Waddress
)
3567 && !warning_suppressed_p (inner
, OPT_Waddress
))
3569 /* Common Ada programmer's mistake. */
3570 warning_at (location
,
3572 "the address of %qD will always evaluate as %<true%>",
3574 suppress_warning (inner
, OPT_Waddress
);
3575 return truthvalue_true_node
;
3581 expr
= build_binary_op (EXPR_LOCATION (expr
),
3582 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3583 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3584 c_common_truthvalue_conversion (location
,
3585 TREE_OPERAND (expr
, 0)),
3586 c_common_truthvalue_conversion (location
,
3587 TREE_OPERAND (expr
, 1)),
3595 case EXCESS_PRECISION_EXPR
:
3596 /* These don't change whether an object is nonzero or zero. */
3597 return c_common_truthvalue_conversion (location
, TREE_OPERAND (expr
, 0));
3601 /* These don't change whether an object is zero or nonzero, but
3602 we can't ignore them if their second arg has side-effects. */
3603 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3605 expr
= build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3606 TREE_OPERAND (expr
, 1),
3607 c_common_truthvalue_conversion
3608 (location
, TREE_OPERAND (expr
, 0)));
3612 return c_common_truthvalue_conversion (location
,
3613 TREE_OPERAND (expr
, 0));
3616 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3617 "%<*%> in boolean context, suggest %<&&%> instead");
3621 /* We will only warn on signed shifts here, because the majority of
3622 false positive warnings happen in code where unsigned arithmetic
3623 was used in anticipation of a possible overflow.
3624 Furthermore, if we see an unsigned type here we know that the
3625 result of the shift is not subject to integer promotion rules. */
3626 if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
3627 && !TYPE_UNSIGNED (TREE_TYPE (expr
)))
3628 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3629 "%<<<%> in boolean context, did you mean %<<%>?");
3633 if (warn_int_in_bool_context
3634 && !from_macro_definition_at (EXPR_LOCATION (expr
)))
3636 tree val1
= fold_for_warn (TREE_OPERAND (expr
, 1));
3637 tree val2
= fold_for_warn (TREE_OPERAND (expr
, 2));
3638 if (TREE_CODE (val1
) == INTEGER_CST
3639 && TREE_CODE (val2
) == INTEGER_CST
3640 && !integer_zerop (val1
)
3641 && !integer_zerop (val2
)
3642 && (!integer_onep (val1
)
3643 || !integer_onep (val2
)))
3644 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3645 "%<?:%> using integer constants in boolean context, "
3646 "the expression will always evaluate to %<true%>");
3647 else if ((TREE_CODE (val1
) == INTEGER_CST
3648 && !integer_zerop (val1
)
3649 && !integer_onep (val1
))
3650 || (TREE_CODE (val2
) == INTEGER_CST
3651 && !integer_zerop (val2
)
3652 && !integer_onep (val2
)))
3653 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3654 "%<?:%> using integer constants in boolean context");
3656 /* Distribute the conversion into the arms of a COND_EXPR. */
3657 if (c_dialect_cxx ())
3658 /* Avoid premature folding. */
3662 int w
= warn_int_in_bool_context
;
3663 warn_int_in_bool_context
= 0;
3664 /* Folding will happen later for C. */
3665 expr
= build3 (COND_EXPR
, truthvalue_type_node
,
3666 TREE_OPERAND (expr
, 0),
3667 c_common_truthvalue_conversion (location
,
3668 TREE_OPERAND (expr
, 1)),
3669 c_common_truthvalue_conversion (location
,
3670 TREE_OPERAND (expr
, 2)));
3671 warn_int_in_bool_context
= w
;
3677 tree totype
= TREE_TYPE (expr
);
3678 tree fromtype
= TREE_TYPE (TREE_OPERAND (expr
, 0));
3680 if (POINTER_TYPE_P (totype
)
3681 && !c_inhibit_evaluation_warnings
3682 && TREE_CODE (fromtype
) == REFERENCE_TYPE
)
3688 warning_at (location
,
3690 "the compiler can assume that the address of "
3691 "%qD will always evaluate to %<true%>",
3695 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3696 since that affects how `default_conversion' will behave. */
3697 if (TREE_CODE (totype
) == REFERENCE_TYPE
3698 || TREE_CODE (fromtype
) == REFERENCE_TYPE
)
3700 /* Don't strip a conversion from C++0x scoped enum, since they
3701 don't implicitly convert to other types. */
3702 if (TREE_CODE (fromtype
) == ENUMERAL_TYPE
3703 && ENUM_IS_SCOPED (fromtype
))
3705 /* If this isn't narrowing the argument, we can ignore it. */
3706 if (TYPE_PRECISION (totype
) >= TYPE_PRECISION (fromtype
))
3708 tree op0
= TREE_OPERAND (expr
, 0);
3709 if ((TREE_CODE (fromtype
) == POINTER_TYPE
3710 && TREE_CODE (totype
) == INTEGER_TYPE
)
3711 || warning_suppressed_p (expr
, OPT_Waddress
))
3712 /* Suppress -Waddress for casts to intptr_t, propagating
3713 any suppression from the enclosing expression to its
3715 suppress_warning (op0
, OPT_Waddress
);
3716 return c_common_truthvalue_conversion (location
, op0
);
3722 if (!warning_suppressed_p (expr
, OPT_Wparentheses
)
3724 && warning_at (location
, OPT_Wparentheses
,
3725 "suggest parentheses around assignment used as "
3727 suppress_warning (expr
, OPT_Wparentheses
);
3732 tree folded_expr
= fold_for_warn (expr
);
3733 if (folded_expr
!= expr
)
3734 return c_common_truthvalue_conversion (location
, folded_expr
);
3742 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
3744 tree t
= save_expr (expr
);
3745 expr
= (build_binary_op
3746 (EXPR_LOCATION (expr
),
3747 (TREE_SIDE_EFFECTS (expr
)
3748 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3749 c_common_truthvalue_conversion
3751 build_unary_op (location
, REALPART_EXPR
, t
, false)),
3752 c_common_truthvalue_conversion
3754 build_unary_op (location
, IMAGPART_EXPR
, t
, false)),
3759 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
3761 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
3763 (TREE_TYPE (expr
))));
3764 return build_binary_op (location
, NE_EXPR
, expr
, fixed_zero_node
, true);
3767 return build_binary_op (location
, NE_EXPR
, expr
, integer_zero_node
, true);
3770 protected_set_expr_location (expr
, location
);
3774 static void def_builtin_1 (enum built_in_function fncode
,
3776 enum built_in_class fnclass
,
3777 tree fntype
, tree libtype
,
3778 bool both_p
, bool fallback_p
, bool nonansi_p
,
3779 tree fnattrs
, bool implicit_p
);
3782 /* Apply the TYPE_QUALS to the new DECL. */
3785 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
3787 tree type
= TREE_TYPE (decl
);
3789 if (type
== error_mark_node
)
3792 if ((type_quals
& TYPE_QUAL_CONST
)
3793 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
3794 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
3795 constructor can produce constant init, so rely on cp_finish_decl to
3796 clear TREE_READONLY if the variable has non-constant init. */
3797 TREE_READONLY (decl
) = 1;
3798 if (type_quals
& TYPE_QUAL_VOLATILE
)
3800 TREE_SIDE_EFFECTS (decl
) = 1;
3801 TREE_THIS_VOLATILE (decl
) = 1;
3803 if (type_quals
& TYPE_QUAL_RESTRICT
)
3805 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
3806 /* Allow 'restrict' on arrays of pointers.
3807 FIXME currently we just ignore it. */
3808 type
= TREE_TYPE (type
);
3810 || !POINTER_TYPE_P (type
)
3811 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
3812 error ("invalid use of %<restrict%>");
3816 /* Return the typed-based alias set for T, which may be an expression
3817 or a type. Return -1 if we don't do anything special. */
3820 c_common_get_alias_set (tree t
)
3822 /* For VLAs, use the alias set of the element type rather than the
3823 default of alias set 0 for types compared structurally. */
3824 if (TYPE_P (t
) && TYPE_STRUCTURAL_EQUALITY_P (t
))
3826 if (TREE_CODE (t
) == ARRAY_TYPE
)
3827 return get_alias_set (TREE_TYPE (t
));
3831 /* That's all the expressions we handle specially. */
3835 /* Unlike char, char8_t doesn't alias. */
3836 if (flag_char8_t
&& t
== char8_type_node
)
3839 /* The C standard guarantees that any object may be accessed via an
3840 lvalue that has narrow character type (except char8_t). */
3841 if (t
== char_type_node
3842 || t
== signed_char_type_node
3843 || t
== unsigned_char_type_node
)
3846 /* The C standard specifically allows aliasing between signed and
3847 unsigned variants of the same type. We treat the signed
3848 variant as canonical. */
3849 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
3851 tree t1
= c_common_signed_type (t
);
3853 /* t1 == t can happen for boolean nodes which are always unsigned. */
3855 return get_alias_set (t1
);
3861 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
3862 the IS_SIZEOF parameter indicates which operator is being applied.
3863 The COMPLAIN flag controls whether we should diagnose possibly
3864 ill-formed constructs or not. LOC is the location of the SIZEOF or
3865 TYPEOF operator. If MIN_ALIGNOF, the least alignment required for
3866 a type in any context should be returned, rather than the normal
3867 alignment for that type. */
3870 c_sizeof_or_alignof_type (location_t loc
,
3871 tree type
, bool is_sizeof
, bool min_alignof
,
3874 const char *op_name
;
3876 enum tree_code type_code
= TREE_CODE (type
);
3878 op_name
= is_sizeof
? "sizeof" : "__alignof__";
3880 if (type_code
== FUNCTION_TYPE
)
3884 if (complain
&& warn_pointer_arith
)
3885 pedwarn (loc
, OPT_Wpointer_arith
,
3886 "invalid application of %<sizeof%> to a function type");
3888 return error_mark_node
;
3889 value
= size_one_node
;
3895 if (c_dialect_cxx ())
3896 pedwarn (loc
, OPT_Wpedantic
, "ISO C++ does not permit "
3897 "%<alignof%> applied to a function type");
3899 pedwarn (loc
, OPT_Wpedantic
, "ISO C does not permit "
3900 "%<_Alignof%> applied to a function type");
3902 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3905 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3907 if (type_code
== VOID_TYPE
3908 && complain
&& warn_pointer_arith
)
3909 pedwarn (loc
, OPT_Wpointer_arith
,
3910 "invalid application of %qs to a void type", op_name
);
3912 return error_mark_node
;
3913 value
= size_one_node
;
3915 else if (!COMPLETE_TYPE_P (type
)
3916 && (!c_dialect_cxx () || is_sizeof
|| type_code
!= ARRAY_TYPE
))
3919 error_at (loc
, "invalid application of %qs to incomplete type %qT",
3921 return error_mark_node
;
3923 else if (c_dialect_cxx () && type_code
== ARRAY_TYPE
3924 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
3927 error_at (loc
, "invalid application of %qs to array type %qT of "
3928 "incomplete element type", op_name
, type
);
3929 return error_mark_node
;
3931 else if (!verify_type_context (loc
, is_sizeof
? TCTX_SIZEOF
: TCTX_ALIGNOF
,
3935 return error_mark_node
;
3936 value
= size_one_node
;
3941 /* Convert in case a char is more than one unit. */
3942 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3943 size_int (TYPE_PRECISION (char_type_node
)
3945 else if (min_alignof
)
3946 value
= size_int (min_align_of_type (type
));
3948 value
= size_int (TYPE_ALIGN_UNIT (type
));
3951 /* VALUE will have the middle-end integer type sizetype.
3952 However, we should really return a value of type `size_t',
3953 which is just a typedef for an ordinary integer type. */
3954 value
= fold_convert_loc (loc
, size_type_node
, value
);
3959 /* Implement the __alignof keyword: Return the minimum required
3960 alignment of EXPR, measured in bytes. For VAR_DECLs,
3961 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3962 from an "aligned" __attribute__ specification). LOC is the
3963 location of the ALIGNOF operator. */
3966 c_alignof_expr (location_t loc
, tree expr
)
3970 if (!verify_type_context (loc
, TCTX_ALIGNOF
, TREE_TYPE (expr
)))
3973 else if (VAR_OR_FUNCTION_DECL_P (expr
))
3974 t
= size_int (DECL_ALIGN_UNIT (expr
));
3976 else if (TREE_CODE (expr
) == COMPONENT_REF
3977 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3979 error_at (loc
, "%<__alignof%> applied to a bit-field");
3982 else if (TREE_CODE (expr
) == COMPONENT_REF
3983 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3984 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
3986 else if (INDIRECT_REF_P (expr
))
3988 tree t
= TREE_OPERAND (expr
, 0);
3990 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3992 while (CONVERT_EXPR_P (t
)
3993 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3997 t
= TREE_OPERAND (t
, 0);
3998 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3999 if (thisalign
> bestalign
)
4000 best
= t
, bestalign
= thisalign
;
4002 return c_alignof (loc
, TREE_TYPE (TREE_TYPE (best
)));
4005 return c_alignof (loc
, TREE_TYPE (expr
));
4007 return fold_convert_loc (loc
, size_type_node
, t
);
4010 /* Handle C and C++ default attributes. */
4012 enum built_in_attribute
4014 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4015 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4016 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
4017 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4018 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4019 #include "builtin-attrs.def"
4020 #undef DEF_ATTR_NULL_TREE
4022 #undef DEF_ATTR_STRING
4023 #undef DEF_ATTR_IDENT
4024 #undef DEF_ATTR_TREE_LIST
4028 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
4030 static void c_init_attributes (void);
4034 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4035 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4036 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4037 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4038 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4039 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4040 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4041 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4043 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4045 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4046 ARG6, ARG7, ARG8) NAME,
4047 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4048 ARG6, ARG7, ARG8, ARG9) NAME,
4049 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4050 ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
4051 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4052 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
4053 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4054 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4055 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4056 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4057 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4058 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4060 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4062 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4064 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4065 #include "builtin-types.def"
4066 #undef DEF_PRIMITIVE_TYPE
4067 #undef DEF_FUNCTION_TYPE_0
4068 #undef DEF_FUNCTION_TYPE_1
4069 #undef DEF_FUNCTION_TYPE_2
4070 #undef DEF_FUNCTION_TYPE_3
4071 #undef DEF_FUNCTION_TYPE_4
4072 #undef DEF_FUNCTION_TYPE_5
4073 #undef DEF_FUNCTION_TYPE_6
4074 #undef DEF_FUNCTION_TYPE_7
4075 #undef DEF_FUNCTION_TYPE_8
4076 #undef DEF_FUNCTION_TYPE_9
4077 #undef DEF_FUNCTION_TYPE_10
4078 #undef DEF_FUNCTION_TYPE_11
4079 #undef DEF_FUNCTION_TYPE_VAR_0
4080 #undef DEF_FUNCTION_TYPE_VAR_1
4081 #undef DEF_FUNCTION_TYPE_VAR_2
4082 #undef DEF_FUNCTION_TYPE_VAR_3
4083 #undef DEF_FUNCTION_TYPE_VAR_4
4084 #undef DEF_FUNCTION_TYPE_VAR_5
4085 #undef DEF_FUNCTION_TYPE_VAR_6
4086 #undef DEF_FUNCTION_TYPE_VAR_7
4087 #undef DEF_POINTER_TYPE
4091 typedef enum c_builtin_type builtin_type
;
4093 /* A temporary array for c_common_nodes_and_builtins. Used in
4094 communication with def_fn_type. */
4095 static tree builtin_types
[(int) BT_LAST
+ 1];
4097 /* A helper function for c_common_nodes_and_builtins. Build function type
4098 for DEF with return type RET and N arguments. If VAR is true, then the
4099 function should be variadic after those N arguments.
4101 Takes special care not to ICE if any of the types involved are
4102 error_mark_node, which indicates that said type is not in fact available
4103 (see builtin_type_for_size). In which case the function type as a whole
4104 should be error_mark_node. */
4107 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
4110 tree
*args
= XALLOCAVEC (tree
, n
);
4115 for (i
= 0; i
< n
; ++i
)
4117 builtin_type a
= (builtin_type
) va_arg (list
, int);
4118 t
= builtin_types
[a
];
4119 if (t
== error_mark_node
)
4124 t
= builtin_types
[ret
];
4125 if (t
== error_mark_node
)
4128 t
= build_varargs_function_type_array (t
, n
, args
);
4130 t
= build_function_type_array (t
, n
, args
);
4133 builtin_types
[def
] = t
;
4137 /* Build builtin functions common to both C and C++ language
4141 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
4143 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4144 builtin_types[ENUM] = VALUE;
4145 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4146 def_fn_type (ENUM, RETURN, 0, 0);
4147 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4148 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4149 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4150 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4151 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4152 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4153 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4154 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4155 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4156 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4157 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4159 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4160 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4162 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4163 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4165 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
4167 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4168 ARG6, ARG7, ARG8, ARG9) \
4169 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
4171 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4172 ARG6, ARG7, ARG8, ARG9, ARG10) \
4173 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
4174 ARG7, ARG8, ARG9, ARG10);
4175 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4176 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
4177 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
4178 ARG7, ARG8, ARG9, ARG10, ARG11);
4179 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4180 def_fn_type (ENUM, RETURN, 1, 0);
4181 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4182 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4183 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4184 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4185 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4186 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4187 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4188 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4189 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4190 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4191 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4193 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4194 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4196 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4197 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4198 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4200 #include "builtin-types.def"
4202 #undef DEF_PRIMITIVE_TYPE
4203 #undef DEF_FUNCTION_TYPE_0
4204 #undef DEF_FUNCTION_TYPE_1
4205 #undef DEF_FUNCTION_TYPE_2
4206 #undef DEF_FUNCTION_TYPE_3
4207 #undef DEF_FUNCTION_TYPE_4
4208 #undef DEF_FUNCTION_TYPE_5
4209 #undef DEF_FUNCTION_TYPE_6
4210 #undef DEF_FUNCTION_TYPE_7
4211 #undef DEF_FUNCTION_TYPE_8
4212 #undef DEF_FUNCTION_TYPE_9
4213 #undef DEF_FUNCTION_TYPE_10
4214 #undef DEF_FUNCTION_TYPE_11
4215 #undef DEF_FUNCTION_TYPE_VAR_0
4216 #undef DEF_FUNCTION_TYPE_VAR_1
4217 #undef DEF_FUNCTION_TYPE_VAR_2
4218 #undef DEF_FUNCTION_TYPE_VAR_3
4219 #undef DEF_FUNCTION_TYPE_VAR_4
4220 #undef DEF_FUNCTION_TYPE_VAR_5
4221 #undef DEF_FUNCTION_TYPE_VAR_6
4222 #undef DEF_FUNCTION_TYPE_VAR_7
4223 #undef DEF_POINTER_TYPE
4224 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
4226 c_init_attributes ();
4228 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4229 NONANSI_P, ATTRS, IMPLICIT, COND) \
4231 def_builtin_1 (ENUM, NAME, CLASS, \
4232 builtin_types[(int) TYPE], \
4233 builtin_types[(int) LIBTYPE], \
4234 BOTH_P, FALLBACK_P, NONANSI_P, \
4235 built_in_attributes[(int) ATTRS], IMPLICIT);
4236 #include "builtins.def"
4238 targetm
.init_builtins ();
4240 build_common_builtin_nodes ();
4243 /* Like get_identifier, but avoid warnings about null arguments when
4244 the argument may be NULL for targets where GCC lacks stdint.h type
4248 c_get_ident (const char *id
)
4250 return get_identifier (id
);
4253 /* Build tree nodes and builtin functions common to both C and C++ language
4257 c_common_nodes_and_builtins (void)
4259 int char8_type_size
;
4260 int char16_type_size
;
4261 int char32_type_size
;
4262 int wchar_type_size
;
4263 tree array_domain_type
;
4264 tree va_list_ref_type_node
;
4265 tree va_list_arg_type_node
;
4268 build_common_tree_nodes (flag_signed_char
);
4270 /* Define `int' and `char' first so that dbx will output them first. */
4271 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
4272 record_builtin_type (RID_CHAR
, "char", char_type_node
);
4274 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4275 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4276 but not C. Are the conditionals here needed? */
4277 if (c_dialect_cxx ())
4278 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
4279 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
4280 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
4281 record_builtin_type (RID_MAX
, "long unsigned int",
4282 long_unsigned_type_node
);
4284 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
4288 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
4289 record_builtin_type ((enum rid
)(RID_FIRST_INT_N
+ i
), name
,
4290 int_n_trees
[i
].signed_type
);
4291 sprintf (name
, "__int%d__", int_n_data
[i
].bitsize
);
4292 record_builtin_type ((enum rid
)(RID_FIRST_INT_N
+ i
), name
,
4293 int_n_trees
[i
].signed_type
);
4294 ridpointers
[RID_FIRST_INT_N
+ i
]
4295 = DECL_NAME (TYPE_NAME (int_n_trees
[i
].signed_type
));
4297 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
4298 record_builtin_type (RID_MAX
, name
, int_n_trees
[i
].unsigned_type
);
4299 sprintf (name
, "__int%d__ unsigned", int_n_data
[i
].bitsize
);
4300 record_builtin_type (RID_MAX
, name
, int_n_trees
[i
].unsigned_type
);
4303 if (c_dialect_cxx ())
4304 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
4305 record_builtin_type (RID_MAX
, "long long int",
4306 long_long_integer_type_node
);
4307 record_builtin_type (RID_MAX
, "long long unsigned int",
4308 long_long_unsigned_type_node
);
4309 if (c_dialect_cxx ())
4310 record_builtin_type (RID_MAX
, "long long unsigned",
4311 long_long_unsigned_type_node
);
4312 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
4313 record_builtin_type (RID_MAX
, "short unsigned int",
4314 short_unsigned_type_node
);
4315 if (c_dialect_cxx ())
4316 record_builtin_type (RID_MAX
, "unsigned short",
4317 short_unsigned_type_node
);
4319 /* Define both `signed char' and `unsigned char'. */
4320 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
4321 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
4323 /* These are types that c_common_type_for_size and
4324 c_common_type_for_mode use. */
4325 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4326 TYPE_DECL
, NULL_TREE
,
4328 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4329 TYPE_DECL
, NULL_TREE
,
4331 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4332 TYPE_DECL
, NULL_TREE
,
4334 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4335 TYPE_DECL
, NULL_TREE
,
4337 #if HOST_BITS_PER_WIDE_INT >= 64
4338 /* Note that this is different than the __int128 type that's part of
4339 the generic __intN support. */
4340 if (targetm
.scalar_mode_supported_p (TImode
))
4341 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4343 get_identifier ("__int128_t"),
4346 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4347 TYPE_DECL
, NULL_TREE
,
4348 unsigned_intQI_type_node
));
4349 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4350 TYPE_DECL
, NULL_TREE
,
4351 unsigned_intHI_type_node
));
4352 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4353 TYPE_DECL
, NULL_TREE
,
4354 unsigned_intSI_type_node
));
4355 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4356 TYPE_DECL
, NULL_TREE
,
4357 unsigned_intDI_type_node
));
4358 #if HOST_BITS_PER_WIDE_INT >= 64
4359 if (targetm
.scalar_mode_supported_p (TImode
))
4360 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4362 get_identifier ("__uint128_t"),
4363 unsigned_intTI_type_node
));
4366 /* Create the widest literal types. */
4367 if (targetm
.scalar_mode_supported_p (TImode
))
4369 widest_integer_literal_type_node
= intTI_type_node
;
4370 widest_unsigned_literal_type_node
= unsigned_intTI_type_node
;
4374 widest_integer_literal_type_node
= intDI_type_node
;
4375 widest_unsigned_literal_type_node
= unsigned_intDI_type_node
;
4378 signed_size_type_node
= c_common_signed_type (size_type_node
);
4381 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
4383 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
4384 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
4385 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
4387 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
4389 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
)
4390 record_builtin_type ((enum rid
) (RID_FLOATN_NX_FIRST
+ i
), NULL
,
4391 FLOATN_NX_TYPE_NODE (i
));
4394 /* For C, let float128t_type_node (__float128 in some backends) be the
4395 same type as float128_type_node (_Float128), for C++ let those
4396 be distinct types that mangle and behave differently. */
4397 if (c_dialect_cxx ())
4398 float128t_type_node
= NULL_TREE
;
4400 /* Only supported decimal floating point extension if the target
4401 actually supports underlying modes. */
4402 if (targetm
.scalar_mode_supported_p (SDmode
)
4403 && targetm
.scalar_mode_supported_p (DDmode
)
4404 && targetm
.scalar_mode_supported_p (TDmode
))
4406 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
4407 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
4408 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
4411 if (targetm
.fixed_point_supported_p ())
4413 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
4414 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
4415 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
4416 record_builtin_type (RID_MAX
, "long long _Fract",
4417 long_long_fract_type_node
);
4418 record_builtin_type (RID_MAX
, "unsigned short _Fract",
4419 unsigned_short_fract_type_node
);
4420 record_builtin_type (RID_MAX
, "unsigned _Fract",
4421 unsigned_fract_type_node
);
4422 record_builtin_type (RID_MAX
, "unsigned long _Fract",
4423 unsigned_long_fract_type_node
);
4424 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
4425 unsigned_long_long_fract_type_node
);
4426 record_builtin_type (RID_MAX
, "_Sat short _Fract",
4427 sat_short_fract_type_node
);
4428 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
4429 record_builtin_type (RID_MAX
, "_Sat long _Fract",
4430 sat_long_fract_type_node
);
4431 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
4432 sat_long_long_fract_type_node
);
4433 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
4434 sat_unsigned_short_fract_type_node
);
4435 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
4436 sat_unsigned_fract_type_node
);
4437 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
4438 sat_unsigned_long_fract_type_node
);
4439 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
4440 sat_unsigned_long_long_fract_type_node
);
4441 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
4442 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
4443 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
4444 record_builtin_type (RID_MAX
, "long long _Accum",
4445 long_long_accum_type_node
);
4446 record_builtin_type (RID_MAX
, "unsigned short _Accum",
4447 unsigned_short_accum_type_node
);
4448 record_builtin_type (RID_MAX
, "unsigned _Accum",
4449 unsigned_accum_type_node
);
4450 record_builtin_type (RID_MAX
, "unsigned long _Accum",
4451 unsigned_long_accum_type_node
);
4452 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
4453 unsigned_long_long_accum_type_node
);
4454 record_builtin_type (RID_MAX
, "_Sat short _Accum",
4455 sat_short_accum_type_node
);
4456 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
4457 record_builtin_type (RID_MAX
, "_Sat long _Accum",
4458 sat_long_accum_type_node
);
4459 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
4460 sat_long_long_accum_type_node
);
4461 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
4462 sat_unsigned_short_accum_type_node
);
4463 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
4464 sat_unsigned_accum_type_node
);
4465 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
4466 sat_unsigned_long_accum_type_node
);
4467 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
4468 sat_unsigned_long_long_accum_type_node
);
4472 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4474 get_identifier ("complex int"),
4475 complex_integer_type_node
));
4476 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4478 get_identifier ("complex float"),
4479 complex_float_type_node
));
4480 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4482 get_identifier ("complex double"),
4483 complex_double_type_node
));
4484 lang_hooks
.decls
.pushdecl
4485 (build_decl (UNKNOWN_LOCATION
,
4486 TYPE_DECL
, get_identifier ("complex long double"),
4487 complex_long_double_type_node
));
4489 if (!c_dialect_cxx ())
4490 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
4491 if (COMPLEX_FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
)
4494 sprintf (buf
, "complex _Float%d%s", floatn_nx_types
[i
].n
,
4495 floatn_nx_types
[i
].extended
? "x" : "");
4496 lang_hooks
.decls
.pushdecl
4497 (build_decl (UNKNOWN_LOCATION
,
4499 get_identifier (buf
),
4500 COMPLEX_FLOATN_NX_TYPE_NODE (i
)));
4503 /* Make fileptr_type_node a distinct void * type until
4504 FILE type is defined. Likewise for const struct tm*. */
4505 for (unsigned i
= 0; i
< ARRAY_SIZE (builtin_structptr_types
); ++i
)
4506 builtin_structptr_types
[i
].node
4507 = build_variant_type_copy (builtin_structptr_types
[i
].base
);
4509 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
4511 /* Set the TYPE_NAME for any variants that were built before
4512 record_builtin_type gave names to the built-in types. */
4514 tree void_name
= TYPE_NAME (void_type_node
);
4515 TYPE_NAME (void_type_node
) = NULL_TREE
;
4516 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
4518 TYPE_NAME (void_type_node
) = void_name
;
4521 /* Make a type to be the domain of a few array types
4522 whose domains don't really matter.
4523 200 is small enough that it always fits in size_t
4524 and large enough that it can hold most function names for the
4525 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4526 array_domain_type
= build_index_type (size_int (200));
4528 /* Make a type for arrays of characters.
4529 With luck nothing will ever really depend on the length of this
4531 char_array_type_node
4532 = build_array_type (char_type_node
, array_domain_type
);
4534 string_type_node
= build_pointer_type (char_type_node
);
4535 const_string_type_node
4536 = build_pointer_type (build_qualified_type
4537 (char_type_node
, TYPE_QUAL_CONST
));
4539 /* This is special for C++ so functions can be overloaded. */
4540 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
4541 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
4542 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
4543 underlying_wchar_type_node
= wchar_type_node
;
4544 if (c_dialect_cxx ())
4546 if (TYPE_UNSIGNED (wchar_type_node
))
4547 wchar_type_node
= make_unsigned_type (wchar_type_size
);
4549 wchar_type_node
= make_signed_type (wchar_type_size
);
4550 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
4553 /* This is for wide string constants. */
4554 wchar_array_type_node
4555 = build_array_type (wchar_type_node
, array_domain_type
);
4557 /* Define 'char8_t'. */
4558 char8_type_node
= get_identifier (CHAR8_TYPE
);
4559 char8_type_node
= TREE_TYPE (identifier_global_value (char8_type_node
));
4560 char8_type_size
= TYPE_PRECISION (char8_type_node
);
4561 if (c_dialect_cxx ())
4563 char8_type_node
= make_unsigned_type (char8_type_size
);
4564 TYPE_STRING_FLAG (char8_type_node
) = true;
4567 record_builtin_type (RID_CHAR8
, "char8_t", char8_type_node
);
4570 /* This is for UTF-8 string constants. */
4571 char8_array_type_node
4572 = build_array_type (char8_type_node
, array_domain_type
);
4574 /* Define 'char16_t'. */
4575 char16_type_node
= get_identifier (CHAR16_TYPE
);
4576 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
4577 char16_type_size
= TYPE_PRECISION (char16_type_node
);
4578 if (c_dialect_cxx ())
4580 char16_type_node
= make_unsigned_type (char16_type_size
);
4582 if (cxx_dialect
>= cxx11
)
4583 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
4586 /* This is for UTF-16 string constants. */
4587 char16_array_type_node
4588 = build_array_type (char16_type_node
, array_domain_type
);
4590 /* Define 'char32_t'. */
4591 char32_type_node
= get_identifier (CHAR32_TYPE
);
4592 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
4593 char32_type_size
= TYPE_PRECISION (char32_type_node
);
4594 if (c_dialect_cxx ())
4596 char32_type_node
= make_unsigned_type (char32_type_size
);
4598 if (cxx_dialect
>= cxx11
)
4599 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
4602 /* This is for UTF-32 string constants. */
4603 char32_array_type_node
4604 = build_array_type (char32_type_node
, array_domain_type
);
4607 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
4610 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
4612 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
4614 if (SIG_ATOMIC_TYPE
)
4615 sig_atomic_type_node
=
4616 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE
)));
4619 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE
)));
4622 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE
)));
4625 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE
)));
4628 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE
)));
4631 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE
)));
4633 c_uint16_type_node
= uint16_type_node
=
4634 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE
)));
4636 c_uint32_type_node
= uint32_type_node
=
4637 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE
)));
4639 c_uint64_type_node
= uint64_type_node
=
4640 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE
)));
4641 if (INT_LEAST8_TYPE
)
4642 int_least8_type_node
=
4643 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE
)));
4644 if (INT_LEAST16_TYPE
)
4645 int_least16_type_node
=
4646 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE
)));
4647 if (INT_LEAST32_TYPE
)
4648 int_least32_type_node
=
4649 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE
)));
4650 if (INT_LEAST64_TYPE
)
4651 int_least64_type_node
=
4652 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE
)));
4653 if (UINT_LEAST8_TYPE
)
4654 uint_least8_type_node
=
4655 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE
)));
4656 if (UINT_LEAST16_TYPE
)
4657 uint_least16_type_node
=
4658 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE
)));
4659 if (UINT_LEAST32_TYPE
)
4660 uint_least32_type_node
=
4661 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE
)));
4662 if (UINT_LEAST64_TYPE
)
4663 uint_least64_type_node
=
4664 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE
)));
4666 int_fast8_type_node
=
4667 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE
)));
4668 if (INT_FAST16_TYPE
)
4669 int_fast16_type_node
=
4670 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE
)));
4671 if (INT_FAST32_TYPE
)
4672 int_fast32_type_node
=
4673 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE
)));
4674 if (INT_FAST64_TYPE
)
4675 int_fast64_type_node
=
4676 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE
)));
4677 if (UINT_FAST8_TYPE
)
4678 uint_fast8_type_node
=
4679 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE
)));
4680 if (UINT_FAST16_TYPE
)
4681 uint_fast16_type_node
=
4682 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE
)));
4683 if (UINT_FAST32_TYPE
)
4684 uint_fast32_type_node
=
4685 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE
)));
4686 if (UINT_FAST64_TYPE
)
4687 uint_fast64_type_node
=
4688 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE
)));
4691 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE
)));
4694 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE
)));
4696 default_function_type
4697 = build_varargs_function_type_list (integer_type_node
, NULL_TREE
);
4698 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
4700 lang_hooks
.decls
.pushdecl
4701 (build_decl (UNKNOWN_LOCATION
,
4702 TYPE_DECL
, get_identifier ("__builtin_va_list"),
4703 va_list_type_node
));
4704 if (targetm
.enum_va_list_p
)
4710 for (l
= 0; targetm
.enum_va_list_p (l
, &pname
, &ptype
); ++l
)
4712 lang_hooks
.decls
.pushdecl
4713 (build_decl (UNKNOWN_LOCATION
,
4714 TYPE_DECL
, get_identifier (pname
),
4720 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4722 va_list_arg_type_node
= va_list_ref_type_node
=
4723 build_pointer_type (TREE_TYPE (va_list_type_node
));
4727 va_list_arg_type_node
= va_list_type_node
;
4728 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
4731 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
4733 main_identifier_node
= get_identifier ("main");
4735 /* Create the built-in __null node. It is important that this is
4737 null_node
= make_int_cst (1, 1);
4738 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
4740 /* Create the built-in nullptr node. This part of its initialization is
4741 common to C and C++. The front ends can further adjust its definition
4742 in {c,cxx}_init_decl_processing. In particular, we aren't setting the
4743 alignment here for C++ backward ABI bug compatibility. */
4744 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4745 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4746 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4747 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4748 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4749 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4750 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4752 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4753 memset (builtin_types
, 0, sizeof (builtin_types
));
4756 /* The number of named compound-literals generated thus far. */
4757 static GTY(()) int compound_literal_number
;
4759 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4762 set_compound_literal_name (tree decl
)
4765 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
4766 compound_literal_number
);
4767 compound_literal_number
++;
4768 DECL_NAME (decl
) = get_identifier (name
);
4771 /* build_va_arg helper function. Return a VA_ARG_EXPR with location LOC, type
4772 TYPE and operand OP. */
4775 build_va_arg_1 (location_t loc
, tree type
, tree op
)
4777 tree expr
= build1 (VA_ARG_EXPR
, type
, op
);
4778 SET_EXPR_LOCATION (expr
, loc
);
4782 /* Return a VA_ARG_EXPR corresponding to a source-level expression
4783 va_arg (EXPR, TYPE) at source location LOC. */
4786 build_va_arg (location_t loc
, tree expr
, tree type
)
4788 tree va_type
= TREE_TYPE (expr
);
4789 tree canon_va_type
= (va_type
== error_mark_node
4791 : targetm
.canonical_va_list_type (va_type
));
4793 if (va_type
== error_mark_node
4794 || canon_va_type
== NULL_TREE
)
4796 if (canon_va_type
== NULL_TREE
)
4797 error_at (loc
, "first argument to %<va_arg%> not of type %<va_list%>");
4799 /* Let's handle things neutrally, if expr:
4800 - has undeclared type, or
4801 - is not an va_list type. */
4802 return build_va_arg_1 (loc
, type
, error_mark_node
);
4805 if (TREE_CODE (canon_va_type
) != ARRAY_TYPE
)
4807 /* Case 1: Not an array type. */
4809 /* Take the address, to get '&ap'. Note that &ap is not a va_list
4811 c_common_mark_addressable_vec (expr
);
4812 expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (expr
)), expr
);
4814 return build_va_arg_1 (loc
, type
, expr
);
4817 /* Case 2: Array type.
4821 For contrast, let's start with the simple case (case 1). If
4822 canon_va_type is not an array type, but say a char *, then when
4823 passing-by-value a va_list, the type of the va_list param decl is
4824 the same as for another va_list decl (all ap's are char *):
4827 D.1815 = VA_ARG (&ap, 0B, 1);
4833 __builtin_va_start (&ap, 0);
4836 __builtin_va_end (&ap);
4840 However, if canon_va_type is ARRAY_TYPE, then when passing-by-value a
4841 va_list the type of the va_list param decl (case 2b, struct * ap) is not
4842 the same as for another va_list decl (case 2a, struct ap[1]).
4845 D.1844 = VA_ARG (ap, 0B, 0);
4850 __builtin_va_start (&ap, 0);
4852 __builtin_va_end (&ap);
4856 Case 2b is different because:
4857 - on the callee side, the parm decl has declared type va_list, but
4858 grokdeclarator changes the type of the parm decl to a pointer to the
4860 - on the caller side, the pass-by-value uses &ap.
4862 We unify these two cases (case 2a: va_list is array type,
4863 case 2b: va_list is pointer to array elem type), by adding '&' for the
4864 array type case, such that we have a pointer to array elem in both
4867 if (TREE_CODE (va_type
) == ARRAY_TYPE
)
4869 /* Case 2a: va_list is array type. */
4871 /* Take the address, to get '&ap'. Make sure it's a pointer to array
4873 c_common_mark_addressable_vec (expr
);
4874 expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (canon_va_type
)),
4877 /* Verify that &ap is still recognized as having va_list type. */
4878 tree canon_expr_type
4879 = targetm
.canonical_va_list_type (TREE_TYPE (expr
));
4880 gcc_assert (canon_expr_type
!= NULL_TREE
);
4884 /* Case 2b: va_list is pointer to array elem type. */
4885 gcc_assert (POINTER_TYPE_P (va_type
));
4887 /* Comparison as in std_canonical_va_list_type. */
4888 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (va_type
))
4889 == TYPE_MAIN_VARIANT (TREE_TYPE (canon_va_type
)));
4891 /* Don't take the address. We've already got '&ap'. */
4895 return build_va_arg_1 (loc
, type
, expr
);
4899 /* Linked list of disabled built-in functions. */
4901 struct disabled_builtin
4904 struct disabled_builtin
*next
;
4906 static disabled_builtin
*disabled_builtins
= NULL
;
4908 static bool builtin_function_disabled_p (const char *);
4910 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4911 begins with "__builtin_", give an error. */
4914 disable_builtin_function (const char *name
)
4916 if (startswith (name
, "__builtin_"))
4917 error ("cannot disable built-in function %qs", name
);
4920 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
4921 new_disabled_builtin
->name
= name
;
4922 new_disabled_builtin
->next
= disabled_builtins
;
4923 disabled_builtins
= new_disabled_builtin
;
4928 /* Return true if the built-in function NAME has been disabled, false
4932 builtin_function_disabled_p (const char *name
)
4934 disabled_builtin
*p
;
4935 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
4937 if (strcmp (name
, p
->name
) == 0)
4944 /* Worker for DEF_BUILTIN.
4945 Possibly define a builtin function with one or two names.
4946 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4947 nonansi_p and flag_no_nonansi_builtin. */
4950 def_builtin_1 (enum built_in_function fncode
,
4952 enum built_in_class fnclass
,
4953 tree fntype
, tree libtype
,
4954 bool both_p
, bool fallback_p
, bool nonansi_p
,
4955 tree fnattrs
, bool implicit_p
)
4958 const char *libname
;
4960 if (fntype
== error_mark_node
)
4963 gcc_assert ((!both_p
&& !fallback_p
)
4964 || startswith (name
, "__builtin_"));
4966 libname
= name
+ strlen ("__builtin_");
4967 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
4968 (fallback_p
? libname
: NULL
),
4971 set_builtin_decl (fncode
, decl
, implicit_p
);
4974 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
4975 && !(nonansi_p
&& flag_no_nonansi_builtin
))
4976 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
4980 /* Nonzero if the type T promotes to int. This is (nearly) the
4981 integral promotions defined in ISO C99 6.3.1.1/2. */
4984 c_promoting_integer_type_p (const_tree t
)
4986 switch (TREE_CODE (t
))
4989 return (TYPE_MAIN_VARIANT (t
) == char_type_node
4990 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
4991 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
4992 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
4993 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
4994 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
4997 /* ??? Technically all enumerations not larger than an int
4998 promote to an int. But this is used along code paths
4999 that only want to notice a size change. */
5000 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
5010 /* Return 1 if PARMS specifies a fixed number of parameters
5011 and none of their types is affected by default promotions. */
5014 self_promoting_args_p (const_tree parms
)
5017 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
5019 tree type
= TREE_VALUE (t
);
5021 if (type
== error_mark_node
)
5024 if (TREE_CHAIN (t
) == NULL_TREE
&& type
!= void_type_node
)
5027 if (type
== NULL_TREE
)
5030 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
5033 if (c_promoting_integer_type_p (type
))
5039 /* Recursively remove any '*' or '&' operator from TYPE. */
5041 strip_pointer_operator (tree t
)
5043 while (POINTER_TYPE_P (t
))
5048 /* Recursively remove pointer or array type from TYPE. */
5050 strip_pointer_or_array_types (tree t
)
5052 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
5057 /* Used to compare case labels. K1 and K2 are actually tree nodes
5058 representing case labels, or NULL_TREE for a `default' label.
5059 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5060 K2, and 0 if K1 and K2 are equal. */
5063 case_compare (splay_tree_key k1
, splay_tree_key k2
)
5065 /* Consider a NULL key (such as arises with a `default' label) to be
5066 smaller than anything else. */
5072 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5075 /* Process a case label, located at LOC, for the range LOW_VALUE
5076 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5077 then this case label is actually a `default' label. If only
5078 HIGH_VALUE is NULL_TREE, then case label was declared using the
5079 usual C/C++ syntax, rather than the GNU case range extension.
5080 CASES is a tree containing all the case ranges processed so far;
5081 COND is the condition for the switch-statement itself.
5082 Returns the CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no
5083 CASE_LABEL_EXPR is created. ATTRS are the attributes to be applied
5087 c_add_case_label (location_t loc
, splay_tree cases
, tree cond
,
5088 tree low_value
, tree high_value
, tree attrs
)
5093 splay_tree_node node
;
5095 /* Create the LABEL_DECL itself. */
5096 label
= create_artificial_label (loc
);
5097 decl_attributes (&label
, attrs
, 0);
5099 /* If there was an error processing the switch condition, bail now
5100 before we get more confused. */
5101 if (!cond
|| cond
== error_mark_node
)
5104 if ((low_value
&& TREE_TYPE (low_value
)
5105 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
5106 || (high_value
&& TREE_TYPE (high_value
)
5107 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
5109 error_at (loc
, "pointers are not permitted as case values");
5113 /* Case ranges are a GNU extension. */
5115 pedwarn (loc
, OPT_Wpedantic
,
5116 "range expressions in switch statements are non-standard");
5118 type
= TREE_TYPE (cond
);
5121 low_value
= check_case_value (loc
, low_value
);
5122 low_value
= convert_and_check (loc
, type
, low_value
);
5123 low_value
= fold (low_value
);
5124 if (low_value
== error_mark_node
)
5129 high_value
= check_case_value (loc
, high_value
);
5130 high_value
= convert_and_check (loc
, type
, high_value
);
5131 high_value
= fold (high_value
);
5132 if (high_value
== error_mark_node
)
5136 if (low_value
&& high_value
)
5138 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5139 really a case range, even though it was written that way.
5140 Remove the HIGH_VALUE to simplify later processing. */
5141 if (tree_int_cst_equal (low_value
, high_value
))
5142 high_value
= NULL_TREE
;
5143 else if (!tree_int_cst_lt (low_value
, high_value
))
5144 warning_at (loc
, 0, "empty range specified");
5147 /* Look up the LOW_VALUE in the table of case labels we already
5149 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
5150 /* If there was not an exact match, check for overlapping ranges.
5151 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5152 that's a `default' label and the only overlap is an exact match. */
5153 if (!node
&& (low_value
|| high_value
))
5155 splay_tree_node low_bound
;
5156 splay_tree_node high_bound
;
5158 /* Even though there wasn't an exact match, there might be an
5159 overlap between this case range and another case range.
5160 Since we've (inductively) not allowed any overlapping case
5161 ranges, we simply need to find the greatest low case label
5162 that is smaller that LOW_VALUE, and the smallest low case
5163 label that is greater than LOW_VALUE. If there is an overlap
5164 it will occur in one of these two ranges. */
5165 low_bound
= splay_tree_predecessor (cases
,
5166 (splay_tree_key
) low_value
);
5167 high_bound
= splay_tree_successor (cases
,
5168 (splay_tree_key
) low_value
);
5170 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5171 the LOW_VALUE, so there is no need to check unless the
5172 LOW_BOUND is in fact itself a case range. */
5174 && CASE_HIGH ((tree
) low_bound
->value
)
5175 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
5178 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5179 range is bigger than the low end of the current range, so we
5180 are only interested if the current range is a real range, and
5181 not an ordinary case label. */
5184 && (tree_int_cst_compare ((tree
) high_bound
->key
,
5189 /* If there was an overlap, issue an error. */
5192 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
5196 error_at (loc
, "duplicate (or overlapping) case value");
5197 inform (DECL_SOURCE_LOCATION (duplicate
),
5198 "this is the first entry overlapping that value");
5202 error_at (loc
, "duplicate case value") ;
5203 inform (DECL_SOURCE_LOCATION (duplicate
), "previously used here");
5207 error_at (loc
, "multiple default labels in one switch");
5208 inform (DECL_SOURCE_LOCATION (duplicate
),
5209 "this is the first default label");
5214 /* Add a CASE_LABEL to the statement-tree. */
5215 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
5216 /* Register this case label in the splay tree. */
5217 splay_tree_insert (cases
,
5218 (splay_tree_key
) low_value
,
5219 (splay_tree_value
) case_label
);
5224 /* Add a label so that the back-end doesn't think that the beginning of
5225 the switch is unreachable. Note that we do not add a case label, as
5226 that just leads to duplicates and thence to failure later on. */
5229 tree t
= create_artificial_label (loc
);
5230 add_stmt (build_stmt (loc
, LABEL_EXPR
, t
));
5232 return error_mark_node
;
5235 /* Subroutine of c_switch_covers_all_cases_p, called via
5236 splay_tree_foreach. Return 1 if it doesn't cover all the cases.
5237 ARGS[0] is initially NULL and after the first iteration is the
5238 so far highest case label. ARGS[1] is the minimum of SWITCH_COND's
5242 c_switch_covers_all_cases_p_1 (splay_tree_node node
, void *data
)
5244 tree label
= (tree
) node
->value
;
5245 tree
*args
= (tree
*) data
;
5247 /* If there is a default case, we shouldn't have called this. */
5248 gcc_assert (CASE_LOW (label
));
5250 if (args
[0] == NULL_TREE
)
5252 if (wi::to_widest (args
[1]) < wi::to_widest (CASE_LOW (label
)))
5255 else if (wi::add (wi::to_widest (args
[0]), 1)
5256 != wi::to_widest (CASE_LOW (label
)))
5258 if (CASE_HIGH (label
))
5259 args
[0] = CASE_HIGH (label
);
5261 args
[0] = CASE_LOW (label
);
5265 /* Return true if switch with CASES and switch condition with type
5266 covers all possible values in the case labels. */
5269 c_switch_covers_all_cases_p (splay_tree cases
, tree type
)
5271 /* If there is default:, this is always the case. */
5272 splay_tree_node default_node
5273 = splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
5277 if (!INTEGRAL_TYPE_P (type
))
5280 tree args
[2] = { NULL_TREE
, TYPE_MIN_VALUE (type
) };
5281 if (splay_tree_foreach (cases
, c_switch_covers_all_cases_p_1
, args
))
5284 /* If there are no cases at all, or if the highest case label
5285 is smaller than TYPE_MAX_VALUE, return false. */
5286 if (args
[0] == NULL_TREE
5287 || wi::to_widest (args
[0]) < wi::to_widest (TYPE_MAX_VALUE (type
)))
5293 /* Return true if stmt can fall through. Used by block_may_fallthru
5297 c_block_may_fallthru (const_tree stmt
)
5299 switch (TREE_CODE (stmt
))
5302 return (!SWITCH_STMT_ALL_CASES_P (stmt
)
5303 || !SWITCH_STMT_NO_BREAK_P (stmt
)
5304 || block_may_fallthru (SWITCH_STMT_BODY (stmt
)));
5311 /* Finish an expression taking the address of LABEL (an
5312 IDENTIFIER_NODE). Returns an expression for the address.
5314 LOC is the location for the expression returned. */
5317 finish_label_address_expr (tree label
, location_t loc
)
5321 pedwarn (input_location
, OPT_Wpedantic
, "taking the address of a label is non-standard");
5323 if (label
== error_mark_node
)
5324 return error_mark_node
;
5326 label
= lookup_label (label
);
5327 if (label
== NULL_TREE
)
5328 result
= null_pointer_node
;
5331 TREE_USED (label
) = 1;
5332 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
5333 /* The current function is not necessarily uninlinable.
5334 Computed gotos are incompatible with inlining, but the value
5335 here could be used only in a diagnostic, for example. */
5336 protected_set_expr_location (result
, loc
);
5343 /* Given a boolean expression ARG, return a tree representing an increment
5344 or decrement (as indicated by CODE) of ARG. The front end must check for
5345 invalid cases (e.g., decrement in C++). */
5347 boolean_increment (enum tree_code code
, tree arg
)
5350 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
5352 arg
= stabilize_reference (arg
);
5355 case PREINCREMENT_EXPR
:
5356 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5358 case POSTINCREMENT_EXPR
:
5359 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5360 arg
= save_expr (arg
);
5361 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5362 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5364 case PREDECREMENT_EXPR
:
5365 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5366 invert_truthvalue_loc (input_location
, arg
));
5368 case POSTDECREMENT_EXPR
:
5369 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5370 invert_truthvalue_loc (input_location
, arg
));
5371 arg
= save_expr (arg
);
5372 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5373 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5378 TREE_SIDE_EFFECTS (val
) = 1;
5382 /* Built-in macros for stddef.h and stdint.h, that require macros
5383 defined in this file. */
5385 c_stddef_cpp_builtins(void)
5387 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
5388 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
5389 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
5390 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
5391 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
5392 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
5394 builtin_define_with_value ("__CHAR8_TYPE__", CHAR8_TYPE
, 0);
5395 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
5396 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
5397 if (SIG_ATOMIC_TYPE
)
5398 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE
, 0);
5400 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE
, 0);
5402 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE
, 0);
5404 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE
, 0);
5406 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE
, 0);
5408 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE
, 0);
5410 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE
, 0);
5412 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE
, 0);
5414 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE
, 0);
5415 if (INT_LEAST8_TYPE
)
5416 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE
, 0);
5417 if (INT_LEAST16_TYPE
)
5418 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE
, 0);
5419 if (INT_LEAST32_TYPE
)
5420 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE
, 0);
5421 if (INT_LEAST64_TYPE
)
5422 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE
, 0);
5423 if (UINT_LEAST8_TYPE
)
5424 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE
, 0);
5425 if (UINT_LEAST16_TYPE
)
5426 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE
, 0);
5427 if (UINT_LEAST32_TYPE
)
5428 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE
, 0);
5429 if (UINT_LEAST64_TYPE
)
5430 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE
, 0);
5432 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE
, 0);
5433 if (INT_FAST16_TYPE
)
5434 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE
, 0);
5435 if (INT_FAST32_TYPE
)
5436 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE
, 0);
5437 if (INT_FAST64_TYPE
)
5438 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE
, 0);
5439 if (UINT_FAST8_TYPE
)
5440 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE
, 0);
5441 if (UINT_FAST16_TYPE
)
5442 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE
, 0);
5443 if (UINT_FAST32_TYPE
)
5444 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE
, 0);
5445 if (UINT_FAST64_TYPE
)
5446 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE
, 0);
5448 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE
, 0);
5450 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE
, 0);
5451 /* GIMPLE FE testcases need access to the GCC internal 'sizetype'.
5452 Expose it as __SIZETYPE__. */
5454 builtin_define_with_value ("__SIZETYPE__", SIZETYPE
, 0);
5458 c_init_attributes (void)
5460 /* Fill in the built_in_attributes array. */
5461 #define DEF_ATTR_NULL_TREE(ENUM) \
5462 built_in_attributes[(int) ENUM] = NULL_TREE;
5463 #define DEF_ATTR_INT(ENUM, VALUE) \
5464 built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE);
5465 #define DEF_ATTR_STRING(ENUM, VALUE) \
5466 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
5467 #define DEF_ATTR_IDENT(ENUM, STRING) \
5468 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5469 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5470 built_in_attributes[(int) ENUM] \
5471 = tree_cons (built_in_attributes[(int) PURPOSE], \
5472 built_in_attributes[(int) VALUE], \
5473 built_in_attributes[(int) CHAIN]);
5474 #include "builtin-attrs.def"
5475 #undef DEF_ATTR_NULL_TREE
5477 #undef DEF_ATTR_IDENT
5478 #undef DEF_ATTR_TREE_LIST
5481 /* Check whether the byte alignment ALIGN is a valid user-specified
5482 alignment less than the supported maximum. If so, return ALIGN's
5483 base-2 log; if not, output an error and return -1. If OBJFILE
5484 then reject alignments greater than MAX_OFILE_ALIGNMENT when
5485 converted to bits. Otherwise, consider valid only alignments
5486 that are less than HOST_BITS_PER_INT - LOG2_BITS_PER_UNIT.
5487 Zero is not considered a valid argument (and results in -1 on
5488 return) but it only triggers a warning when WARN_ZERO is set. */
5491 check_user_alignment (const_tree align
, bool objfile
, bool warn_zero
)
5493 if (error_operand_p (align
))
5496 if (TREE_CODE (align
) != INTEGER_CST
5497 || !INTEGRAL_TYPE_P (TREE_TYPE (align
)))
5499 error ("requested alignment is not an integer constant");
5503 if (integer_zerop (align
))
5506 warning (OPT_Wattributes
,
5507 "requested alignment %qE is not a positive power of 2",
5512 /* Log2 of the byte alignment ALIGN. */
5514 if (tree_int_cst_sgn (align
) == -1
5515 || (log2align
= tree_log2 (align
)) == -1)
5517 error ("requested alignment %qE is not a positive power of 2",
5524 unsigned maxalign
= MAX_OFILE_ALIGNMENT
/ BITS_PER_UNIT
;
5525 if (!tree_fits_uhwi_p (align
) || tree_to_uhwi (align
) > maxalign
)
5527 error ("requested alignment %qE exceeds object file maximum %u",
5533 if (log2align
>= HOST_BITS_PER_INT
- LOG2_BITS_PER_UNIT
)
5535 error ("requested alignment %qE exceeds maximum %u",
5536 align
, 1U << (HOST_BITS_PER_INT
- LOG2_BITS_PER_UNIT
- 1));
5543 /* Determine the ELF symbol visibility for DECL, which is either a
5544 variable or a function. It is an error to use this function if a
5545 definition of DECL is not available in this translation unit.
5546 Returns true if the final visibility has been determined by this
5547 function; false if the caller is free to make additional
5551 c_determine_visibility (tree decl
)
5553 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
5555 /* If the user explicitly specified the visibility with an
5556 attribute, honor that. DECL_VISIBILITY will have been set during
5557 the processing of the attribute. We check for an explicit
5558 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5559 to distinguish the use of an attribute from the use of a "#pragma
5560 GCC visibility push(...)"; in the latter case we still want other
5561 considerations to be able to overrule the #pragma. */
5562 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
5563 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5564 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
5565 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
5568 /* Set default visibility to whatever the user supplied with
5569 visibility_specified depending on #pragma GCC visibility. */
5570 if (!DECL_VISIBILITY_SPECIFIED (decl
))
5572 if (visibility_options
.inpragma
5573 || DECL_VISIBILITY (decl
) != default_visibility
)
5575 DECL_VISIBILITY (decl
) = default_visibility
;
5576 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
5577 /* If visibility changed and DECL already has DECL_RTL, ensure
5578 symbol flags are updated. */
5579 if (((VAR_P (decl
) && TREE_STATIC (decl
))
5580 || TREE_CODE (decl
) == FUNCTION_DECL
)
5581 && DECL_RTL_SET_P (decl
))
5582 make_decl_rtl (decl
);
5588 /* Data to communicate through check_function_arguments_recurse between
5589 check_function_nonnull and check_nonnull_arg. */
5591 struct nonnull_arg_ctx
5593 /* Location of the call. */
5595 /* The function whose arguments are being checked and its type (used
5596 for calls through function pointers). */
5597 const_tree fndecl
, fntype
;
5598 /* True if a warning has been issued. */
5602 /* Check the argument list of a function call to CTX.FNDECL of CTX.FNTYPE
5603 for null in argument slots that are marked as requiring a non-null
5604 pointer argument. The NARGS arguments are passed in the array ARGARRAY.
5605 Return true if we have warned. */
5608 check_function_nonnull (nonnull_arg_ctx
&ctx
, int nargs
, tree
*argarray
)
5611 if (TREE_CODE (ctx
.fntype
) == METHOD_TYPE
)
5613 bool closure
= false;
5616 /* For certain lambda expressions the C++ front end emits calls
5617 that pass a null this pointer as an argument named __closure
5618 to the member operator() of empty function. Detect those
5619 and avoid checking them, but proceed to check the remaining
5621 tree arg0
= DECL_ARGUMENTS (ctx
.fndecl
);
5622 if (tree arg0name
= DECL_NAME (arg0
))
5623 closure
= id_equal (arg0name
, "__closure");
5626 /* In calls to C++ non-static member functions check the this
5627 pointer regardless of whether the function is declared with
5628 attribute nonnull. */
5631 check_function_arguments_recurse (check_nonnull_arg
, &ctx
, argarray
[0],
5632 firstarg
, OPT_Wnonnull
);
5635 tree attrs
= lookup_attribute ("nonnull", TYPE_ATTRIBUTES (ctx
.fntype
));
5636 if (attrs
== NULL_TREE
)
5637 return ctx
.warned_p
;
5640 /* See if any of the nonnull attributes has no arguments. If so,
5641 then every pointer argument is checked (in which case the check
5642 for pointer type is done in check_nonnull_arg). */
5643 if (TREE_VALUE (a
) != NULL_TREE
)
5645 a
= lookup_attribute ("nonnull", TREE_CHAIN (a
));
5646 while (a
!= NULL_TREE
&& TREE_VALUE (a
) != NULL_TREE
);
5649 for (int i
= firstarg
; i
< nargs
; i
++)
5650 check_function_arguments_recurse (check_nonnull_arg
, &ctx
, argarray
[i
],
5651 i
+ 1, OPT_Wnonnull
);
5654 /* Walk the argument list. If we encounter an argument number we
5655 should check for non-null, do it. */
5656 for (int i
= firstarg
; i
< nargs
; i
++)
5658 for (a
= attrs
; ; a
= TREE_CHAIN (a
))
5660 a
= lookup_attribute ("nonnull", a
);
5661 if (a
== NULL_TREE
|| nonnull_check_p (TREE_VALUE (a
), i
+ 1))
5666 check_function_arguments_recurse (check_nonnull_arg
, &ctx
,
5671 return ctx
.warned_p
;
5674 /* Check that the Nth argument of a function call (counting backwards
5675 from the end) is a (pointer)0. The NARGS arguments are passed in the
5679 check_function_sentinel (const_tree fntype
, int nargs
, tree
*argarray
)
5681 tree attr
= lookup_attribute ("sentinel", TYPE_ATTRIBUTES (fntype
));
5688 function_args_iterator iter
;
5691 /* Skip over the named arguments. */
5692 FOREACH_FUNCTION_ARGS (fntype
, t
, iter
)
5699 if (TREE_VALUE (attr
))
5701 tree p
= TREE_VALUE (TREE_VALUE (attr
));
5702 pos
= TREE_INT_CST_LOW (p
);
5705 /* The sentinel must be one of the varargs, i.e.
5706 in position >= the number of fixed arguments. */
5707 if ((nargs
- 1 - pos
) < len
)
5709 warning (OPT_Wformat_
,
5710 "not enough variable arguments to fit a sentinel");
5714 /* Validate the sentinel. */
5715 sentinel
= fold_for_warn (argarray
[nargs
- 1 - pos
]);
5716 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
5717 || !integer_zerop (sentinel
))
5718 /* Although __null (in C++) is only an integer we allow it
5719 nevertheless, as we are guaranteed that it's exactly
5720 as wide as a pointer, and we don't want to force
5721 users to cast the NULL they have written there.
5722 We warn with -Wstrict-null-sentinel, though. */
5723 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
5724 warning (OPT_Wformat_
, "missing sentinel in function call");
5728 /* Check that the same argument isn't passed to two or more
5729 restrict-qualified formal and issue a -Wrestrict warning
5730 if it is. Return true if a warning has been issued. */
5733 check_function_restrict (const_tree fndecl
, const_tree fntype
,
5734 int nargs
, tree
*unfolded_argarray
)
5737 tree parms
= TYPE_ARG_TYPES (fntype
);
5739 /* Call fold_for_warn on all of the arguments. */
5740 auto_vec
<tree
> argarray (nargs
);
5741 for (i
= 0; i
< nargs
; i
++)
5742 argarray
.quick_push (fold_for_warn (unfolded_argarray
[i
]));
5745 && TREE_CODE (fndecl
) == FUNCTION_DECL
)
5747 /* Avoid diagnosing calls built-ins with a zero size/bound
5748 here. They are checked in more detail elsewhere. */
5749 if (fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
)
5751 && TREE_CODE (argarray
[2]) == INTEGER_CST
5752 && integer_zerop (argarray
[2]))
5755 if (DECL_ARGUMENTS (fndecl
))
5756 parms
= DECL_ARGUMENTS (fndecl
);
5759 for (i
= 0; i
< nargs
; i
++)
5760 TREE_VISITED (argarray
[i
]) = 0;
5762 bool warned
= false;
5764 for (i
= 0; i
< nargs
&& parms
&& parms
!= void_list_node
; i
++)
5767 if (TREE_CODE (parms
) == PARM_DECL
)
5769 type
= TREE_TYPE (parms
);
5770 parms
= DECL_CHAIN (parms
);
5774 type
= TREE_VALUE (parms
);
5775 parms
= TREE_CHAIN (parms
);
5777 if (POINTER_TYPE_P (type
)
5778 && TYPE_RESTRICT (type
)
5779 && !TYPE_READONLY (TREE_TYPE (type
)))
5780 warned
|= warn_for_restrict (i
, argarray
.address (), nargs
);
5783 for (i
= 0; i
< nargs
; i
++)
5784 TREE_VISITED (argarray
[i
]) = 0;
5789 /* Helper for check_function_nonnull; given a list of operands which
5790 must be non-null in ARGS, determine if operand PARAM_NUM should be
5794 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
5796 unsigned HOST_WIDE_INT arg_num
= 0;
5798 for (; args
; args
= TREE_CHAIN (args
))
5800 bool found
= get_attribute_operand (TREE_VALUE (args
), &arg_num
);
5804 if (arg_num
== param_num
)
5810 /* Check that the function argument PARAM (which is operand number
5811 PARAM_NUM) is non-null. This is called by check_function_nonnull
5812 via check_function_arguments_recurse. */
5815 check_nonnull_arg (void *ctx
, tree param
, unsigned HOST_WIDE_INT param_num
)
5817 struct nonnull_arg_ctx
*pctx
= (struct nonnull_arg_ctx
*) ctx
;
5819 /* Just skip checking the argument if it's not a pointer. This can
5820 happen if the "nonnull" attribute was given without an operand
5821 list (which means to check every pointer argument). */
5823 tree paramtype
= TREE_TYPE (param
);
5824 if (TREE_CODE (paramtype
) != POINTER_TYPE
5825 && TREE_CODE (paramtype
) != NULLPTR_TYPE
)
5828 /* Diagnose the simple cases of null arguments. */
5829 if (!integer_zerop (fold_for_warn (param
)))
5832 auto_diagnostic_group adg
;
5834 const location_t loc
= EXPR_LOC_OR_LOC (param
, pctx
->loc
);
5836 if (TREE_CODE (pctx
->fntype
) == METHOD_TYPE
)
5842 warned
= warning_at (loc
, OPT_Wnonnull
,
5843 "%qs pointer is null", "this");
5844 if (warned
&& pctx
->fndecl
)
5845 inform (DECL_SOURCE_LOCATION (pctx
->fndecl
),
5846 "in a call to non-static member function %qD",
5851 warned
= warning_at (loc
, OPT_Wnonnull
,
5852 "argument %u null where non-null expected",
5853 (unsigned) param_num
);
5854 if (warned
&& pctx
->fndecl
)
5855 inform (DECL_SOURCE_LOCATION (pctx
->fndecl
),
5856 "in a call to function %qD declared %qs",
5857 pctx
->fndecl
, "nonnull");
5861 pctx
->warned_p
= true;
5864 /* Helper for attribute handling; fetch the operand number from
5865 the attribute argument list. */
5868 get_attribute_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
5870 /* Verify the arg number is a small constant. */
5871 if (tree_fits_uhwi_p (arg_num_expr
))
5873 *valp
= tree_to_uhwi (arg_num_expr
);
5880 /* Arguments being collected for optimization. */
5881 typedef const char *const_char_p
; /* For DEF_VEC_P. */
5882 static GTY(()) vec
<const_char_p
, va_gc
> *optimize_args
;
5885 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
5886 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
5887 false for #pragma GCC optimize. */
5890 parse_optimize_options (tree args
, bool attr_p
)
5895 const char **opt_argv
;
5896 struct cl_decoded_option
*decoded_options
;
5897 unsigned int decoded_options_count
;
5900 /* Build up argv vector. Just in case the string is stored away, use garbage
5901 collected strings. */
5902 vec_safe_truncate (optimize_args
, 0);
5903 vec_safe_push (optimize_args
, (const char *) NULL
);
5905 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
5907 tree value
= TREE_VALUE (ap
);
5909 if (TREE_CODE (value
) == INTEGER_CST
)
5911 char buffer
[HOST_BITS_PER_LONG
/ 3 + 4];
5912 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
5913 vec_safe_push (optimize_args
, ggc_strdup (buffer
));
5916 else if (TREE_CODE (value
) == STRING_CST
)
5918 /* Split string into multiple substrings. */
5919 size_t len
= TREE_STRING_LENGTH (value
);
5920 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
5921 char *end
= p
+ len
;
5925 while (next_p
!= NULL
)
5931 comma
= strchr (p
, ',');
5944 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
5946 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
5950 warning (OPT_Wattributes
,
5951 "bad option %qs to attribute %<optimize%>", p
);
5953 warning (OPT_Wpragmas
,
5954 "bad option %qs to pragma %<optimize%>", p
);
5958 /* Can't use GC memory here, see PR88007. */
5959 r
= q
= XOBNEWVEC (&opts_obstack
, char, len2
+ 3);
5965 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
5966 itself is -Os, and any other switch begins with a -f. */
5967 if ((*p
>= '0' && *p
<= '9')
5968 || (p
[0] == 's' && p
[1] == '\0'))
5974 memcpy (r
, p
, len2
);
5976 vec_safe_push (optimize_args
, (const char *) q
);
5982 opt_argc
= optimize_args
->length ();
5983 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
5985 for (i
= 1; i
< opt_argc
; i
++)
5986 opt_argv
[i
] = (*optimize_args
)[i
];
5988 /* Now parse the options. */
5989 decode_cmdline_options_to_array_default_mask (opt_argc
, opt_argv
,
5991 &decoded_options_count
);
5992 /* Drop non-Optimization options. */
5994 for (i
= 1; i
< decoded_options_count
; ++i
)
5996 if (! (cl_options
[decoded_options
[i
].opt_index
].flags
& CL_OPTIMIZATION
))
6000 warning (OPT_Wattributes
,
6001 "bad option %qs to attribute %<optimize%>",
6002 decoded_options
[i
].orig_option_with_args_text
);
6004 warning (OPT_Wpragmas
,
6005 "bad option %qs to pragma %<optimize%>",
6006 decoded_options
[i
].orig_option_with_args_text
);
6010 decoded_options
[j
] = decoded_options
[i
];
6013 decoded_options_count
= j
;
6015 /* Merge the decoded options with save_decoded_options. */
6016 unsigned save_opt_count
= save_opt_decoded_options
->length ();
6017 unsigned merged_decoded_options_count
6018 = save_opt_count
+ decoded_options_count
;
6019 cl_decoded_option
*merged_decoded_options
6020 = XNEWVEC (cl_decoded_option
, merged_decoded_options_count
);
6022 /* Note the first decoded_options is used for the program name. */
6023 for (unsigned i
= 0; i
< save_opt_count
; ++i
)
6024 merged_decoded_options
[i
+ 1] = (*save_opt_decoded_options
)[i
];
6025 for (unsigned i
= 1; i
< decoded_options_count
; ++i
)
6026 merged_decoded_options
[save_opt_count
+ i
] = decoded_options
[i
];
6028 /* And apply them. */
6029 decode_options (&global_options
, &global_options_set
,
6030 merged_decoded_options
, merged_decoded_options_count
,
6031 input_location
, global_dc
, NULL
);
6032 free (decoded_options
);
6034 targetm
.override_options_after_change();
6036 optimize_args
->truncate (0);
6040 /* Check whether ATTR is a valid attribute fallthrough. */
6043 attribute_fallthrough_p (tree attr
)
6045 if (attr
== error_mark_node
)
6047 tree t
= lookup_attribute ("fallthrough", attr
);
6050 /* It is no longer true that "this attribute shall appear at most once in
6051 each attribute-list", but we still give a warning. */
6052 if (lookup_attribute ("fallthrough", TREE_CHAIN (t
)))
6053 warning (OPT_Wattributes
, "attribute %<fallthrough%> specified multiple "
6055 /* No attribute-argument-clause shall be present. */
6056 else if (TREE_VALUE (t
) != NULL_TREE
)
6057 warning (OPT_Wattributes
, "%<fallthrough%> attribute specified with "
6059 /* Warn if other attributes are found. */
6060 for (t
= attr
; t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
6062 tree name
= get_attribute_name (t
);
6063 if (!is_attribute_p ("fallthrough", name
))
6065 if (!c_dialect_cxx () && get_attribute_namespace (t
) == NULL_TREE
)
6066 /* The specifications of standard attributes in C mean
6067 this is a constraint violation. */
6068 pedwarn (input_location
, OPT_Wattributes
, "%qE attribute ignored",
6069 get_attribute_name (t
));
6071 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6078 /* Check for valid arguments being passed to a function with FNTYPE.
6079 There are NARGS arguments in the array ARGARRAY. LOC should be used
6080 for diagnostics. Return true if either -Wnonnull or -Wrestrict has
6083 The arguments in ARGARRAY may not have been folded yet (e.g. for C++,
6084 to preserve location wrappers); checks that require folded arguments
6085 should call fold_for_warn on them. */
6088 check_function_arguments (location_t loc
, const_tree fndecl
, const_tree fntype
,
6089 int nargs
, tree
*argarray
, vec
<location_t
> *arglocs
)
6091 bool warned_p
= false;
6093 /* Check for null being passed in a pointer argument that must be
6094 non-null. In C++, this includes the this pointer. We also need
6095 to do this if format checking is enabled. */
6098 nonnull_arg_ctx ctx
= { loc
, fndecl
, fntype
, false };
6099 warned_p
= check_function_nonnull (ctx
, nargs
, argarray
);
6102 /* Check for errors in format strings. */
6104 if (warn_format
|| warn_suggest_attribute_format
)
6105 check_function_format (fndecl
? fndecl
: fntype
, TYPE_ATTRIBUTES (fntype
), nargs
,
6109 check_function_sentinel (fntype
, nargs
, argarray
);
6111 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
6113 switch (DECL_FUNCTION_CODE (fndecl
))
6115 case BUILT_IN_SPRINTF
:
6116 case BUILT_IN_SPRINTF_CHK
:
6117 case BUILT_IN_SNPRINTF
:
6118 case BUILT_IN_SNPRINTF_CHK
:
6119 /* Let the sprintf pass handle these. */
6127 /* check_function_restrict sets the DECL_READ_P for arguments
6128 so it must be called unconditionally. */
6129 warned_p
|= check_function_restrict (fndecl
, fntype
, nargs
, argarray
);
6134 /* Generic argument checking recursion routine. PARAM is the argument to
6135 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6136 once the argument is resolved. CTX is context for the callback.
6137 OPT is the warning for which this is done. */
6139 check_function_arguments_recurse (void (*callback
)
6140 (void *, tree
, unsigned HOST_WIDE_INT
),
6141 void *ctx
, tree param
,
6142 unsigned HOST_WIDE_INT param_num
,
6145 if (opt
!= OPT_Wformat_
&& warning_suppressed_p (param
))
6148 if (CONVERT_EXPR_P (param
)
6149 && (TYPE_PRECISION (TREE_TYPE (param
))
6150 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
6152 /* Strip coercion. */
6153 check_function_arguments_recurse (callback
, ctx
,
6154 TREE_OPERAND (param
, 0), param_num
,
6159 if (TREE_CODE (param
) == CALL_EXPR
&& CALL_EXPR_FN (param
))
6161 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
6163 bool found_format_arg
= false;
6165 /* See if this is a call to a known internationalization function
6166 that modifies a format arg. Such a function may have multiple
6167 format_arg attributes (for example, ngettext). */
6169 for (attrs
= TYPE_ATTRIBUTES (type
);
6171 attrs
= TREE_CHAIN (attrs
))
6172 if (is_attribute_p ("format_arg", get_attribute_name (attrs
)))
6175 tree format_num_expr
;
6178 call_expr_arg_iterator iter
;
6180 /* Extract the argument number, which was previously checked
6182 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
6184 format_num
= tree_to_uhwi (format_num_expr
);
6186 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
6187 inner_arg
!= NULL_TREE
;
6188 inner_arg
= next_call_expr_arg (&iter
), i
++)
6189 if (i
== format_num
)
6191 check_function_arguments_recurse (callback
, ctx
,
6192 inner_arg
, param_num
,
6194 found_format_arg
= true;
6199 /* If we found a format_arg attribute and did a recursive check,
6200 we are done with checking this argument. Otherwise, we continue
6201 and this will be considered a non-literal. */
6202 if (found_format_arg
)
6206 if (TREE_CODE (param
) == COND_EXPR
)
6208 /* Simplify to avoid warning for an impossible case. */
6209 param
= fold_for_warn (param
);
6210 if (TREE_CODE (param
) == COND_EXPR
)
6212 /* Check both halves of the conditional expression. */
6213 check_function_arguments_recurse (callback
, ctx
,
6214 TREE_OPERAND (param
, 1),
6216 check_function_arguments_recurse (callback
, ctx
,
6217 TREE_OPERAND (param
, 2),
6223 (*callback
) (ctx
, param
, param_num
);
6226 /* Checks for a builtin function FNDECL that the number of arguments
6227 NARGS against the required number REQUIRED and issues an error if
6228 there is a mismatch. Returns true if the number of arguments is
6229 correct, otherwise false. LOC is the location of FNDECL. */
6232 builtin_function_validate_nargs (location_t loc
, tree fndecl
, int nargs
,
6235 if (nargs
< required
)
6237 error_at (loc
, "too few arguments to function %qE", fndecl
);
6240 else if (nargs
> required
)
6242 error_at (loc
, "too many arguments to function %qE", fndecl
);
6248 /* Helper macro for check_builtin_function_arguments. */
6249 #define ARG_LOCATION(N) \
6250 (arg_loc.is_empty () \
6251 ? EXPR_LOC_OR_LOC (args[(N)], input_location) \
6252 : expansion_point_location (arg_loc[(N)]))
6254 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
6255 Returns false if there was an error, otherwise true. LOC is the
6256 location of the function; ARG_LOC is a vector of locations of the
6257 arguments. If FNDECL is the result of resolving an overloaded
6258 target built-in, ORIG_FNDECL is the original function decl,
6259 otherwise it is null. */
6262 check_builtin_function_arguments (location_t loc
, vec
<location_t
> arg_loc
,
6263 tree fndecl
, tree orig_fndecl
,
6264 int nargs
, tree
*args
)
6266 if (!fndecl_built_in_p (fndecl
))
6269 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_MD
)
6270 return (!targetm
.check_builtin_call
6271 || targetm
.check_builtin_call (loc
, arg_loc
, fndecl
,
6272 orig_fndecl
, nargs
, args
));
6274 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_FRONTEND
)
6277 gcc_assert (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
);
6278 switch (DECL_FUNCTION_CODE (fndecl
))
6280 case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
:
6281 if (!tree_fits_uhwi_p (args
[2]))
6283 error_at (ARG_LOCATION (2),
6284 "third argument to function %qE must be a constant integer",
6290 case BUILT_IN_ALLOCA_WITH_ALIGN
:
6292 /* Get the requested alignment (in bits) if it's a constant
6293 integer expression. */
6294 unsigned HOST_WIDE_INT align
6295 = tree_fits_uhwi_p (args
[1]) ? tree_to_uhwi (args
[1]) : 0;
6297 /* Determine if the requested alignment is a power of 2. */
6298 if ((align
& (align
- 1)))
6301 /* The maximum alignment in bits corresponding to the same
6302 maximum in bytes enforced in check_user_alignment(). */
6303 unsigned maxalign
= (UINT_MAX
>> 1) + 1;
6305 /* Reject invalid alignments. */
6306 if (align
< BITS_PER_UNIT
|| maxalign
< align
)
6308 error_at (ARG_LOCATION (1),
6309 "second argument to function %qE must be a constant "
6310 "integer power of 2 between %qi and %qu bits",
6311 fndecl
, BITS_PER_UNIT
, maxalign
);
6317 case BUILT_IN_CONSTANT_P
:
6318 return builtin_function_validate_nargs (loc
, fndecl
, nargs
, 1);
6320 case BUILT_IN_ISFINITE
:
6321 case BUILT_IN_ISINF
:
6322 case BUILT_IN_ISINF_SIGN
:
6323 case BUILT_IN_ISNAN
:
6324 case BUILT_IN_ISNORMAL
:
6325 case BUILT_IN_ISSIGNALING
:
6326 case BUILT_IN_SIGNBIT
:
6327 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 1))
6329 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
6331 error_at (ARG_LOCATION (0), "non-floating-point argument in "
6332 "call to function %qE", fndecl
);
6339 case BUILT_IN_ISGREATER
:
6340 case BUILT_IN_ISGREATEREQUAL
:
6341 case BUILT_IN_ISLESS
:
6342 case BUILT_IN_ISLESSEQUAL
:
6343 case BUILT_IN_ISLESSGREATER
:
6344 case BUILT_IN_ISUNORDERED
:
6345 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 2))
6347 enum tree_code code0
, code1
;
6348 code0
= TREE_CODE (TREE_TYPE (args
[0]));
6349 code1
= TREE_CODE (TREE_TYPE (args
[1]));
6350 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
6351 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
6352 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
6354 error_at (loc
, "non-floating-point arguments in call to "
6355 "function %qE", fndecl
);
6362 case BUILT_IN_FPCLASSIFY
:
6363 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 6))
6365 for (unsigned int i
= 0; i
< 5; i
++)
6366 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
6368 error_at (ARG_LOCATION (i
), "non-const integer argument %u in "
6369 "call to function %qE", i
+ 1, fndecl
);
6373 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
6375 error_at (ARG_LOCATION (5), "non-floating-point argument in "
6376 "call to function %qE", fndecl
);
6383 case BUILT_IN_ASSUME_ALIGNED
:
6384 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 2 + (nargs
> 2)))
6386 if (nargs
>= 3 && TREE_CODE (TREE_TYPE (args
[2])) != INTEGER_TYPE
)
6388 error_at (ARG_LOCATION (2), "non-integer argument 3 in call to "
6389 "function %qE", fndecl
);
6396 case BUILT_IN_ADD_OVERFLOW
:
6397 case BUILT_IN_SUB_OVERFLOW
:
6398 case BUILT_IN_MUL_OVERFLOW
:
6399 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 3))
6402 for (i
= 0; i
< 2; i
++)
6403 if (!INTEGRAL_TYPE_P (TREE_TYPE (args
[i
])))
6405 error_at (ARG_LOCATION (i
), "argument %u in call to function "
6406 "%qE does not have integral type", i
+ 1, fndecl
);
6409 if (TREE_CODE (TREE_TYPE (args
[2])) != POINTER_TYPE
6410 || !INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (args
[2]))))
6412 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
6413 "does not have pointer to integral type", fndecl
);
6416 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args
[2]))) == ENUMERAL_TYPE
)
6418 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
6419 "has pointer to enumerated type", fndecl
);
6422 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args
[2]))) == BOOLEAN_TYPE
)
6424 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
6425 "has pointer to boolean type", fndecl
);
6428 else if (TYPE_READONLY (TREE_TYPE (TREE_TYPE (args
[2]))))
6430 error_at (ARG_LOCATION (2), "argument %u in call to function %qE "
6431 "has pointer to %qs type (%qT)", 3, fndecl
, "const",
6432 TREE_TYPE (args
[2]));
6435 else if (TYPE_ATOMIC (TREE_TYPE (TREE_TYPE (args
[2]))))
6437 error_at (ARG_LOCATION (2), "argument %u in call to function %qE "
6438 "has pointer to %qs type (%qT)", 3, fndecl
,
6439 "_Atomic", TREE_TYPE (args
[2]));
6446 case BUILT_IN_ADD_OVERFLOW_P
:
6447 case BUILT_IN_SUB_OVERFLOW_P
:
6448 case BUILT_IN_MUL_OVERFLOW_P
:
6449 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 3))
6452 for (i
= 0; i
< 3; i
++)
6453 if (!INTEGRAL_TYPE_P (TREE_TYPE (args
[i
])))
6455 error_at (ARG_LOCATION (i
), "argument %u in call to function "
6456 "%qE does not have integral type", i
+ 1, fndecl
);
6459 if (TREE_CODE (TREE_TYPE (args
[2])) == ENUMERAL_TYPE
)
6461 error_at (ARG_LOCATION (2), "argument 3 in call to function "
6462 "%qE has enumerated type", fndecl
);
6465 else if (TREE_CODE (TREE_TYPE (args
[2])) == BOOLEAN_TYPE
)
6467 error_at (ARG_LOCATION (2), "argument 3 in call to function "
6468 "%qE has boolean type", fndecl
);
6475 case BUILT_IN_CLEAR_PADDING
:
6476 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 1))
6478 if (!POINTER_TYPE_P (TREE_TYPE (args
[0])))
6480 error_at (ARG_LOCATION (0), "argument %u in call to function "
6481 "%qE does not have pointer type", 1, fndecl
);
6484 else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (args
[0]))))
6486 error_at (ARG_LOCATION (0), "argument %u in call to function "
6487 "%qE points to incomplete type", 1, fndecl
);
6490 else if (TYPE_READONLY (TREE_TYPE (TREE_TYPE (args
[0]))))
6492 error_at (ARG_LOCATION (0), "argument %u in call to function %qE "
6493 "has pointer to %qs type (%qT)", 1, fndecl
, "const",
6494 TREE_TYPE (args
[0]));
6497 else if (TYPE_ATOMIC (TREE_TYPE (TREE_TYPE (args
[0]))))
6499 error_at (ARG_LOCATION (0), "argument %u in call to function %qE "
6500 "has pointer to %qs type (%qT)", 1, fndecl
,
6501 "_Atomic", TREE_TYPE (args
[0]));
6513 /* Subroutine of c_parse_error.
6514 Return the result of concatenating LHS and RHS. RHS is really
6515 a string literal, its first character is indicated by RHS_START and
6516 RHS_SIZE is its length (including the terminating NUL character).
6518 The caller is responsible for deleting the returned pointer. */
6521 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
6523 const size_t lhs_size
= strlen (lhs
);
6524 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
6525 memcpy (result
, lhs
, lhs_size
);
6526 memcpy (result
+ lhs_size
, rhs_start
, rhs_size
);
6530 /* Issue the error given by GMSGID at RICHLOC, indicating that it occurred
6531 before TOKEN, which had the associated VALUE. */
6534 c_parse_error (const char *gmsgid
, enum cpp_ttype token_type
,
6535 tree value
, unsigned char token_flags
,
6536 rich_location
*richloc
)
6538 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6540 char *message
= NULL
;
6542 if (token_type
== CPP_EOF
)
6543 message
= catenate_messages (gmsgid
, " at end of input");
6544 else if (token_type
== CPP_CHAR
6545 || token_type
== CPP_WCHAR
6546 || token_type
== CPP_CHAR16
6547 || token_type
== CPP_CHAR32
6548 || token_type
== CPP_UTF8CHAR
)
6550 unsigned int val
= TREE_INT_CST_LOW (value
);
6572 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
6573 message
= catenate_messages (gmsgid
, " before %s'%c'");
6575 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
6577 error_at (richloc
, message
, prefix
, val
);
6581 else if (token_type
== CPP_CHAR_USERDEF
6582 || token_type
== CPP_WCHAR_USERDEF
6583 || token_type
== CPP_CHAR16_USERDEF
6584 || token_type
== CPP_CHAR32_USERDEF
6585 || token_type
== CPP_UTF8CHAR_USERDEF
)
6586 message
= catenate_messages (gmsgid
,
6587 " before user-defined character literal");
6588 else if (token_type
== CPP_STRING_USERDEF
6589 || token_type
== CPP_WSTRING_USERDEF
6590 || token_type
== CPP_STRING16_USERDEF
6591 || token_type
== CPP_STRING32_USERDEF
6592 || token_type
== CPP_UTF8STRING_USERDEF
)
6593 message
= catenate_messages (gmsgid
, " before user-defined string literal");
6594 else if (token_type
== CPP_STRING
6595 || token_type
== CPP_WSTRING
6596 || token_type
== CPP_STRING16
6597 || token_type
== CPP_STRING32
6598 || token_type
== CPP_UTF8STRING
)
6599 message
= catenate_messages (gmsgid
, " before string constant");
6600 else if (token_type
== CPP_NUMBER
)
6601 message
= catenate_messages (gmsgid
, " before numeric constant");
6602 else if (token_type
== CPP_NAME
)
6604 message
= catenate_messages (gmsgid
, " before %qE");
6605 error_at (richloc
, message
, value
);
6609 else if (token_type
== CPP_PRAGMA
)
6610 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
6611 else if (token_type
== CPP_PRAGMA_EOL
)
6612 message
= catenate_messages (gmsgid
, " before end of line");
6613 else if (token_type
== CPP_DECLTYPE
)
6614 message
= catenate_messages (gmsgid
, " before %<decltype%>");
6615 else if (token_type
< N_TTYPES
)
6617 message
= catenate_messages (gmsgid
, " before %qs token");
6618 error_at (richloc
, message
, cpp_type2name (token_type
, token_flags
));
6623 error_at (richloc
, gmsgid
);
6627 error_at (richloc
, message
);
6630 #undef catenate_messages
6633 /* Return the gcc option code associated with the reason for a cpp
6634 message, or 0 if none. */
6637 c_option_controlling_cpp_diagnostic (enum cpp_warning_reason reason
)
6639 const struct cpp_reason_option_codes_t
*entry
;
6641 for (entry
= cpp_reason_option_codes
; entry
->reason
!= CPP_W_NONE
; entry
++)
6643 if (entry
->reason
== reason
)
6644 return entry
->option_code
;
6649 /* Return TRUE if the given option index corresponds to a diagnostic
6650 issued by libcpp. Linear search seems fine for now. */
6652 c_option_is_from_cpp_diagnostics (int option_index
)
6654 for (auto entry
= cpp_reason_option_codes
; entry
->reason
!= CPP_W_NONE
;
6657 if (entry
->option_code
== option_index
)
6663 /* Callback from cpp_diagnostic for PFILE to print diagnostics from the
6664 preprocessor. The diagnostic is of type LEVEL, with REASON set
6665 to the reason code if LEVEL is represents a warning, at location
6666 RICHLOC unless this is after lexing and the compiler's location
6667 should be used instead; MSG is the translated message and AP
6668 the arguments. Returns true if a diagnostic was emitted, false
6672 c_cpp_diagnostic (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
6673 enum cpp_diagnostic_level level
,
6674 enum cpp_warning_reason reason
,
6675 rich_location
*richloc
,
6676 const char *msg
, va_list *ap
)
6678 diagnostic_info diagnostic
;
6679 diagnostic_t dlevel
;
6680 bool save_warn_system_headers
= global_dc
->dc_warn_system_headers
;
6685 case CPP_DL_WARNING_SYSHDR
:
6688 global_dc
->dc_warn_system_headers
= 1;
6690 case CPP_DL_WARNING
:
6693 dlevel
= DK_WARNING
;
6695 case CPP_DL_PEDWARN
:
6696 if (flag_no_output
&& !flag_pedantic_errors
)
6698 dlevel
= DK_PEDWARN
;
6715 if (override_libcpp_locations
)
6716 richloc
->set_range (0, input_location
, SHOW_RANGE_WITH_CARET
);
6717 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
6719 diagnostic_override_option_index
6721 c_option_controlling_cpp_diagnostic (reason
));
6722 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
6723 if (level
== CPP_DL_WARNING_SYSHDR
)
6724 global_dc
->dc_warn_system_headers
= save_warn_system_headers
;
6728 /* Convert a character from the host to the target execution character
6729 set. cpplib handles this, mostly. */
6732 c_common_to_target_charset (HOST_WIDE_INT c
)
6734 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6735 zero-extended under -fno-signed-char. cpplib insists that characters
6736 and character constants are always unsigned. Hence we must convert
6738 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
6740 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
6742 if (flag_signed_char
)
6743 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
6744 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
6749 /* Fold an offsetof-like expression. EXPR is a nested sequence of component
6750 references with an INDIRECT_REF of a constant at the bottom; much like the
6751 traditional rendering of offsetof as a macro. TYPE is the desired type of
6752 the whole expression. Return the folded result. */
6755 fold_offsetof (tree expr
, tree type
, enum tree_code ctx
)
6758 tree_code code
= TREE_CODE (expr
);
6765 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
6766 return error_mark_node
;
6770 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6771 return error_mark_node
;
6775 if (!TREE_CONSTANT (TREE_OPERAND (expr
, 0)))
6777 error ("cannot apply %<offsetof%> to a non constant address");
6778 return error_mark_node
;
6780 return convert (type
, TREE_OPERAND (expr
, 0));
6783 base
= fold_offsetof (TREE_OPERAND (expr
, 0), type
, code
);
6784 if (base
== error_mark_node
)
6787 t
= TREE_OPERAND (expr
, 1);
6788 if (DECL_C_BIT_FIELD (t
))
6790 error ("attempt to take address of bit-field structure "
6792 return error_mark_node
;
6794 off
= size_binop_loc (input_location
, PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
6795 size_int (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (t
))
6800 base
= fold_offsetof (TREE_OPERAND (expr
, 0), type
, code
);
6801 if (base
== error_mark_node
)
6804 t
= TREE_OPERAND (expr
, 1);
6805 STRIP_ANY_LOCATION_WRAPPER (t
);
6807 /* Check if the offset goes beyond the upper bound of the array. */
6808 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) >= 0)
6810 tree upbound
= array_ref_up_bound (expr
);
6811 if (upbound
!= NULL_TREE
6812 && TREE_CODE (upbound
) == INTEGER_CST
6813 && !tree_int_cst_equal (upbound
,
6814 TYPE_MAX_VALUE (TREE_TYPE (upbound
))))
6816 if (ctx
!= ARRAY_REF
&& ctx
!= COMPONENT_REF
)
6817 upbound
= size_binop (PLUS_EXPR
, upbound
,
6818 build_int_cst (TREE_TYPE (upbound
), 1));
6819 if (tree_int_cst_lt (upbound
, t
))
6823 for (v
= TREE_OPERAND (expr
, 0);
6824 TREE_CODE (v
) == COMPONENT_REF
;
6825 v
= TREE_OPERAND (v
, 0))
6826 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v
, 0)))
6829 tree fld_chain
= DECL_CHAIN (TREE_OPERAND (v
, 1));
6830 for (; fld_chain
; fld_chain
= DECL_CHAIN (fld_chain
))
6831 if (TREE_CODE (fld_chain
) == FIELD_DECL
)
6837 /* Don't warn if the array might be considered a poor
6838 man's flexible array member with a very permissive
6839 definition thereof. */
6840 if (TREE_CODE (v
) == ARRAY_REF
6841 || TREE_CODE (v
) == COMPONENT_REF
)
6842 warning (OPT_Warray_bounds
,
6843 "index %E denotes an offset "
6844 "greater than size of %qT",
6845 t
, TREE_TYPE (TREE_OPERAND (expr
, 0)));
6850 t
= convert (sizetype
, t
);
6851 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
6855 /* Handle static members of volatile structs. */
6856 t
= TREE_OPERAND (expr
, 1);
6857 gcc_checking_assert (VAR_P (get_base_address (t
)));
6858 return fold_offsetof (t
, type
);
6864 if (!POINTER_TYPE_P (type
))
6865 return size_binop (PLUS_EXPR
, base
, convert (type
, off
));
6866 return fold_build_pointer_plus (base
, off
);
6869 /* *PTYPE is an incomplete array. Complete it with a domain based on
6870 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6871 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6872 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6875 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
6877 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
6878 int failure
= 0, quals
;
6879 bool overflow_p
= false;
6881 maxindex
= size_zero_node
;
6884 STRIP_ANY_LOCATION_WRAPPER (initial_value
);
6886 if (TREE_CODE (initial_value
) == STRING_CST
)
6889 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
6890 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
6892 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
6894 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
6896 if (vec_safe_is_empty (v
))
6900 maxindex
= ssize_int (-1);
6905 unsigned HOST_WIDE_INT cnt
;
6906 constructor_elt
*ce
;
6907 bool fold_p
= false;
6910 maxindex
= (*v
)[0].index
, fold_p
= true;
6912 curindex
= maxindex
;
6914 for (cnt
= 1; vec_safe_iterate (v
, cnt
, &ce
); cnt
++)
6916 bool curfold_p
= false;
6918 curindex
= ce
->index
, curfold_p
= true;
6923 /* Since we treat size types now as ordinary
6924 unsigned types, we need an explicit overflow
6926 tree orig
= curindex
;
6927 curindex
= fold_convert (sizetype
, curindex
);
6928 overflow_p
|= tree_int_cst_lt (curindex
, orig
);
6930 curindex
= size_binop (PLUS_EXPR
, curindex
,
6933 if (tree_int_cst_lt (maxindex
, curindex
))
6934 maxindex
= curindex
, fold_p
= curfold_p
;
6938 tree orig
= maxindex
;
6939 maxindex
= fold_convert (sizetype
, maxindex
);
6940 overflow_p
|= tree_int_cst_lt (maxindex
, orig
);
6946 /* Make an error message unless that happened already. */
6947 if (initial_value
!= error_mark_node
)
6959 elt
= TREE_TYPE (type
);
6960 quals
= TYPE_QUALS (strip_array_types (elt
));
6964 unqual_elt
= c_build_qualified_type (elt
, KEEP_QUAL_ADDR_SPACE (quals
));
6966 /* Using build_distinct_type_copy and modifying things afterward instead
6967 of using build_array_type to create a new type preserves all of the
6968 TYPE_LANG_FLAG_? bits that the front end may have set. */
6969 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6970 TREE_TYPE (main_type
) = unqual_elt
;
6971 TYPE_DOMAIN (main_type
)
6972 = build_range_type (TREE_TYPE (maxindex
),
6973 build_int_cst (TREE_TYPE (maxindex
), 0), maxindex
);
6974 TYPE_TYPELESS_STORAGE (main_type
) = TYPE_TYPELESS_STORAGE (type
);
6975 layout_type (main_type
);
6977 /* Make sure we have the canonical MAIN_TYPE. */
6978 hashval_t hashcode
= type_hash_canon_hash (main_type
);
6979 main_type
= type_hash_canon (hashcode
, main_type
);
6981 /* Fix the canonical type. */
6982 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
6983 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
6984 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
6985 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
6986 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
6987 != TYPE_DOMAIN (main_type
)))
6988 TYPE_CANONICAL (main_type
)
6989 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
6990 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)),
6991 TYPE_TYPELESS_STORAGE (main_type
));
6993 TYPE_CANONICAL (main_type
) = main_type
;
6998 type
= c_build_qualified_type (main_type
, quals
);
7000 if (COMPLETE_TYPE_P (type
)
7001 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
7002 && (overflow_p
|| TREE_OVERFLOW (TYPE_SIZE_UNIT (type
))))
7004 error ("size of array is too large");
7005 /* If we proceed with the array type as it is, we'll eventually
7006 crash in tree_to_[su]hwi(). */
7007 type
= error_mark_node
;
7014 /* INIT is an constructor of a structure with a flexible array member.
7015 Complete the flexible array member with a domain based on it's value. */
7017 complete_flexible_array_elts (tree init
)
7021 if (init
== NULL_TREE
|| TREE_CODE (init
) != CONSTRUCTOR
)
7024 if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init
)))
7027 elt
= CONSTRUCTOR_ELTS (init
)->last ().value
;
7028 type
= TREE_TYPE (elt
);
7029 if (TREE_CODE (type
) == ARRAY_TYPE
7030 && TYPE_SIZE (type
) == NULL_TREE
)
7031 complete_array_type (&TREE_TYPE (elt
), elt
, false);
7033 complete_flexible_array_elts (elt
);
7036 /* Like c_mark_addressable but don't check register qualifier. */
7038 c_common_mark_addressable_vec (tree t
)
7040 while (handled_component_p (t
) || TREE_CODE (t
) == C_MAYBE_CONST_EXPR
)
7042 if (TREE_CODE (t
) == C_MAYBE_CONST_EXPR
)
7043 t
= C_MAYBE_CONST_EXPR_EXPR (t
);
7045 t
= TREE_OPERAND (t
, 0);
7048 && TREE_CODE (t
) != PARM_DECL
7049 && TREE_CODE (t
) != COMPOUND_LITERAL_EXPR
7050 && TREE_CODE (t
) != TARGET_EXPR
)
7052 if (!VAR_P (t
) || !DECL_HARD_REGISTER (t
))
7053 TREE_ADDRESSABLE (t
) = 1;
7054 if (TREE_CODE (t
) == COMPOUND_LITERAL_EXPR
)
7055 TREE_ADDRESSABLE (COMPOUND_LITERAL_EXPR_DECL (t
)) = 1;
7056 else if (TREE_CODE (t
) == TARGET_EXPR
)
7057 TREE_ADDRESSABLE (TARGET_EXPR_SLOT (t
)) = 1;
7062 /* Used to help initialize the builtin-types.def table. When a type of
7063 the correct size doesn't exist, use error_mark_node instead of NULL.
7064 The later results in segfaults even when a decl using the type doesn't
7068 builtin_type_for_size (int size
, bool unsignedp
)
7070 tree type
= c_common_type_for_size (size
, unsignedp
);
7071 return type
? type
: error_mark_node
;
7074 /* Work out the size of the first argument of a call to
7075 __builtin_speculation_safe_value. Only pointers and integral types
7076 are permitted. Return -1 if the argument type is not supported or
7077 the size is too large; 0 if the argument type is a pointer or the
7078 size if it is integral. */
7079 static enum built_in_function
7080 speculation_safe_value_resolve_call (tree function
, vec
<tree
, va_gc
> *params
)
7082 /* Type of the argument. */
7086 if (vec_safe_is_empty (params
))
7088 error ("too few arguments to function %qE", function
);
7089 return BUILT_IN_NONE
;
7092 type
= TREE_TYPE ((*params
)[0]);
7093 if (TREE_CODE (type
) == ARRAY_TYPE
&& c_dialect_cxx ())
7095 /* Force array-to-pointer decay for C++. */
7096 (*params
)[0] = default_conversion ((*params
)[0]);
7097 type
= TREE_TYPE ((*params
)[0]);
7100 if (POINTER_TYPE_P (type
))
7101 return BUILT_IN_SPECULATION_SAFE_VALUE_PTR
;
7103 if (!INTEGRAL_TYPE_P (type
))
7106 if (!COMPLETE_TYPE_P (type
))
7109 size
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
7110 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
7111 return ((enum built_in_function
)
7112 ((int) BUILT_IN_SPECULATION_SAFE_VALUE_1
+ exact_log2 (size
)));
7115 /* Issue the diagnostic only if the argument is valid, otherwise
7116 it would be redundant at best and could be misleading. */
7117 if (type
!= error_mark_node
)
7118 error ("operand type %qT is incompatible with argument %d of %qE",
7121 return BUILT_IN_NONE
;
7124 /* Validate and coerce PARAMS, the arguments to ORIG_FUNCTION to fit
7125 the prototype for FUNCTION. The first argument is mandatory, a second
7126 argument, if present, must be type compatible with the first. */
7128 speculation_safe_value_resolve_params (location_t loc
, tree orig_function
,
7129 vec
<tree
, va_gc
> *params
)
7133 if (params
->length () == 0)
7135 error_at (loc
, "too few arguments to function %qE", orig_function
);
7139 else if (params
->length () > 2)
7141 error_at (loc
, "too many arguments to function %qE", orig_function
);
7146 if (TREE_CODE (TREE_TYPE (val
)) == ARRAY_TYPE
)
7147 val
= default_conversion (val
);
7148 if (!(TREE_CODE (TREE_TYPE (val
)) == POINTER_TYPE
7149 || TREE_CODE (TREE_TYPE (val
)) == INTEGER_TYPE
))
7152 "expecting argument of type pointer or of type integer "
7158 if (params
->length () == 2)
7160 tree val2
= (*params
)[1];
7161 if (TREE_CODE (TREE_TYPE (val2
)) == ARRAY_TYPE
)
7162 val2
= default_conversion (val2
);
7163 if (error_operand_p (val2
))
7165 if (!(TREE_TYPE (val
) == TREE_TYPE (val2
)
7166 || useless_type_conversion_p (TREE_TYPE (val
), TREE_TYPE (val2
))))
7168 error_at (loc
, "both arguments must be compatible");
7171 (*params
)[1] = val2
;
7177 /* Cast the result of the builtin back to the type of the first argument,
7178 preserving any qualifiers that it might have. */
7180 speculation_safe_value_resolve_return (tree first_param
, tree result
)
7182 tree ptype
= TREE_TYPE (first_param
);
7183 tree rtype
= TREE_TYPE (result
);
7184 ptype
= TYPE_MAIN_VARIANT (ptype
);
7186 if (tree_int_cst_equal (TYPE_SIZE (ptype
), TYPE_SIZE (rtype
)))
7187 return convert (ptype
, result
);
7192 /* A helper function for resolve_overloaded_builtin in resolving the
7193 overloaded __sync_ builtins. Returns a positive power of 2 if the
7194 first operand of PARAMS is a pointer to a supported data type.
7195 Returns 0 if an error is encountered.
7196 FETCH is true when FUNCTION is one of the _FETCH_OP_ or _OP_FETCH_
7200 sync_resolve_size (tree function
, vec
<tree
, va_gc
> *params
, bool fetch
)
7202 /* Type of the argument. */
7204 /* Type the argument points to. */
7208 if (vec_safe_is_empty (params
))
7210 error ("too few arguments to function %qE", function
);
7214 argtype
= type
= TREE_TYPE ((*params
)[0]);
7215 if (TREE_CODE (type
) == ARRAY_TYPE
&& c_dialect_cxx ())
7217 /* Force array-to-pointer decay for C++. */
7218 (*params
)[0] = default_conversion ((*params
)[0]);
7219 type
= TREE_TYPE ((*params
)[0]);
7221 if (TREE_CODE (type
) != POINTER_TYPE
)
7224 type
= TREE_TYPE (type
);
7225 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
7228 if (!COMPLETE_TYPE_P (type
))
7231 if (fetch
&& TREE_CODE (type
) == BOOLEAN_TYPE
)
7234 size
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
7235 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
7239 /* Issue the diagnostic only if the argument is valid, otherwise
7240 it would be redundant at best and could be misleading. */
7241 if (argtype
!= error_mark_node
)
7242 error ("operand type %qT is incompatible with argument %d of %qE",
7243 argtype
, 1, function
);
7247 /* A helper function for resolve_overloaded_builtin. Adds casts to
7248 PARAMS to make arguments match up with those of FUNCTION. Drops
7249 the variadic arguments at the end. Returns false if some error
7250 was encountered; true on success. */
7253 sync_resolve_params (location_t loc
, tree orig_function
, tree function
,
7254 vec
<tree
, va_gc
> *params
, bool orig_format
)
7256 function_args_iterator iter
;
7258 unsigned int parmnum
;
7260 function_args_iter_init (&iter
, TREE_TYPE (function
));
7261 /* We've declared the implementation functions to use "volatile void *"
7262 as the pointer parameter, so we shouldn't get any complaints from the
7263 call to check_function_arguments what ever type the user used. */
7264 function_args_iter_next (&iter
);
7265 ptype
= TREE_TYPE (TREE_TYPE ((*params
)[0]));
7266 ptype
= TYPE_MAIN_VARIANT (ptype
);
7268 /* For the rest of the values, we need to cast these to FTYPE, so that we
7269 don't get warnings for passing pointer types, etc. */
7275 arg_type
= function_args_iter_cond (&iter
);
7276 /* XXX void_type_node belies the abstraction. */
7277 if (arg_type
== void_type_node
)
7281 if (params
->length () <= parmnum
)
7283 error_at (loc
, "too few arguments to function %qE", orig_function
);
7287 /* Only convert parameters if arg_type is unsigned integer type with
7288 new format sync routines, i.e. don't attempt to convert pointer
7289 arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n),
7290 bool arguments (e.g. WEAK argument) or signed int arguments (memmodel
7292 if (TREE_CODE (arg_type
) == INTEGER_TYPE
&& TYPE_UNSIGNED (arg_type
))
7294 /* Ideally for the first conversion we'd use convert_for_assignment
7295 so that we get warnings for anything that doesn't match the pointer
7296 type. This isn't portable across the C and C++ front ends atm. */
7297 val
= (*params
)[parmnum
];
7298 val
= convert (ptype
, val
);
7299 val
= convert (arg_type
, val
);
7300 (*params
)[parmnum
] = val
;
7303 function_args_iter_next (&iter
);
7306 /* __atomic routines are not variadic. */
7307 if (!orig_format
&& params
->length () != parmnum
+ 1)
7309 error_at (loc
, "too many arguments to function %qE", orig_function
);
7313 /* The definition of these primitives is variadic, with the remaining
7314 being "an optional list of variables protected by the memory barrier".
7315 No clue what that's supposed to mean, precisely, but we consider all
7316 call-clobbered variables to be protected so we're safe. */
7317 params
->truncate (parmnum
+ 1);
7322 /* A helper function for resolve_overloaded_builtin. Adds a cast to
7323 RESULT to make it match the type of the first pointer argument in
7327 sync_resolve_return (tree first_param
, tree result
, bool orig_format
)
7329 tree ptype
= TREE_TYPE (TREE_TYPE (first_param
));
7330 tree rtype
= TREE_TYPE (result
);
7331 ptype
= TYPE_MAIN_VARIANT (ptype
);
7333 /* New format doesn't require casting unless the types are the same size. */
7334 if (orig_format
|| tree_int_cst_equal (TYPE_SIZE (ptype
), TYPE_SIZE (rtype
)))
7335 return convert (ptype
, result
);
7340 /* This function verifies the PARAMS to generic atomic FUNCTION.
7341 It returns the size if all the parameters are the same size, otherwise
7342 0 is returned if the parameters are invalid. */
7345 get_atomic_generic_size (location_t loc
, tree function
,
7346 vec
<tree
, va_gc
> *params
)
7348 unsigned int n_param
;
7349 unsigned int n_model
;
7350 unsigned int outputs
= 0; // bitset of output parameters
7355 /* Determine the parameter makeup. */
7356 switch (DECL_FUNCTION_CODE (function
))
7358 case BUILT_IN_ATOMIC_EXCHANGE
:
7363 case BUILT_IN_ATOMIC_LOAD
:
7368 case BUILT_IN_ATOMIC_STORE
:
7373 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
7382 if (vec_safe_length (params
) != n_param
)
7384 error_at (loc
, "incorrect number of arguments to function %qE", function
);
7388 /* Get type of first parameter, and determine its size. */
7389 type_0
= TREE_TYPE ((*params
)[0]);
7390 if (TREE_CODE (type_0
) == ARRAY_TYPE
&& c_dialect_cxx ())
7392 /* Force array-to-pointer decay for C++. */
7393 (*params
)[0] = default_conversion ((*params
)[0]);
7394 type_0
= TREE_TYPE ((*params
)[0]);
7396 if (TREE_CODE (type_0
) != POINTER_TYPE
|| VOID_TYPE_P (TREE_TYPE (type_0
)))
7398 error_at (loc
, "argument 1 of %qE must be a non-void pointer type",
7403 if (!COMPLETE_TYPE_P (TREE_TYPE (type_0
)))
7405 error_at (loc
, "argument 1 of %qE must be a pointer to a complete type",
7410 /* Types must be compile time constant sizes. */
7411 if (!tree_fits_uhwi_p ((TYPE_SIZE_UNIT (TREE_TYPE (type_0
)))))
7414 "argument 1 of %qE must be a pointer to a constant size type",
7419 size_0
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (type_0
)));
7421 /* Zero size objects are not allowed. */
7425 "argument 1 of %qE must be a pointer to a nonzero size object",
7430 /* Check each other parameter is a pointer and the same size. */
7431 for (x
= 0; x
< n_param
- n_model
; x
++)
7434 tree type
= TREE_TYPE ((*params
)[x
]);
7435 /* __atomic_compare_exchange has a bool in the 4th position, skip it. */
7436 if (n_param
== 6 && x
== 3)
7438 if (TREE_CODE (type
) == ARRAY_TYPE
&& c_dialect_cxx ())
7440 /* Force array-to-pointer decay for C++. */
7441 (*params
)[x
] = default_conversion ((*params
)[x
]);
7442 type
= TREE_TYPE ((*params
)[x
]);
7444 if (!POINTER_TYPE_P (type
))
7446 error_at (loc
, "argument %d of %qE must be a pointer type", x
+ 1,
7450 else if (TYPE_SIZE_UNIT (TREE_TYPE (type
))
7451 && TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type
))))
7454 error_at (loc
, "argument %d of %qE must be a pointer to a constant "
7455 "size type", x
+ 1, function
);
7458 else if (FUNCTION_POINTER_TYPE_P (type
))
7460 error_at (loc
, "argument %d of %qE must not be a pointer to a "
7461 "function", x
+ 1, function
);
7464 tree type_size
= TYPE_SIZE_UNIT (TREE_TYPE (type
));
7465 size
= type_size
? tree_to_uhwi (type_size
) : 0;
7468 error_at (loc
, "size mismatch in argument %d of %qE", x
+ 1,
7474 auto_diagnostic_group d
;
7475 int quals
= TYPE_QUALS (TREE_TYPE (type
));
7476 /* Must not write to an argument of a const-qualified type. */
7477 if (outputs
& (1 << x
) && quals
& TYPE_QUAL_CONST
)
7479 if (c_dialect_cxx ())
7481 error_at (loc
, "argument %d of %qE must not be a pointer to "
7482 "a %<const%> type", x
+ 1, function
);
7486 pedwarn (loc
, OPT_Wincompatible_pointer_types
, "argument %d "
7487 "of %qE discards %<const%> qualifier", x
+ 1,
7490 /* Only the first argument is allowed to be volatile. */
7491 if (x
> 0 && quals
& TYPE_QUAL_VOLATILE
)
7493 if (c_dialect_cxx ())
7495 error_at (loc
, "argument %d of %qE must not be a pointer to "
7496 "a %<volatile%> type", x
+ 1, function
);
7500 pedwarn (loc
, OPT_Wincompatible_pointer_types
, "argument %d "
7501 "of %qE discards %<volatile%> qualifier", x
+ 1,
7507 /* Check memory model parameters for validity. */
7508 for (x
= n_param
- n_model
; x
< n_param
; x
++)
7510 tree p
= (*params
)[x
];
7511 if (!INTEGRAL_TYPE_P (TREE_TYPE (p
)))
7513 error_at (loc
, "non-integer memory model argument %d of %qE", x
+ 1,
7517 p
= fold_for_warn (p
);
7518 if (TREE_CODE (p
) == INTEGER_CST
)
7520 /* memmodel_base masks the low 16 bits, thus ignore any bits above
7521 it by using TREE_INT_CST_LOW instead of tree_to_*hwi. Those high
7522 bits will be checked later during expansion in target specific
7524 if (memmodel_base (TREE_INT_CST_LOW (p
)) >= MEMMODEL_LAST
)
7525 warning_at (loc
, OPT_Winvalid_memory_model
,
7526 "invalid memory model argument %d of %qE", x
+ 1,
7535 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N
7536 at the beginning of the parameter list PARAMS representing the size of the
7537 objects. This is to match the library ABI requirement. LOC is the location
7538 of the function call.
7539 The new function is returned if it needed rebuilding, otherwise NULL_TREE is
7540 returned to allow the external call to be constructed. */
7543 add_atomic_size_parameter (unsigned n
, location_t loc
, tree function
,
7544 vec
<tree
, va_gc
> *params
)
7548 /* Insert a SIZE_T parameter as the first param. If there isn't
7549 enough space, allocate a new vector and recursively re-build with that. */
7550 if (!params
->space (1))
7552 unsigned int z
, len
;
7553 vec
<tree
, va_gc
> *v
;
7556 len
= params
->length ();
7557 vec_alloc (v
, len
+ 1);
7558 v
->quick_push (build_int_cst (size_type_node
, n
));
7559 for (z
= 0; z
< len
; z
++)
7560 v
->quick_push ((*params
)[z
]);
7561 f
= build_function_call_vec (loc
, vNULL
, function
, v
, NULL
);
7566 /* Add the size parameter and leave as a function call for processing. */
7567 size_node
= build_int_cst (size_type_node
, n
);
7568 params
->quick_insert (0, size_node
);
7573 /* Return whether atomic operations for naturally aligned N-byte
7574 arguments are supported, whether inline or through libatomic. */
7576 atomic_size_supported_p (int n
)
7587 return targetm
.scalar_mode_supported_p (TImode
);
7594 /* This will process an __atomic_exchange function call, determine whether it
7595 needs to be mapped to the _N variation, or turned into a library call.
7596 LOC is the location of the builtin call.
7597 FUNCTION is the DECL that has been invoked;
7598 PARAMS is the argument list for the call. The return value is non-null
7599 TRUE is returned if it is translated into the proper format for a call to the
7600 external library, and NEW_RETURN is set the tree for that function.
7601 FALSE is returned if processing for the _N variation is required, and
7602 NEW_RETURN is set to the return value the result is copied into. */
7604 resolve_overloaded_atomic_exchange (location_t loc
, tree function
,
7605 vec
<tree
, va_gc
> *params
, tree
*new_return
)
7607 tree p0
, p1
, p2
, p3
;
7608 tree I_type
, I_type_ptr
;
7609 int n
= get_atomic_generic_size (loc
, function
, params
);
7611 /* Size of 0 is an error condition. */
7614 *new_return
= error_mark_node
;
7618 /* If not a lock-free size, change to the library generic format. */
7619 if (!atomic_size_supported_p (n
))
7621 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
7625 /* Otherwise there is a lockfree match, transform the call from:
7626 void fn(T* mem, T* desired, T* return, model)
7628 *return = (T) (fn (In* mem, (In) *desired, model)) */
7635 /* Create pointer to appropriate size. */
7636 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
7637 I_type_ptr
= build_pointer_type (I_type
);
7639 /* Convert object pointer to required type. */
7640 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7642 /* Convert new value to required type, and dereference it. */
7643 p1
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
7644 p1
= build1 (VIEW_CONVERT_EXPR
, I_type
, p1
);
7647 /* Move memory model to the 3rd position, and end param list. */
7649 params
->truncate (3);
7651 /* Convert return pointer and dereference it for later assignment. */
7652 *new_return
= build_indirect_ref (loc
, p2
, RO_UNARY_STAR
);
7658 /* This will process an __atomic_compare_exchange function call, determine
7659 whether it needs to be mapped to the _N variation, or turned into a lib call.
7660 LOC is the location of the builtin call.
7661 FUNCTION is the DECL that has been invoked;
7662 PARAMS is the argument list for the call. The return value is non-null
7663 TRUE is returned if it is translated into the proper format for a call to the
7664 external library, and NEW_RETURN is set the tree for that function.
7665 FALSE is returned if processing for the _N variation is required. */
7668 resolve_overloaded_atomic_compare_exchange (location_t loc
, tree function
,
7669 vec
<tree
, va_gc
> *params
,
7673 tree I_type
, I_type_ptr
;
7674 int n
= get_atomic_generic_size (loc
, function
, params
);
7676 /* Size of 0 is an error condition. */
7679 *new_return
= error_mark_node
;
7683 /* If not a lock-free size, change to the library generic format. */
7684 if (!atomic_size_supported_p (n
))
7686 /* The library generic format does not have the weak parameter, so
7687 remove it from the param list. Since a parameter has been removed,
7688 we can be sure that there is room for the SIZE_T parameter, meaning
7689 there will not be a recursive rebuilding of the parameter list, so
7690 there is no danger this will be done twice. */
7693 (*params
)[3] = (*params
)[4];
7694 (*params
)[4] = (*params
)[5];
7695 params
->truncate (5);
7697 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
7701 /* Otherwise, there is a match, so the call needs to be transformed from:
7702 bool fn(T* mem, T* desired, T* return, weak, success, failure)
7704 bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */
7710 /* Create pointer to appropriate size. */
7711 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
7712 I_type_ptr
= build_pointer_type (I_type
);
7714 /* Convert object pointer to required type. */
7715 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7718 /* Convert expected pointer to required type. */
7719 p1
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p1
);
7722 /* Convert desired value to required type, and dereference it. */
7723 p2
= build_indirect_ref (loc
, p2
, RO_UNARY_STAR
);
7724 p2
= build1 (VIEW_CONVERT_EXPR
, I_type
, p2
);
7727 /* The rest of the parameters are fine. NULL means no special return value
7734 /* This will process an __atomic_load function call, determine whether it
7735 needs to be mapped to the _N variation, or turned into a library call.
7736 LOC is the location of the builtin call.
7737 FUNCTION is the DECL that has been invoked;
7738 PARAMS is the argument list for the call. The return value is non-null
7739 TRUE is returned if it is translated into the proper format for a call to the
7740 external library, and NEW_RETURN is set the tree for that function.
7741 FALSE is returned if processing for the _N variation is required, and
7742 NEW_RETURN is set to the return value the result is copied into. */
7745 resolve_overloaded_atomic_load (location_t loc
, tree function
,
7746 vec
<tree
, va_gc
> *params
, tree
*new_return
)
7749 tree I_type
, I_type_ptr
;
7750 int n
= get_atomic_generic_size (loc
, function
, params
);
7752 /* Size of 0 is an error condition. */
7755 *new_return
= error_mark_node
;
7759 /* If not a lock-free size, change to the library generic format. */
7760 if (!atomic_size_supported_p (n
))
7762 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
7766 /* Otherwise, there is a match, so the call needs to be transformed from:
7767 void fn(T* mem, T* return, model)
7769 *return = (T) (fn ((In *) mem, model)) */
7775 /* Create pointer to appropriate size. */
7776 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
7777 I_type_ptr
= build_pointer_type (I_type
);
7779 /* Convert object pointer to required type. */
7780 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7783 /* Move memory model to the 2nd position, and end param list. */
7785 params
->truncate (2);
7787 /* Convert return pointer and dereference it for later assignment. */
7788 *new_return
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
7794 /* This will process an __atomic_store function call, determine whether it
7795 needs to be mapped to the _N variation, or turned into a library call.
7796 LOC is the location of the builtin call.
7797 FUNCTION is the DECL that has been invoked;
7798 PARAMS is the argument list for the call. The return value is non-null
7799 TRUE is returned if it is translated into the proper format for a call to the
7800 external library, and NEW_RETURN is set the tree for that function.
7801 FALSE is returned if processing for the _N variation is required, and
7802 NEW_RETURN is set to the return value the result is copied into. */
7805 resolve_overloaded_atomic_store (location_t loc
, tree function
,
7806 vec
<tree
, va_gc
> *params
, tree
*new_return
)
7809 tree I_type
, I_type_ptr
;
7810 int n
= get_atomic_generic_size (loc
, function
, params
);
7812 /* Size of 0 is an error condition. */
7815 *new_return
= error_mark_node
;
7819 /* If not a lock-free size, change to the library generic format. */
7820 if (!atomic_size_supported_p (n
))
7822 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
7826 /* Otherwise, there is a match, so the call needs to be transformed from:
7827 void fn(T* mem, T* value, model)
7829 fn ((In *) mem, (In) *value, model) */
7834 /* Create pointer to appropriate size. */
7835 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
7836 I_type_ptr
= build_pointer_type (I_type
);
7838 /* Convert object pointer to required type. */
7839 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7842 /* Convert new value to required type, and dereference it. */
7843 p1
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
7844 p1
= build1 (VIEW_CONVERT_EXPR
, I_type
, p1
);
7847 /* The memory model is in the right spot already. Return is void. */
7848 *new_return
= NULL_TREE
;
7854 /* Some builtin functions are placeholders for other expressions. This
7855 function should be called immediately after parsing the call expression
7856 before surrounding code has committed to the type of the expression.
7858 LOC is the location of the builtin call.
7860 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7861 PARAMS is the argument list for the call. The return value is non-null
7862 when expansion is complete, and null if normal processing should
7866 resolve_overloaded_builtin (location_t loc
, tree function
,
7867 vec
<tree
, va_gc
> *params
)
7869 /* Is function one of the _FETCH_OP_ or _OP_FETCH_ built-ins?
7870 Those are not valid to call with a pointer to _Bool (or C++ bool)
7871 and so must be rejected. */
7872 bool fetch_op
= true;
7873 bool orig_format
= true;
7874 tree new_return
= NULL_TREE
;
7876 switch (DECL_BUILT_IN_CLASS (function
))
7878 case BUILT_IN_NORMAL
:
7881 if (targetm
.resolve_overloaded_builtin
)
7882 return targetm
.resolve_overloaded_builtin (loc
, function
, params
);
7889 /* Handle BUILT_IN_NORMAL here. */
7890 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
7893 case BUILT_IN_SPECULATION_SAFE_VALUE_N
:
7895 tree new_function
, first_param
, result
;
7896 enum built_in_function fncode
7897 = speculation_safe_value_resolve_call (function
, params
);
7899 if (fncode
== BUILT_IN_NONE
)
7900 return error_mark_node
;
7902 first_param
= (*params
)[0];
7903 if (!speculation_safe_value_resolve_params (loc
, function
, params
))
7904 return error_mark_node
;
7906 if (targetm
.have_speculation_safe_value (true))
7908 new_function
= builtin_decl_explicit (fncode
);
7909 result
= build_function_call_vec (loc
, vNULL
, new_function
, params
,
7912 if (result
== error_mark_node
)
7915 return speculation_safe_value_resolve_return (first_param
, result
);
7919 /* This target doesn't have, or doesn't need, active mitigation
7920 against incorrect speculative execution. Simply return the
7921 first parameter to the builtin. */
7922 if (!targetm
.have_speculation_safe_value (false))
7923 /* The user has invoked __builtin_speculation_safe_value
7924 even though __HAVE_SPECULATION_SAFE_VALUE is not
7925 defined: emit a warning. */
7926 warning_at (input_location
, 0,
7927 "this target does not define a speculation barrier; "
7928 "your program will still execute correctly, "
7929 "but incorrect speculation may not be "
7932 /* If the optional second argument is present, handle any side
7934 if (params
->length () == 2
7935 && TREE_SIDE_EFFECTS ((*params
)[1]))
7936 return build2 (COMPOUND_EXPR
, TREE_TYPE (first_param
),
7937 (*params
)[1], first_param
);
7943 case BUILT_IN_ATOMIC_EXCHANGE
:
7944 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
7945 case BUILT_IN_ATOMIC_LOAD
:
7946 case BUILT_IN_ATOMIC_STORE
:
7948 /* Handle these 4 together so that they can fall through to the next
7949 case if the call is transformed to an _N variant. */
7952 case BUILT_IN_ATOMIC_EXCHANGE
:
7954 if (resolve_overloaded_atomic_exchange (loc
, function
, params
,
7957 /* Change to the _N variant. */
7958 orig_code
= BUILT_IN_ATOMIC_EXCHANGE_N
;
7962 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
7964 if (resolve_overloaded_atomic_compare_exchange (loc
, function
,
7968 /* Change to the _N variant. */
7969 orig_code
= BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
;
7972 case BUILT_IN_ATOMIC_LOAD
:
7974 if (resolve_overloaded_atomic_load (loc
, function
, params
,
7977 /* Change to the _N variant. */
7978 orig_code
= BUILT_IN_ATOMIC_LOAD_N
;
7981 case BUILT_IN_ATOMIC_STORE
:
7983 if (resolve_overloaded_atomic_store (loc
, function
, params
,
7986 /* Change to the _N variant. */
7987 orig_code
= BUILT_IN_ATOMIC_STORE_N
;
7995 case BUILT_IN_ATOMIC_EXCHANGE_N
:
7996 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
:
7997 case BUILT_IN_ATOMIC_LOAD_N
:
7998 case BUILT_IN_ATOMIC_STORE_N
:
8001 case BUILT_IN_ATOMIC_ADD_FETCH_N
:
8002 case BUILT_IN_ATOMIC_SUB_FETCH_N
:
8003 case BUILT_IN_ATOMIC_AND_FETCH_N
:
8004 case BUILT_IN_ATOMIC_NAND_FETCH_N
:
8005 case BUILT_IN_ATOMIC_XOR_FETCH_N
:
8006 case BUILT_IN_ATOMIC_OR_FETCH_N
:
8007 case BUILT_IN_ATOMIC_FETCH_ADD_N
:
8008 case BUILT_IN_ATOMIC_FETCH_SUB_N
:
8009 case BUILT_IN_ATOMIC_FETCH_AND_N
:
8010 case BUILT_IN_ATOMIC_FETCH_NAND_N
:
8011 case BUILT_IN_ATOMIC_FETCH_XOR_N
:
8012 case BUILT_IN_ATOMIC_FETCH_OR_N
:
8013 orig_format
= false;
8015 case BUILT_IN_SYNC_FETCH_AND_ADD_N
:
8016 case BUILT_IN_SYNC_FETCH_AND_SUB_N
:
8017 case BUILT_IN_SYNC_FETCH_AND_OR_N
:
8018 case BUILT_IN_SYNC_FETCH_AND_AND_N
:
8019 case BUILT_IN_SYNC_FETCH_AND_XOR_N
:
8020 case BUILT_IN_SYNC_FETCH_AND_NAND_N
:
8021 case BUILT_IN_SYNC_ADD_AND_FETCH_N
:
8022 case BUILT_IN_SYNC_SUB_AND_FETCH_N
:
8023 case BUILT_IN_SYNC_OR_AND_FETCH_N
:
8024 case BUILT_IN_SYNC_AND_AND_FETCH_N
:
8025 case BUILT_IN_SYNC_XOR_AND_FETCH_N
:
8026 case BUILT_IN_SYNC_NAND_AND_FETCH_N
:
8027 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
:
8028 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N
:
8029 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_N
:
8030 case BUILT_IN_SYNC_LOCK_RELEASE_N
:
8032 /* The following are not _FETCH_OPs and must be accepted with
8033 pointers to _Bool (or C++ bool). */
8036 (orig_code
!= BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
8037 && orig_code
!= BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N
8038 && orig_code
!= BUILT_IN_SYNC_LOCK_TEST_AND_SET_N
8039 && orig_code
!= BUILT_IN_SYNC_LOCK_RELEASE_N
);
8041 int n
= sync_resolve_size (function
, params
, fetch_op
);
8042 tree new_function
, first_param
, result
;
8043 enum built_in_function fncode
;
8046 return error_mark_node
;
8048 fncode
= (enum built_in_function
)((int)orig_code
+ exact_log2 (n
) + 1);
8049 new_function
= builtin_decl_explicit (fncode
);
8050 if (!sync_resolve_params (loc
, function
, new_function
, params
,
8052 return error_mark_node
;
8054 first_param
= (*params
)[0];
8055 result
= build_function_call_vec (loc
, vNULL
, new_function
, params
,
8057 if (result
== error_mark_node
)
8059 if (orig_code
!= BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
8060 && orig_code
!= BUILT_IN_SYNC_LOCK_RELEASE_N
8061 && orig_code
!= BUILT_IN_ATOMIC_STORE_N
8062 && orig_code
!= BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
)
8063 result
= sync_resolve_return (first_param
, result
, orig_format
);
8066 /* Prevent -Wunused-value warning. */
8067 TREE_USED (result
) = true;
8069 /* If new_return is set, assign function to that expr and cast the
8070 result to void since the generic interface returned void. */
8073 /* Cast function result from I{1,2,4,8,16} to the required type. */
8074 result
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (new_return
), result
);
8075 result
= build2 (MODIFY_EXPR
, TREE_TYPE (new_return
), new_return
,
8077 TREE_SIDE_EFFECTS (result
) = 1;
8078 protected_set_expr_location (result
, loc
);
8079 result
= convert (void_type_node
, result
);
8089 /* vector_types_compatible_elements_p is used in type checks of vectors
8090 values used as operands of binary operators. Where it returns true, and
8091 the other checks of the caller succeed (being vector types in he first
8092 place, and matching number of elements), we can just treat the types
8093 as essentially the same.
8094 Contrast with vector_targets_convertible_p, which is used for vector
8095 pointer types, and vector_types_convertible_p, which will allow
8096 language-specific matches under the control of flag_lax_vector_conversions,
8097 and might still require a conversion. */
8098 /* True if vector types T1 and T2 can be inputs to the same binary
8099 operator without conversion.
8100 We don't check the overall vector size here because some of our callers
8101 want to give different error messages when the vectors are compatible
8102 except for the element count. */
8105 vector_types_compatible_elements_p (tree t1
, tree t2
)
8107 bool opaque
= TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
);
8108 t1
= TREE_TYPE (t1
);
8109 t2
= TREE_TYPE (t2
);
8111 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
8113 gcc_assert ((INTEGRAL_TYPE_P (t1
)
8115 || c1
== FIXED_POINT_TYPE
)
8116 && (INTEGRAL_TYPE_P (t2
)
8118 || c2
== FIXED_POINT_TYPE
));
8120 t1
= c_common_signed_type (t1
);
8121 t2
= c_common_signed_type (t2
);
8122 /* Equality works here because c_common_signed_type uses
8123 TYPE_MAIN_VARIANT. */
8126 if (opaque
&& c1
== c2
8127 && (INTEGRAL_TYPE_P (t1
) || c1
== REAL_TYPE
)
8128 && TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
8133 /* Check for missing format attributes on function pointers. LTYPE is
8134 the new type or left-hand side type. RTYPE is the old type or
8135 right-hand side type. Returns TRUE if LTYPE is missing the desired
8139 check_missing_format_attribute (tree ltype
, tree rtype
)
8141 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
8144 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
8145 if (is_attribute_p ("format", get_attribute_name (ra
)))
8150 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
8151 if (is_attribute_p ("format", get_attribute_name (la
)))
8159 /* Setup a TYPE_DECL node as a typedef representation.
8161 X is a TYPE_DECL for a typedef statement. Create a brand new
8162 ..._TYPE node (which will be just a variant of the existing
8163 ..._TYPE node with identical properties) and then install X
8164 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
8166 The whole point here is to end up with a situation where each
8167 and every ..._TYPE node the compiler creates will be uniquely
8168 associated with AT MOST one node representing a typedef name.
8169 This way, even though the compiler substitutes corresponding
8170 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
8171 early on, later parts of the compiler can always do the reverse
8172 translation and get back the corresponding typedef name. For
8175 typedef struct S MY_TYPE;
8178 Later parts of the compiler might only know that `object' was of
8179 type `struct S' if it were not for code just below. With this
8180 code however, later parts of the compiler see something like:
8182 struct S' == struct S
8183 typedef struct S' MY_TYPE;
8186 And they can then deduce (from the node for type struct S') that
8187 the original object declaration was:
8191 Being able to do this is important for proper support of protoize,
8192 and also for generating precise symbolic debugging information
8193 which takes full account of the programmer's (typedef) vocabulary.
8195 Obviously, we don't want to generate a duplicate ..._TYPE node if
8196 the TYPE_DECL node that we are now processing really represents a
8197 standard built-in type. */
8200 set_underlying_type (tree x
)
8202 if (x
== error_mark_node
|| TREE_TYPE (x
) == error_mark_node
)
8204 if (DECL_IS_UNDECLARED_BUILTIN (x
) && TREE_CODE (TREE_TYPE (x
)) != ARRAY_TYPE
)
8206 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
8207 TYPE_NAME (TREE_TYPE (x
)) = x
;
8209 else if (DECL_ORIGINAL_TYPE (x
))
8210 gcc_checking_assert (TYPE_NAME (TREE_TYPE (x
)) == x
);
8213 tree tt
= TREE_TYPE (x
);
8214 DECL_ORIGINAL_TYPE (x
) = tt
;
8215 tt
= build_variant_type_copy (tt
);
8216 TYPE_STUB_DECL (tt
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
8219 /* Mark the type as used only when its type decl is decorated
8220 with attribute unused. */
8221 if (lookup_attribute ("unused", DECL_ATTRIBUTES (x
)))
8228 /* Return true if it is worth exposing the DECL_ORIGINAL_TYPE of TYPE to
8229 the user in diagnostics, false if it would be better to use TYPE itself.
8230 TYPE is known to satisfy typedef_variant_p. */
8233 user_facing_original_type_p (const_tree type
)
8235 gcc_assert (typedef_variant_p (type
));
8236 tree decl
= TYPE_NAME (type
);
8238 /* Look through any typedef in "user" code. */
8239 if (!DECL_IN_SYSTEM_HEADER (decl
) && !DECL_IS_UNDECLARED_BUILTIN (decl
))
8242 /* If the original type is also named and is in the user namespace,
8243 assume it too is a user-facing type. */
8244 tree orig_type
= DECL_ORIGINAL_TYPE (decl
);
8245 if (tree orig_id
= TYPE_IDENTIFIER (orig_type
))
8246 if (!name_reserved_for_implementation_p (IDENTIFIER_POINTER (orig_id
)))
8249 switch (TREE_CODE (orig_type
))
8251 /* Don't look through to an anonymous vector type, since the syntax
8252 we use for them in diagnostics isn't real C or C++ syntax.
8253 And if ORIG_TYPE is named but in the implementation namespace,
8254 TYPE is likely to be more meaningful to the user. */
8258 /* Don't expose anonymous tag types that are presumably meant to be
8259 known by their typedef name. Also don't expose tags that are in
8260 the implementation namespace, such as:
8262 typedef struct __foo foo; */
8268 /* Look through to anything else. */
8274 /* Record the types used by the current global variable declaration
8275 being parsed, so that we can decide later to emit their debug info.
8276 Those types are in types_used_by_cur_var_decl, and we are going to
8277 store them in the types_used_by_vars_hash hash table.
8278 DECL is the declaration of the global variable that has been parsed. */
8281 record_types_used_by_current_var_decl (tree decl
)
8283 gcc_assert (decl
&& DECL_P (decl
) && TREE_STATIC (decl
));
8285 while (types_used_by_cur_var_decl
&& !types_used_by_cur_var_decl
->is_empty ())
8287 tree type
= types_used_by_cur_var_decl
->pop ();
8288 types_used_by_var_decl_insert (type
, decl
);
8292 /* The C and C++ parsers both use vectors to hold function arguments.
8293 For efficiency, we keep a cache of unused vectors. This is the
8296 typedef vec
<tree
, va_gc
> *tree_gc_vec
;
8297 static GTY((deletable
)) vec
<tree_gc_vec
, va_gc
> *tree_vector_cache
;
8299 /* Return a new vector from the cache. If the cache is empty,
8300 allocate a new vector. These vectors are GC'ed, so it is OK if the
8301 pointer is not released.. */
8304 make_tree_vector (void)
8306 if (tree_vector_cache
&& !tree_vector_cache
->is_empty ())
8307 return tree_vector_cache
->pop ();
8310 /* Passing 0 to vec::alloc returns NULL, and our callers require
8311 that we always return a non-NULL value. The vector code uses
8312 4 when growing a NULL vector, so we do too. */
8313 vec
<tree
, va_gc
> *v
;
8319 /* Release a vector of trees back to the cache. */
8322 release_tree_vector (vec
<tree
, va_gc
> *vec
)
8326 if (vec
->allocated () >= 16)
8327 /* Don't cache vecs that have expanded more than once. On a p64
8328 target, vecs double in alloc size with each power of 2 elements, e.g
8329 at 16 elements the alloc increases from 128 to 256 bytes. */
8334 vec_safe_push (tree_vector_cache
, vec
);
8339 /* Get a new tree vector holding a single tree. */
8342 make_tree_vector_single (tree t
)
8344 vec
<tree
, va_gc
> *ret
= make_tree_vector ();
8345 ret
->quick_push (t
);
8349 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */
8352 make_tree_vector_from_list (tree list
)
8354 vec
<tree
, va_gc
> *ret
= make_tree_vector ();
8355 for (; list
; list
= TREE_CHAIN (list
))
8356 vec_safe_push (ret
, TREE_VALUE (list
));
8360 /* Get a new tree vector of the values of a CONSTRUCTOR. */
8363 make_tree_vector_from_ctor (tree ctor
)
8365 vec
<tree
,va_gc
> *ret
= make_tree_vector ();
8366 vec_safe_reserve (ret
, CONSTRUCTOR_NELTS (ctor
));
8367 for (unsigned i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
8368 ret
->quick_push (CONSTRUCTOR_ELT (ctor
, i
)->value
);
8372 /* Get a new tree vector which is a copy of an existing one. */
8375 make_tree_vector_copy (const vec
<tree
, va_gc
> *orig
)
8377 vec
<tree
, va_gc
> *ret
;
8381 ret
= make_tree_vector ();
8382 vec_safe_reserve (ret
, vec_safe_length (orig
));
8383 FOR_EACH_VEC_SAFE_ELT (orig
, ix
, t
)
8384 ret
->quick_push (t
);
8388 /* Return true if KEYWORD starts a type specifier. */
8391 keyword_begins_type_specifier (enum rid keyword
)
8425 if (keyword
>= RID_FIRST_INT_N
8426 && keyword
< RID_FIRST_INT_N
+ NUM_INT_N_ENTS
8427 && int_n_enabled_p
[keyword
-RID_FIRST_INT_N
])
8433 /* Return true if KEYWORD names a type qualifier. */
8436 keyword_is_type_qualifier (enum rid keyword
)
8450 /* Return true if KEYWORD names a storage class specifier.
8452 RID_TYPEDEF is not included in this list despite `typedef' being
8453 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
8454 such for syntactic convenience only. */
8457 keyword_is_storage_class_specifier (enum rid keyword
)
8473 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
8476 keyword_is_function_specifier (enum rid keyword
)
8490 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
8491 declaration-specifier (C99 6.7). */
8494 keyword_is_decl_specifier (enum rid keyword
)
8496 if (keyword_is_storage_class_specifier (keyword
)
8497 || keyword_is_type_qualifier (keyword
)
8498 || keyword_is_function_specifier (keyword
))
8513 /* Initialize language-specific-bits of tree_contains_struct. */
8516 c_common_init_ts (void)
8518 MARK_TS_EXP (SIZEOF_EXPR
);
8519 MARK_TS_EXP (PAREN_SIZEOF_EXPR
);
8520 MARK_TS_EXP (C_MAYBE_CONST_EXPR
);
8521 MARK_TS_EXP (EXCESS_PRECISION_EXPR
);
8522 MARK_TS_EXP (BREAK_STMT
);
8523 MARK_TS_EXP (CONTINUE_STMT
);
8524 MARK_TS_EXP (DO_STMT
);
8525 MARK_TS_EXP (FOR_STMT
);
8526 MARK_TS_EXP (SWITCH_STMT
);
8527 MARK_TS_EXP (WHILE_STMT
);
8530 /* Build a user-defined numeric literal out of an integer constant type VALUE
8531 with identifier SUFFIX. */
8534 build_userdef_literal (tree suffix_id
, tree value
,
8535 enum overflow_type overflow
, tree num_string
)
8537 tree literal
= make_node (USERDEF_LITERAL
);
8538 USERDEF_LITERAL_SUFFIX_ID (literal
) = suffix_id
;
8539 USERDEF_LITERAL_VALUE (literal
) = value
;
8540 USERDEF_LITERAL_OVERFLOW (literal
) = overflow
;
8541 USERDEF_LITERAL_NUM_STRING (literal
) = num_string
;
8545 /* For vector[index], convert the vector to an array of the underlying type.
8546 Return true if the resulting ARRAY_REF should not be an lvalue. */
8549 convert_vector_to_array_for_subscript (location_t loc
,
8550 tree
*vecp
, tree index
)
8553 if (gnu_vector_type_p (TREE_TYPE (*vecp
)))
8555 tree type
= TREE_TYPE (*vecp
);
8557 ret
= !lvalue_p (*vecp
);
8559 index
= fold_for_warn (index
);
8560 if (TREE_CODE (index
) == INTEGER_CST
)
8561 if (!tree_fits_uhwi_p (index
)
8562 || maybe_ge (tree_to_uhwi (index
), TYPE_VECTOR_SUBPARTS (type
)))
8563 warning_at (loc
, OPT_Warray_bounds
, "index value is out of bound");
8565 /* We are building an ARRAY_REF so mark the vector as addressable
8566 to not run into the gimplifiers premature setting of DECL_GIMPLE_REG_P
8567 for function parameters. */
8568 c_common_mark_addressable_vec (*vecp
);
8570 *vecp
= build1 (VIEW_CONVERT_EXPR
,
8571 build_array_type_nelts (TREE_TYPE (type
),
8572 TYPE_VECTOR_SUBPARTS (type
)),
8578 /* Determine which of the operands, if any, is a scalar that needs to be
8579 converted to a vector, for the range of operations. */
8581 scalar_to_vector (location_t loc
, enum tree_code code
, tree op0
, tree op1
,
8584 tree type0
= TREE_TYPE (op0
);
8585 tree type1
= TREE_TYPE (op1
);
8586 bool integer_only_op
= false;
8587 enum stv_conv ret
= stv_firstarg
;
8589 gcc_assert (gnu_vector_type_p (type0
) || gnu_vector_type_p (type1
));
8592 /* Most GENERIC binary expressions require homogeneous arguments.
8593 LSHIFT_EXPR and RSHIFT_EXPR are exceptions and accept a first
8594 argument that is a vector and a second one that is a scalar, so
8595 we never return stv_secondarg for them. */
8598 if (TREE_CODE (type0
) == INTEGER_TYPE
8599 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
8601 if (unsafe_conversion_p (TREE_TYPE (type1
), op0
,
8605 error_at (loc
, "conversion of scalar %qT to vector %qT "
8606 "involves truncation", type0
, type1
);
8610 return stv_firstarg
;
8617 integer_only_op
= true;
8625 case TRUNC_DIV_EXPR
:
8627 case FLOOR_DIV_EXPR
:
8628 case ROUND_DIV_EXPR
:
8629 case EXACT_DIV_EXPR
:
8630 case TRUNC_MOD_EXPR
:
8631 case FLOOR_MOD_EXPR
:
8639 /* What about UNLT_EXPR? */
8640 if (gnu_vector_type_p (type0
))
8642 ret
= stv_secondarg
;
8643 std::swap (type0
, type1
);
8644 std::swap (op0
, op1
);
8647 if (TREE_CODE (type0
) == INTEGER_TYPE
8648 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
8650 if (unsafe_conversion_p (TREE_TYPE (type1
), op0
,
8654 error_at (loc
, "conversion of scalar %qT to vector %qT "
8655 "involves truncation", type0
, type1
);
8660 else if (!integer_only_op
8661 /* Allow integer --> real conversion if safe. */
8662 && (TREE_CODE (type0
) == REAL_TYPE
8663 || TREE_CODE (type0
) == INTEGER_TYPE
)
8664 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (type1
)))
8666 if (unsafe_conversion_p (TREE_TYPE (type1
), op0
,
8670 error_at (loc
, "conversion of scalar %qT to vector %qT "
8671 "involves truncation", type0
, type1
);
8683 /* Return the alignment of std::max_align_t.
8685 [support.types.layout] The type max_align_t is a POD type whose alignment
8686 requirement is at least as great as that of every scalar type, and whose
8687 alignment requirement is supported in every context. */
8690 max_align_t_align ()
8692 unsigned int max_align
= MAX (TYPE_ALIGN (long_long_integer_type_node
),
8693 TYPE_ALIGN (long_double_type_node
));
8694 if (float128_type_node
!= NULL_TREE
)
8695 max_align
= MAX (max_align
, TYPE_ALIGN (float128_type_node
));
8699 /* Return true iff ALIGN is an integral constant that is a fundamental
8700 alignment, as defined by [basic.align] in the c++-11
8705 [A fundamental alignment is represented by an alignment less than or
8706 equal to the greatest alignment supported by the implementation
8707 in all contexts, which is equal to alignof(max_align_t)]. */
8710 cxx_fundamental_alignment_p (unsigned align
)
8712 return (align
<= max_align_t_align ());
8715 /* Return true if T is a pointer to a zero-sized aggregate. */
8718 pointer_to_zero_sized_aggr_p (tree t
)
8720 if (!POINTER_TYPE_P (t
))
8723 return (TYPE_SIZE (t
) && integer_zerop (TYPE_SIZE (t
)));
8726 /* For an EXPR of a FUNCTION_TYPE that references a GCC built-in function
8727 with no library fallback or for an ADDR_EXPR whose operand is such type
8728 issues an error pointing to the location LOC.
8729 Returns true when the expression has been diagnosed and false
8733 reject_gcc_builtin (const_tree expr
, location_t loc
/* = UNKNOWN_LOCATION */)
8735 if (TREE_CODE (expr
) == ADDR_EXPR
)
8736 expr
= TREE_OPERAND (expr
, 0);
8738 STRIP_ANY_LOCATION_WRAPPER (expr
);
8740 if (TREE_TYPE (expr
)
8741 && TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
8742 && TREE_CODE (expr
) == FUNCTION_DECL
8743 /* The intersection of DECL_BUILT_IN and DECL_IS_UNDECLARED_BUILTIN avoids
8744 false positives for user-declared built-ins such as abs or
8745 strlen, and for C++ operators new and delete.
8746 The c_decl_implicit() test avoids false positives for implicitly
8747 declared built-ins with library fallbacks (such as abs). */
8748 && fndecl_built_in_p (expr
)
8749 && DECL_IS_UNDECLARED_BUILTIN (expr
)
8750 && !c_decl_implicit (expr
)
8751 && !DECL_ASSEMBLER_NAME_SET_P (expr
))
8753 if (loc
== UNKNOWN_LOCATION
)
8754 loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
8756 /* Reject arguments that are built-in functions with
8757 no library fallback. */
8758 error_at (loc
, "built-in function %qE must be directly called", expr
);
8766 /* Issue an ERROR for an invalid SIZE of array NAME which is null
8767 for unnamed arrays. */
8770 invalid_array_size_error (location_t loc
, cst_size_error error
,
8771 const_tree size
, const_tree name
)
8773 tree maxsize
= max_object_size ();
8776 case cst_size_not_constant
:
8778 error_at (loc
, "size of array %qE is not a constant expression",
8781 error_at (loc
, "size of array is not a constant expression");
8783 case cst_size_negative
:
8785 error_at (loc
, "size %qE of array %qE is negative",
8788 error_at (loc
, "size %qE of array is negative",
8791 case cst_size_too_big
:
8793 error_at (loc
, "size %qE of array %qE exceeds maximum "
8794 "object size %qE", size
, name
, maxsize
);
8796 error_at (loc
, "size %qE of array exceeds maximum "
8797 "object size %qE", size
, maxsize
);
8799 case cst_size_overflow
:
8801 error_at (loc
, "size of array %qE exceeds maximum "
8802 "object size %qE", name
, maxsize
);
8804 error_at (loc
, "size of array exceeds maximum "
8805 "object size %qE", maxsize
);
8812 /* Check if array size calculations overflow or if the array covers more
8813 than half of the address space. Return true if the size of the array
8814 is valid, false otherwise. T is either the type of the array or its
8815 size, and NAME is the name of the array, or null for unnamed arrays. */
8818 valid_array_size_p (location_t loc
, const_tree t
, tree name
, bool complain
)
8820 if (t
== error_mark_node
)
8826 if (!COMPLETE_TYPE_P (t
))
8828 size
= TYPE_SIZE_UNIT (t
);
8833 if (TREE_CODE (size
) != INTEGER_CST
)
8836 cst_size_error error
;
8837 if (valid_constant_size_p (size
, &error
))
8843 if (TREE_CODE (TREE_TYPE (size
)) == ENUMERAL_TYPE
)
8844 /* Show the value of the enumerator rather than its name. */
8845 size
= convert (ssizetype
, const_cast<tree
> (size
));
8847 invalid_array_size_error (loc
, error
, size
, name
);
8851 /* Read SOURCE_DATE_EPOCH from environment to have a deterministic
8852 timestamp to replace embedded current dates to get reproducible
8853 results. Returns -1 if SOURCE_DATE_EPOCH is not defined. */
8856 cb_get_source_date_epoch (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
8858 char *source_date_epoch
;
8862 source_date_epoch
= getenv ("SOURCE_DATE_EPOCH");
8863 if (!source_date_epoch
)
8867 #if defined(INT64_T_IS_LONG)
8868 epoch
= strtol (source_date_epoch
, &endptr
, 10);
8870 epoch
= strtoll (source_date_epoch
, &endptr
, 10);
8872 if (errno
!= 0 || endptr
== source_date_epoch
|| *endptr
!= '\0'
8873 || epoch
< 0 || epoch
> MAX_SOURCE_DATE_EPOCH
)
8875 error_at (input_location
, "environment variable %qs must "
8876 "expand to a non-negative integer less than or equal to %wd",
8877 "SOURCE_DATE_EPOCH", MAX_SOURCE_DATE_EPOCH
);
8881 return (time_t) epoch
;
8884 /* Callback for libcpp for offering spelling suggestions for misspelled
8885 directives. GOAL is an unrecognized string; CANDIDATES is a
8886 NULL-terminated array of candidate strings. Return the closest
8887 match to GOAL within CANDIDATES, or NULL if none are good
8891 cb_get_suggestion (cpp_reader
*, const char *goal
,
8892 const char *const *candidates
)
8894 best_match
<const char *, const char *> bm (goal
);
8896 bm
.consider (*candidates
++);
8897 return bm
.get_best_meaningful_candidate ();
8900 /* Return the latice point which is the wider of the two FLT_EVAL_METHOD
8901 modes X, Y. This isn't just >, as the FLT_EVAL_METHOD values added
8902 by C TS 18661-3 for interchange types that are computed in their
8903 native precision are larger than the C11 values for evaluating in the
8904 precision of float/double/long double. If either mode is
8905 FLT_EVAL_METHOD_UNPREDICTABLE, return that. */
8907 enum flt_eval_method
8908 excess_precision_mode_join (enum flt_eval_method x
,
8909 enum flt_eval_method y
)
8911 if (x
== FLT_EVAL_METHOD_UNPREDICTABLE
8912 || y
== FLT_EVAL_METHOD_UNPREDICTABLE
)
8913 return FLT_EVAL_METHOD_UNPREDICTABLE
;
8915 /* GCC only supports one interchange type right now, _Float16. If
8916 we're evaluating _Float16 in 16-bit precision, then flt_eval_method
8917 will be FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */
8918 if (x
== FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
)
8920 if (y
== FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
)
8923 /* Other values for flt_eval_method are directly comparable, and we want
8928 /* Return the value that should be set for FLT_EVAL_METHOD in the
8929 context of ISO/IEC TS 18861-3.
8931 This relates to the effective excess precision seen by the user,
8932 which is the join point of the precision the target requests for
8933 -fexcess-precision={standard,fast,16} and the implicit excess precision
8936 static enum flt_eval_method
8937 c_ts18661_flt_eval_method (void)
8939 enum flt_eval_method implicit
8940 = targetm
.c
.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT
);
8942 enum excess_precision_type flag_type
8943 = (flag_excess_precision
== EXCESS_PRECISION_STANDARD
8944 ? EXCESS_PRECISION_TYPE_STANDARD
8945 : (flag_excess_precision
== EXCESS_PRECISION_FLOAT16
8946 ? EXCESS_PRECISION_TYPE_FLOAT16
8947 : EXCESS_PRECISION_TYPE_FAST
));
8949 enum flt_eval_method requested
8950 = targetm
.c
.excess_precision (flag_type
);
8952 return excess_precision_mode_join (implicit
, requested
);
8955 /* As c_cpp_ts18661_flt_eval_method, but clamps the expected values to
8956 those that were permitted by C11. That is to say, eliminates
8957 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */
8959 static enum flt_eval_method
8960 c_c11_flt_eval_method (void)
8962 return excess_precision_mode_join (c_ts18661_flt_eval_method (),
8963 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
);
8966 /* Return the value that should be set for FLT_EVAL_METHOD.
8967 MAYBE_C11_ONLY_P is TRUE if we should check
8968 FLAG_PERMITTED_EVAL_METHODS as to whether we should limit the possible
8969 values we can return to those from C99/C11, and FALSE otherwise.
8970 See the comments on c_ts18661_flt_eval_method for what value we choose
8974 c_flt_eval_method (bool maybe_c11_only_p
)
8976 if (maybe_c11_only_p
8977 && flag_permitted_flt_eval_methods
8978 == PERMITTED_FLT_EVAL_METHODS_C11
)
8979 return c_c11_flt_eval_method ();
8981 return c_ts18661_flt_eval_method ();
8984 /* An enum for get_missing_token_insertion_kind for describing the best
8985 place to insert a missing token, if there is one. */
8987 enum missing_token_insertion_kind
8990 MTIK_INSERT_BEFORE_NEXT
,
8991 MTIK_INSERT_AFTER_PREV
8994 /* Given a missing token of TYPE, determine if it is reasonable to
8995 emit a fix-it hint suggesting the insertion of the token, and,
8996 if so, where the token should be inserted relative to other tokens.
8998 It only makes sense to do this for values of TYPE that are symbols.
9000 Some symbols should go before the next token, e.g. in:
9002 we want to insert the missing '(' immediately before "flag",
9007 These use MTIK_INSERT_BEFORE_NEXT.
9009 Other symbols should go after the previous token, e.g. in:
9012 we want to insert the missing ')' immediately after the "flag",
9019 These use MTIK_INSERT_AFTER_PREV. */
9021 static enum missing_token_insertion_kind
9022 get_missing_token_insertion_kind (enum cpp_ttype type
)
9026 /* Insert missing "opening" brackets immediately
9027 before the next token. */
9028 case CPP_OPEN_SQUARE
:
9029 case CPP_OPEN_PAREN
:
9030 return MTIK_INSERT_BEFORE_NEXT
;
9032 /* Insert other missing symbols immediately after
9033 the previous token. */
9034 case CPP_CLOSE_PAREN
:
9035 case CPP_CLOSE_SQUARE
:
9039 return MTIK_INSERT_AFTER_PREV
;
9041 /* Other kinds of token don't get fix-it hints. */
9043 return MTIK_IMPOSSIBLE
;
9047 /* Given RICHLOC, a location for a diagnostic describing a missing token
9048 of kind TOKEN_TYPE, potentially add a fix-it hint suggesting the
9049 insertion of the token.
9051 The location of the attempted fix-it hint depends on TOKEN_TYPE:
9053 (a) immediately after PREV_TOKEN_LOC, or
9055 (b) immediately before the primary location within RICHLOC (taken to
9056 be that of the token following where the token was expected).
9058 If we manage to add a fix-it hint, then the location of the
9059 fix-it hint is likely to be more useful as the primary location
9060 of the diagnostic than that of the following token, so we swap
9063 For example, given this bogus code:
9064 123456789012345678901234567890
9065 1 | int missing_semicolon (void)
9072 "expected ';' before '}'"
9074 RICHLOC's primary location is at the closing brace, so before "swapping"
9075 we would emit the error at line 4 column 1:
9077 123456789012345678901234567890
9078 3 | return 42 |< fix-it hint emitted for this line
9080 4 | } |< "expected ';' before '}'" emitted at this line
9083 It's more useful for the location of the diagnostic to be at the
9084 fix-it hint, so we swap the locations, so the primary location
9085 is at the fix-it hint, with the old primary location inserted
9086 as a secondary location, giving this, with the error at line 3
9089 123456789012345678901234567890
9090 3 | return 42 |< "expected ';' before '}'" emitted at this line,
9091 | ^ | with fix-it hint
9093 | } |< secondary range emitted here
9097 maybe_suggest_missing_token_insertion (rich_location
*richloc
,
9098 enum cpp_ttype token_type
,
9099 location_t prev_token_loc
)
9101 gcc_assert (richloc
);
9103 enum missing_token_insertion_kind mtik
9104 = get_missing_token_insertion_kind (token_type
);
9112 case MTIK_IMPOSSIBLE
:
9115 case MTIK_INSERT_BEFORE_NEXT
:
9116 /* Attempt to add the fix-it hint before the primary location
9118 richloc
->add_fixit_insert_before (cpp_type2name (token_type
, 0));
9121 case MTIK_INSERT_AFTER_PREV
:
9122 /* Attempt to add the fix-it hint after PREV_TOKEN_LOC. */
9123 richloc
->add_fixit_insert_after (prev_token_loc
,
9124 cpp_type2name (token_type
, 0));
9128 /* If we were successful, use the fix-it hint's location as the
9129 primary location within RICHLOC, adding the old primary location
9130 back as a secondary location. */
9131 if (!richloc
->seen_impossible_fixit_p ())
9133 fixit_hint
*hint
= richloc
->get_last_fixit_hint ();
9134 location_t hint_loc
= hint
->get_start_loc ();
9135 location_t old_loc
= richloc
->get_loc ();
9137 richloc
->set_range (0, hint_loc
, SHOW_RANGE_WITH_CARET
);
9138 richloc
->add_range (old_loc
);
9144 namespace selftest
{
9146 /* Verify that fold_for_warn on error_mark_node is safe. */
9149 test_fold_for_warn ()
9151 ASSERT_EQ (error_mark_node
, fold_for_warn (error_mark_node
));
9154 /* Run all of the selftests within this file. */
9157 c_common_cc_tests ()
9159 test_fold_for_warn ();
9162 /* Run all of the tests within c-family. */
9165 c_family_tests (void)
9167 c_common_cc_tests ();
9168 c_format_cc_tests ();
9169 c_indentation_cc_tests ();
9170 c_pretty_print_cc_tests ();
9171 c_spellcheck_cc_tests ();
9172 c_diagnostic_cc_tests ();
9173 c_opt_problem_cc_tests ();
9176 } // namespace selftest
9178 #endif /* #if CHECKING_P */
9180 /* Attempt to locate a suitable location within FILE for a
9181 #include directive to be inserted before.
9182 LOC is the location of the relevant diagnostic.
9184 Attempt to return the location within FILE immediately
9185 after the last #include within that file, or the start of
9186 that file if it has no #include directives.
9188 Return UNKNOWN_LOCATION if no suitable location is found,
9189 or if an error occurs. */
9192 try_to_locate_new_include_insertion_point (const char *file
, location_t loc
)
9194 /* Locate the last ordinary map within FILE that ended with a #include. */
9195 const line_map_ordinary
*last_include_ord_map
= NULL
;
9197 /* ...and the next ordinary map within FILE after that one. */
9198 const line_map_ordinary
*last_ord_map_after_include
= NULL
;
9200 /* ...and the first ordinary map within FILE. */
9201 const line_map_ordinary
*first_ord_map_in_file
= NULL
;
9203 /* Get ordinary map containing LOC (or its expansion). */
9204 const line_map_ordinary
*ord_map_for_loc
= NULL
;
9205 linemap_resolve_location (line_table
, loc
, LRK_MACRO_EXPANSION_POINT
,
9207 gcc_assert (ord_map_for_loc
);
9209 for (unsigned int i
= 0; i
< LINEMAPS_ORDINARY_USED (line_table
); i
++)
9211 const line_map_ordinary
*ord_map
9212 = LINEMAPS_ORDINARY_MAP_AT (line_table
, i
);
9214 if (const line_map_ordinary
*from
9215 = linemap_included_from_linemap (line_table
, ord_map
))
9216 /* We cannot use pointer equality, because with preprocessed
9217 input all filename strings are unique. */
9218 if (0 == strcmp (from
->to_file
, file
))
9220 last_include_ord_map
= from
;
9221 last_ord_map_after_include
= NULL
;
9224 /* Likewise, use strcmp, and reject any line-zero introductory
9226 if (ord_map
->to_line
&& 0 == strcmp (ord_map
->to_file
, file
))
9228 if (!first_ord_map_in_file
)
9229 first_ord_map_in_file
= ord_map
;
9230 if (last_include_ord_map
&& !last_ord_map_after_include
)
9231 last_ord_map_after_include
= ord_map
;
9234 /* Stop searching when reaching the ord_map containing LOC,
9235 as it makes no sense to provide fix-it hints that appear
9236 after the diagnostic in question. */
9237 if (ord_map
== ord_map_for_loc
)
9241 /* Determine where to insert the #include. */
9242 const line_map_ordinary
*ord_map_for_insertion
;
9244 /* We want the next ordmap in the file after the last one that's a
9245 #include, but failing that, the start of the file. */
9246 if (last_ord_map_after_include
)
9247 ord_map_for_insertion
= last_ord_map_after_include
;
9249 ord_map_for_insertion
= first_ord_map_in_file
;
9251 if (!ord_map_for_insertion
)
9252 return UNKNOWN_LOCATION
;
9254 /* The "start_location" is column 0, meaning "the whole line".
9255 rich_location and edit_context can't cope with this, so use
9256 column 1 instead. */
9257 location_t col_0
= ord_map_for_insertion
->start_location
;
9258 return linemap_position_for_loc_and_offset (line_table
, col_0
, 1);
9261 /* A map from filenames to sets of headers added to them, for
9262 ensuring idempotency within maybe_add_include_fixit. */
9264 /* The values within the map. We need string comparison as there's
9265 no guarantee that two different diagnostics that are recommending
9266 adding e.g. "<stdio.h>" are using the same buffer. */
9268 typedef hash_set
<const char *, false, nofree_string_hash
> per_file_includes_t
;
9270 /* The map itself. We don't need string comparison for the filename keys,
9271 as they come from libcpp. */
9273 typedef hash_map
<const char *, per_file_includes_t
*> added_includes_t
;
9274 static added_includes_t
*added_includes
;
9276 /* Attempt to add a fix-it hint to RICHLOC, adding "#include HEADER\n"
9277 in a suitable location within the file of RICHLOC's primary
9280 This function is idempotent: a header will be added at most once to
9283 If OVERRIDE_LOCATION is true, then if a fix-it is added and will be
9284 printed, then RICHLOC's primary location will be replaced by that of
9285 the fix-it hint (for use by "inform" notes where the location of the
9286 issue has already been reported). */
9289 maybe_add_include_fixit (rich_location
*richloc
, const char *header
,
9290 bool override_location
)
9292 location_t loc
= richloc
->get_loc ();
9293 const char *file
= LOCATION_FILE (loc
);
9297 /* Idempotency: don't add the same header more than once to a given file. */
9298 if (!added_includes
)
9299 added_includes
= new added_includes_t ();
9300 per_file_includes_t
*&set
= added_includes
->get_or_insert (file
);
9302 if (set
->contains (header
))
9303 /* ...then we've already added HEADER to that file. */
9306 set
= new per_file_includes_t ();
9309 /* Attempt to locate a suitable place for the new directive. */
9310 location_t include_insert_loc
9311 = try_to_locate_new_include_insertion_point (file
, loc
);
9312 if (include_insert_loc
== UNKNOWN_LOCATION
)
9315 char *text
= xasprintf ("#include %s\n", header
);
9316 richloc
->add_fixit_insert_before (include_insert_loc
, text
);
9319 if (override_location
&& global_dc
->show_caret
)
9321 /* Replace the primary location with that of the insertion point for the
9324 We use SHOW_LINES_WITHOUT_RANGE so that we don't meaningless print a
9325 caret for the insertion point (or colorize it).
9327 Hence we print e.g.:
9329 ../x86_64-pc-linux-gnu/libstdc++-v3/include/vector:74:1: note: msg 2
9330 73 | # include <debug/vector>
9331 +++ |+#include <vector>
9336 ../x86_64-pc-linux-gnu/libstdc++-v3/include/vector:74:1: note: msg 2
9337 73 | # include <debug/vector>
9338 +++ |+#include <vector>
9342 avoiding the caret on the first column of line 74. */
9343 richloc
->set_range (0, include_insert_loc
, SHOW_LINES_WITHOUT_RANGE
);
9347 /* Attempt to convert a braced array initializer list CTOR for array
9348 TYPE into a STRING_CST for convenience and efficiency. Return
9349 the converted string on success or the original ctor on failure. */
9352 braced_list_to_string (tree type
, tree ctor
, bool member
)
9354 /* Ignore non-members with unknown size like arrays with unspecified
9356 tree typesize
= TYPE_SIZE_UNIT (type
);
9357 if (!member
&& !tree_fits_uhwi_p (typesize
))
9360 /* If the target char size differs from the host char size, we'd risk
9361 loosing data and getting object sizes wrong by converting to
9363 if (TYPE_PRECISION (char_type_node
) != CHAR_BIT
)
9366 /* STRING_CST doesn't support wide characters. */
9367 gcc_checking_assert (TYPE_PRECISION (TREE_TYPE (type
)) == CHAR_BIT
);
9369 /* If the array has an explicit bound, use it to constrain the size
9370 of the string. If it doesn't, be sure to create a string that's
9371 as long as implied by the index of the last zero specified via
9372 a designator, as in:
9373 const char a[] = { [7] = 0 }; */
9374 unsigned HOST_WIDE_INT maxelts
;
9377 maxelts
= tree_to_uhwi (typesize
);
9378 maxelts
/= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (type
)));
9381 maxelts
= HOST_WIDE_INT_M1U
;
9383 /* Avoid converting initializers for zero-length arrays (but do
9384 create them for flexible array members). */
9388 unsigned HOST_WIDE_INT nelts
= CONSTRUCTOR_NELTS (ctor
);
9391 str
.reserve (nelts
+ 1);
9393 unsigned HOST_WIDE_INT i
;
9396 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), i
, index
, value
)
9398 unsigned HOST_WIDE_INT idx
= i
;
9401 if (!tree_fits_uhwi_p (index
))
9403 idx
= tree_to_uhwi (index
);
9406 /* auto_vec is limited to UINT_MAX elements. */
9410 /* Avoid non-constant initializers. */
9411 if (!tree_fits_shwi_p (value
))
9414 /* Skip over embedded nuls except the last one (initializer
9415 elements are in ascending order of indices). */
9416 HOST_WIDE_INT val
= tree_to_shwi (value
);
9417 if (!val
&& i
+ 1 < nelts
)
9420 if (idx
< str
.length())
9423 /* Bail if the CTOR has a block of more than 256 embedded nuls
9424 due to implicitly initialized elements. */
9425 unsigned nchars
= (idx
- str
.length ()) + 1;
9432 str
.quick_grow_cleared (idx
);
9438 str
.safe_insert (idx
, val
);
9441 /* Append a nul string termination. */
9442 if (maxelts
!= HOST_WIDE_INT_M1U
&& str
.length () < maxelts
)
9445 /* Build a STRING_CST with the same type as the array. */
9446 tree res
= build_string (str
.length (), str
.begin ());
9447 TREE_TYPE (res
) = type
;
9451 /* Implementation of the two-argument braced_lists_to_string withe
9452 the same arguments plus MEMBER which is set for struct members
9453 to allow initializers for flexible member arrays. */
9456 braced_lists_to_strings (tree type
, tree ctor
, bool member
)
9458 if (TREE_CODE (ctor
) != CONSTRUCTOR
)
9461 tree_code code
= TREE_CODE (type
);
9464 if (code
== ARRAY_TYPE
)
9465 ttp
= TREE_TYPE (type
);
9466 else if (code
== RECORD_TYPE
)
9468 ttp
= TREE_TYPE (ctor
);
9469 if (TREE_CODE (ttp
) == ARRAY_TYPE
)
9472 ttp
= TREE_TYPE (ttp
);
9478 if ((TREE_CODE (ttp
) == ARRAY_TYPE
|| TREE_CODE (ttp
) == INTEGER_TYPE
)
9479 && TYPE_STRING_FLAG (ttp
))
9480 return braced_list_to_string (type
, ctor
, member
);
9482 code
= TREE_CODE (ttp
);
9483 if (code
== ARRAY_TYPE
|| RECORD_OR_UNION_TYPE_P (ttp
))
9485 bool rec
= RECORD_OR_UNION_TYPE_P (ttp
);
9487 /* Handle array of arrays or struct member initializers. */
9489 unsigned HOST_WIDE_INT idx
;
9490 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor
), idx
, val
)
9492 val
= braced_lists_to_strings (ttp
, val
, rec
);
9493 CONSTRUCTOR_ELT (ctor
, idx
)->value
= val
;
9500 /* Attempt to convert a CTOR containing braced array initializer lists
9501 for array TYPE into one containing STRING_CSTs, for convenience and
9502 efficiency. Recurse for arrays of arrays and member initializers.
9503 Return the converted CTOR or STRING_CST on success or the original
9507 braced_lists_to_strings (tree type
, tree ctor
)
9509 return braced_lists_to_strings (type
, ctor
, false);
9513 /* Emit debug for functions before finalizing early debug. */
9516 c_common_finalize_early_debug (void)
9518 /* Emit early debug for reachable functions, and by consequence,
9519 locally scoped symbols. Also emit debug for extern declared
9520 functions that are still reachable at this point. */
9521 struct cgraph_node
*cnode
;
9522 FOR_EACH_FUNCTION (cnode
)
9523 if (!cnode
->alias
&& !cnode
->thunk
9524 && (cnode
->has_gimple_body_p ()
9525 || !DECL_IS_UNDECLARED_BUILTIN (cnode
->decl
)))
9526 (*debug_hooks
->early_global_decl
) (cnode
->decl
);
9529 #include "gt-c-family-c-common.h"