1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 #define GCC_C_COMMON_C
24 #include "coretypes.h"
30 #include "gimple-expr.h"
32 #include "stringpool.h"
34 #include "diagnostic.h"
36 #include "stor-layout.h"
40 #include "trans-mem.h"
42 #include "common/common-target.h"
43 #include "langhooks.h"
44 #include "tree-inline.h"
46 #include "tree-iterator.h"
49 #include "substring-locations.h"
50 #include "spellcheck.h"
53 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
55 /* Mode used to build pointers (VOIDmode means ptr_mode). */
57 machine_mode c_default_pointer_mode
= VOIDmode
;
59 /* The following symbols are subsumed in the c_global_trees array, and
60 listed here individually for documentation purposes.
62 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
64 tree short_integer_type_node;
65 tree long_integer_type_node;
66 tree long_long_integer_type_node;
68 tree short_unsigned_type_node;
69 tree long_unsigned_type_node;
70 tree long_long_unsigned_type_node;
72 tree truthvalue_type_node;
73 tree truthvalue_false_node;
74 tree truthvalue_true_node;
76 tree ptrdiff_type_node;
78 tree unsigned_char_type_node;
79 tree signed_char_type_node;
82 tree char16_type_node;
83 tree char32_type_node;
86 tree double_type_node;
87 tree long_double_type_node;
89 tree complex_integer_type_node;
90 tree complex_float_type_node;
91 tree complex_double_type_node;
92 tree complex_long_double_type_node;
94 tree dfloat32_type_node;
95 tree dfloat64_type_node;
96 tree_dfloat128_type_node;
100 tree intSI_type_node;
101 tree intDI_type_node;
102 tree intTI_type_node;
104 tree unsigned_intQI_type_node;
105 tree unsigned_intHI_type_node;
106 tree unsigned_intSI_type_node;
107 tree unsigned_intDI_type_node;
108 tree unsigned_intTI_type_node;
110 tree widest_integer_literal_type_node;
111 tree widest_unsigned_literal_type_node;
113 Nodes for types `void *' and `const void *'.
115 tree ptr_type_node, const_ptr_type_node;
117 Nodes for types `char *' and `const char *'.
119 tree string_type_node, const_string_type_node;
121 Type `char[SOMENUMBER]'.
122 Used when an array of char is needed and the size is irrelevant.
124 tree char_array_type_node;
126 Type `wchar_t[SOMENUMBER]' or something like it.
127 Used when a wide string literal is created.
129 tree wchar_array_type_node;
131 Type `char16_t[SOMENUMBER]' or something like it.
132 Used when a UTF-16 string literal is created.
134 tree char16_array_type_node;
136 Type `char32_t[SOMENUMBER]' or something like it.
137 Used when a UTF-32 string literal is created.
139 tree char32_array_type_node;
141 Type `int ()' -- used for implicit declaration of functions.
143 tree default_function_type;
145 A VOID_TYPE node, packaged in a TREE_LIST.
149 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
150 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
151 VAR_DECLS, but C++ does.)
153 tree function_name_decl_node;
154 tree pretty_function_name_decl_node;
155 tree c99_function_name_decl_node;
157 Stack of nested function name VAR_DECLs.
159 tree saved_function_name_decls;
163 tree c_global_trees
[CTI_MAX
];
165 /* Switches common to the C front ends. */
167 /* Nonzero means don't output line number information. */
169 char flag_no_line_commands
;
171 /* Nonzero causes -E output not to be done, but directives such as
172 #define that have side effects are still obeyed. */
176 /* Nonzero means dump macros in some fashion. */
178 char flag_dump_macros
;
180 /* Nonzero means pass #include lines through to the output. */
182 char flag_dump_includes
;
184 /* Nonzero means process PCH files while preprocessing. */
186 bool flag_pch_preprocess
;
188 /* The file name to which we should write a precompiled header, or
189 NULL if no header will be written in this compile. */
191 const char *pch_file
;
193 /* Nonzero if an ISO standard was selected. It rejects macros in the
197 /* C/ObjC language option variables. */
200 /* Nonzero means allow type mismatches in conditional expressions;
201 just make their values `void'. */
203 int flag_cond_mismatch
;
205 /* Nonzero means enable C89 Amendment 1 features. */
209 /* Nonzero means use the ISO C99 (or C11) dialect of C. */
213 /* Nonzero means use the ISO C11 dialect of C. */
217 /* Nonzero means that we have builtin functions, and main is an int. */
222 /* ObjC language option variables. */
225 /* Tells the compiler that this is a special run. Do not perform any
226 compiling, instead we are to test some platform dependent features
227 and output a C header file with appropriate definitions. */
229 int print_struct_values
;
231 /* Tells the compiler what is the constant string class for ObjC. */
233 const char *constant_string_class_name
;
236 /* C++ language option variables. */
238 /* The reference version of the ABI for -Wabi. */
240 int warn_abi_version
= -1;
242 /* Nonzero means generate separate instantiation control files and
243 juggle them at link time. */
245 int flag_use_repository
;
247 /* The C++ dialect being used. Default set in c_common_post_options. */
249 enum cxx_dialect cxx_dialect
= cxx_unset
;
251 /* Maximum template instantiation depth. This limit exists to limit the
252 time it takes to notice excessively recursive template instantiations.
254 The default is lower than the 1024 recommended by the C++0x standard
255 because G++ runs out of stack before 1024 with highly recursive template
256 argument deduction substitution (g++.dg/cpp0x/enum11.C). */
258 int max_tinst_depth
= 900;
260 /* The elements of `ridpointers' are identifier nodes for the reserved
261 type names and storage classes. It is indexed by a RID_... value. */
264 tree (*make_fname_decl
) (location_t
, tree
, int);
266 /* Nonzero means don't warn about problems that occur when the code is
268 int c_inhibit_evaluation_warnings
;
270 /* Whether we are building a boolean conversion inside
271 convert_for_assignment, or some other late binary operation. If
272 build_binary_op is called for C (from code shared by C and C++) in
273 this case, then the operands have already been folded and the
274 result will not be folded again, so C_MAYBE_CONST_EXPR should not
276 bool in_late_binary_op
;
278 /* Whether lexing has been completed, so subsequent preprocessor
279 errors should use the compiler's input_location. */
280 bool done_lexing
= false;
282 /* Information about how a function name is generated. */
285 tree
*const decl
; /* pointer to the VAR_DECL. */
286 const unsigned rid
; /* RID number for the identifier. */
287 const int pretty
; /* How pretty is it? */
290 /* The three ways of getting then name of the current function. */
292 const struct fname_var_t fname_vars
[] =
294 /* C99 compliant __func__, must be first. */
295 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
296 /* GCC __FUNCTION__ compliant. */
297 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
298 /* GCC __PRETTY_FUNCTION__ compliant. */
299 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
303 /* Global visibility options. */
304 struct visibility_flags visibility_options
;
306 static tree
check_case_value (location_t
, tree
);
307 static bool check_case_bounds (location_t
, tree
, tree
, tree
*, tree
*,
311 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
312 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
314 /* Reserved words. The third field is a mask: keywords are disabled
315 if they match the mask.
318 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
319 C --std=c99: D_CXXONLY | D_OBJC
320 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
321 C++ --std=c++98: D_CONLY | D_CXX11 | D_OBJC
322 C++ --std=c++11: D_CONLY | D_OBJC
323 ObjC++ is like C++ except that D_OBJC is not set
325 If -fno-asm is used, D_ASM is added to the mask. If
326 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
327 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
328 In C with -Wc++-compat, we warn if D_CXXWARN is set.
330 Note the complication of the D_CXX_OBJC keywords. These are
331 reserved words such as 'class'. In C++, 'class' is a reserved
332 word. In Objective-C++ it is too. In Objective-C, it is a
333 reserved word too, but only if it follows an '@' sign.
335 const struct c_common_resword c_common_reswords
[] =
337 { "_Alignas", RID_ALIGNAS
, D_CONLY
},
338 { "_Alignof", RID_ALIGNOF
, D_CONLY
},
339 { "_Atomic", RID_ATOMIC
, D_CONLY
},
340 { "_Bool", RID_BOOL
, D_CONLY
},
341 { "_Complex", RID_COMPLEX
, 0 },
342 { "_Imaginary", RID_IMAGINARY
, D_CONLY
},
343 { "_Float16", RID_FLOAT16
, D_CONLY
},
344 { "_Float32", RID_FLOAT32
, D_CONLY
},
345 { "_Float64", RID_FLOAT64
, D_CONLY
},
346 { "_Float128", RID_FLOAT128
, D_CONLY
},
347 { "_Float32x", RID_FLOAT32X
, D_CONLY
},
348 { "_Float64x", RID_FLOAT64X
, D_CONLY
},
349 { "_Float128x", RID_FLOAT128X
, D_CONLY
},
350 { "_Decimal32", RID_DFLOAT32
, D_CONLY
| D_EXT
},
351 { "_Decimal64", RID_DFLOAT64
, D_CONLY
| D_EXT
},
352 { "_Decimal128", RID_DFLOAT128
, D_CONLY
| D_EXT
},
353 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
354 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
355 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
356 { "_Static_assert", RID_STATIC_ASSERT
, D_CONLY
},
357 { "_Noreturn", RID_NORETURN
, D_CONLY
},
358 { "_Generic", RID_GENERIC
, D_CONLY
},
359 { "_Thread_local", RID_THREAD
, D_CONLY
},
360 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
361 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
362 { "__alignof", RID_ALIGNOF
, 0 },
363 { "__alignof__", RID_ALIGNOF
, 0 },
364 { "__asm", RID_ASM
, 0 },
365 { "__asm__", RID_ASM
, 0 },
366 { "__attribute", RID_ATTRIBUTE
, 0 },
367 { "__attribute__", RID_ATTRIBUTE
, 0 },
368 { "__auto_type", RID_AUTO_TYPE
, D_CONLY
},
369 { "__bases", RID_BASES
, D_CXXONLY
},
370 { "__builtin_addressof", RID_ADDRESSOF
, D_CXXONLY
},
371 { "__builtin_call_with_static_chain",
372 RID_BUILTIN_CALL_WITH_STATIC_CHAIN
, D_CONLY
},
373 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
374 { "__builtin_complex", RID_BUILTIN_COMPLEX
, D_CONLY
},
375 { "__builtin_launder", RID_BUILTIN_LAUNDER
, D_CXXONLY
},
376 { "__builtin_shuffle", RID_BUILTIN_SHUFFLE
, 0 },
377 { "__builtin_tgmath", RID_BUILTIN_TGMATH
, D_CONLY
},
378 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
379 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
380 { "__builtin_va_arg", RID_VA_ARG
, 0 },
381 { "__complex", RID_COMPLEX
, 0 },
382 { "__complex__", RID_COMPLEX
, 0 },
383 { "__const", RID_CONST
, 0 },
384 { "__const__", RID_CONST
, 0 },
385 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
386 { "__direct_bases", RID_DIRECT_BASES
, D_CXXONLY
},
387 { "__extension__", RID_EXTENSION
, 0 },
388 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
389 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
390 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
391 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
392 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
393 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
394 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
395 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
396 { "__has_unique_object_representations", RID_HAS_UNIQUE_OBJ_REPRESENTATIONS
,
398 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
399 { "__imag", RID_IMAGPART
, 0 },
400 { "__imag__", RID_IMAGPART
, 0 },
401 { "__inline", RID_INLINE
, 0 },
402 { "__inline__", RID_INLINE
, 0 },
403 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
404 { "__is_aggregate", RID_IS_AGGREGATE
, D_CXXONLY
},
405 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
406 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
407 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
408 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
409 { "__is_final", RID_IS_FINAL
, D_CXXONLY
},
410 { "__is_literal_type", RID_IS_LITERAL_TYPE
, D_CXXONLY
},
411 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
412 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
413 { "__is_same_as", RID_IS_SAME_AS
, D_CXXONLY
},
414 { "__is_standard_layout", RID_IS_STD_LAYOUT
, D_CXXONLY
},
415 { "__is_trivial", RID_IS_TRIVIAL
, D_CXXONLY
},
416 { "__is_trivially_assignable", RID_IS_TRIVIALLY_ASSIGNABLE
, D_CXXONLY
},
417 { "__is_trivially_constructible", RID_IS_TRIVIALLY_CONSTRUCTIBLE
, D_CXXONLY
},
418 { "__is_trivially_copyable", RID_IS_TRIVIALLY_COPYABLE
, D_CXXONLY
},
419 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
420 { "__label__", RID_LABEL
, 0 },
421 { "__null", RID_NULL
, 0 },
422 { "__real", RID_REALPART
, 0 },
423 { "__real__", RID_REALPART
, 0 },
424 { "__restrict", RID_RESTRICT
, 0 },
425 { "__restrict__", RID_RESTRICT
, 0 },
426 { "__signed", RID_SIGNED
, 0 },
427 { "__signed__", RID_SIGNED
, 0 },
428 { "__thread", RID_THREAD
, 0 },
429 { "__transaction_atomic", RID_TRANSACTION_ATOMIC
, 0 },
430 { "__transaction_relaxed", RID_TRANSACTION_RELAXED
, 0 },
431 { "__transaction_cancel", RID_TRANSACTION_CANCEL
, 0 },
432 { "__typeof", RID_TYPEOF
, 0 },
433 { "__typeof__", RID_TYPEOF
, 0 },
434 { "__underlying_type", RID_UNDERLYING_TYPE
, D_CXXONLY
},
435 { "__volatile", RID_VOLATILE
, 0 },
436 { "__volatile__", RID_VOLATILE
, 0 },
437 { "__GIMPLE", RID_GIMPLE
, D_CONLY
},
438 { "__PHI", RID_PHI
, D_CONLY
},
439 { "__RTL", RID_RTL
, D_CONLY
},
440 { "alignas", RID_ALIGNAS
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
441 { "alignof", RID_ALIGNOF
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
442 { "asm", RID_ASM
, D_ASM
},
443 { "auto", RID_AUTO
, 0 },
444 { "bool", RID_BOOL
, D_CXXONLY
| D_CXXWARN
},
445 { "break", RID_BREAK
, 0 },
446 { "case", RID_CASE
, 0 },
447 { "catch", RID_CATCH
, D_CXX_OBJC
| D_CXXWARN
},
448 { "char", RID_CHAR
, 0 },
449 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
450 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
451 { "class", RID_CLASS
, D_CXX_OBJC
| D_CXXWARN
},
452 { "const", RID_CONST
, 0 },
453 { "constexpr", RID_CONSTEXPR
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
454 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
455 { "continue", RID_CONTINUE
, 0 },
456 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
457 { "default", RID_DEFAULT
, 0 },
458 { "delete", RID_DELETE
, D_CXXONLY
| D_CXXWARN
},
460 { "double", RID_DOUBLE
, 0 },
461 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
462 { "else", RID_ELSE
, 0 },
463 { "enum", RID_ENUM
, 0 },
464 { "explicit", RID_EXPLICIT
, D_CXXONLY
| D_CXXWARN
},
465 { "export", RID_EXPORT
, D_CXXONLY
| D_CXXWARN
},
466 { "extern", RID_EXTERN
, 0 },
467 { "false", RID_FALSE
, D_CXXONLY
| D_CXXWARN
},
468 { "float", RID_FLOAT
, 0 },
469 { "for", RID_FOR
, 0 },
470 { "friend", RID_FRIEND
, D_CXXONLY
| D_CXXWARN
},
471 { "goto", RID_GOTO
, 0 },
473 { "inline", RID_INLINE
, D_EXT89
},
474 { "int", RID_INT
, 0 },
475 { "long", RID_LONG
, 0 },
476 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
477 { "namespace", RID_NAMESPACE
, D_CXXONLY
| D_CXXWARN
},
478 { "new", RID_NEW
, D_CXXONLY
| D_CXXWARN
},
479 { "noexcept", RID_NOEXCEPT
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
480 { "nullptr", RID_NULLPTR
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
481 { "operator", RID_OPERATOR
, D_CXXONLY
| D_CXXWARN
},
482 { "private", RID_PRIVATE
, D_CXX_OBJC
| D_CXXWARN
},
483 { "protected", RID_PROTECTED
, D_CXX_OBJC
| D_CXXWARN
},
484 { "public", RID_PUBLIC
, D_CXX_OBJC
| D_CXXWARN
},
485 { "register", RID_REGISTER
, 0 },
486 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
487 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
488 { "return", RID_RETURN
, 0 },
489 { "short", RID_SHORT
, 0 },
490 { "signed", RID_SIGNED
, 0 },
491 { "sizeof", RID_SIZEOF
, 0 },
492 { "static", RID_STATIC
, 0 },
493 { "static_assert", RID_STATIC_ASSERT
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
494 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
495 { "struct", RID_STRUCT
, 0 },
496 { "switch", RID_SWITCH
, 0 },
497 { "template", RID_TEMPLATE
, D_CXXONLY
| D_CXXWARN
},
498 { "this", RID_THIS
, D_CXXONLY
| D_CXXWARN
},
499 { "thread_local", RID_THREAD
, D_CXXONLY
| D_CXX11
| D_CXXWARN
},
500 { "throw", RID_THROW
, D_CXX_OBJC
| D_CXXWARN
},
501 { "true", RID_TRUE
, D_CXXONLY
| D_CXXWARN
},
502 { "try", RID_TRY
, D_CXX_OBJC
| D_CXXWARN
},
503 { "typedef", RID_TYPEDEF
, 0 },
504 { "typename", RID_TYPENAME
, D_CXXONLY
| D_CXXWARN
},
505 { "typeid", RID_TYPEID
, D_CXXONLY
| D_CXXWARN
},
506 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
507 { "union", RID_UNION
, 0 },
508 { "unsigned", RID_UNSIGNED
, 0 },
509 { "using", RID_USING
, D_CXXONLY
| D_CXXWARN
},
510 { "virtual", RID_VIRTUAL
, D_CXXONLY
| D_CXXWARN
},
511 { "void", RID_VOID
, 0 },
512 { "volatile", RID_VOLATILE
, 0 },
513 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
514 { "while", RID_WHILE
, 0 },
515 { "__is_assignable", RID_IS_ASSIGNABLE
, D_CXXONLY
},
516 { "__is_constructible", RID_IS_CONSTRUCTIBLE
, D_CXXONLY
},
518 /* C++ transactional memory. */
519 { "synchronized", RID_SYNCHRONIZED
, D_CXX_OBJC
| D_TRANSMEM
},
520 { "atomic_noexcept", RID_ATOMIC_NOEXCEPT
, D_CXXONLY
| D_TRANSMEM
},
521 { "atomic_cancel", RID_ATOMIC_CANCEL
, D_CXXONLY
| D_TRANSMEM
},
522 { "atomic_commit", RID_TRANSACTION_ATOMIC
, D_CXXONLY
| D_TRANSMEM
},
524 /* Concepts-related keywords */
525 { "concept", RID_CONCEPT
, D_CXX_CONCEPTS_FLAGS
| D_CXXWARN
},
526 { "requires", RID_REQUIRES
, D_CXX_CONCEPTS_FLAGS
| D_CXXWARN
},
528 /* These Objective-C keywords are recognized only immediately after
530 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
531 { "defs", RID_AT_DEFS
, D_OBJC
},
532 { "encode", RID_AT_ENCODE
, D_OBJC
},
533 { "end", RID_AT_END
, D_OBJC
},
534 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
535 { "interface", RID_AT_INTERFACE
, D_OBJC
},
536 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
537 { "selector", RID_AT_SELECTOR
, D_OBJC
},
538 { "finally", RID_AT_FINALLY
, D_OBJC
},
539 { "optional", RID_AT_OPTIONAL
, D_OBJC
},
540 { "required", RID_AT_REQUIRED
, D_OBJC
},
541 { "property", RID_AT_PROPERTY
, D_OBJC
},
542 { "package", RID_AT_PACKAGE
, D_OBJC
},
543 { "synthesize", RID_AT_SYNTHESIZE
, D_OBJC
},
544 { "dynamic", RID_AT_DYNAMIC
, D_OBJC
},
545 /* These are recognized only in protocol-qualifier context
547 { "bycopy", RID_BYCOPY
, D_OBJC
},
548 { "byref", RID_BYREF
, D_OBJC
},
549 { "in", RID_IN
, D_OBJC
},
550 { "inout", RID_INOUT
, D_OBJC
},
551 { "oneway", RID_ONEWAY
, D_OBJC
},
552 { "out", RID_OUT
, D_OBJC
},
553 /* These are recognized inside a property attribute list */
554 { "assign", RID_ASSIGN
, D_OBJC
},
555 { "copy", RID_COPY
, D_OBJC
},
556 { "getter", RID_GETTER
, D_OBJC
},
557 { "nonatomic", RID_NONATOMIC
, D_OBJC
},
558 { "readonly", RID_READONLY
, D_OBJC
},
559 { "readwrite", RID_READWRITE
, D_OBJC
},
560 { "retain", RID_RETAIN
, D_OBJC
},
561 { "setter", RID_SETTER
, D_OBJC
},
564 const unsigned int num_c_common_reswords
=
565 sizeof c_common_reswords
/ sizeof (struct c_common_resword
);
567 /* Return identifier for address space AS. */
570 c_addr_space_name (addr_space_t as
)
572 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
573 gcc_assert (ridpointers
[rid
]);
574 return IDENTIFIER_POINTER (ridpointers
[rid
]);
577 /* Push current bindings for the function name VAR_DECLS. */
580 start_fname_decls (void)
583 tree saved
= NULL_TREE
;
585 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
587 tree decl
= *fname_vars
[ix
].decl
;
591 saved
= tree_cons (decl
, build_int_cst (integer_type_node
, ix
),
593 *fname_vars
[ix
].decl
= NULL_TREE
;
596 if (saved
|| saved_function_name_decls
)
597 /* Normally they'll have been NULL, so only push if we've got a
598 stack, or they are non-NULL. */
599 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
600 saved_function_name_decls
);
603 /* Finish up the current bindings, adding them into the current function's
604 statement tree. This must be done _before_ finish_stmt_tree is called.
605 If there is no current function, we must be at file scope and no statements
606 are involved. Pop the previous bindings. */
609 finish_fname_decls (void)
612 tree stmts
= NULL_TREE
;
613 tree stack
= saved_function_name_decls
;
615 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
616 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
620 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
622 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
623 bodyp
= &BIND_EXPR_BODY (*bodyp
);
625 append_to_statement_list_force (*bodyp
, &stmts
);
629 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
630 *fname_vars
[ix
].decl
= NULL_TREE
;
634 /* We had saved values, restore them. */
637 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
639 tree decl
= TREE_PURPOSE (saved
);
640 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
642 *fname_vars
[ix
].decl
= decl
;
644 stack
= TREE_CHAIN (stack
);
646 saved_function_name_decls
= stack
;
649 /* Return the text name of the current function, suitably prettified
650 by PRETTY_P. Return string must be freed by caller. */
653 fname_as_string (int pretty_p
)
655 const char *name
= "top level";
658 cpp_string cstr
= { 0, 0 }, strname
;
666 if (current_function_decl
)
667 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
669 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
671 namep
= XNEWVEC (char, len
);
672 snprintf (namep
, len
, "\"%s\"", name
);
673 strname
.text
= (unsigned char *) namep
;
674 strname
.len
= len
- 1;
676 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
679 return (const char *) cstr
.text
;
685 /* Return the VAR_DECL for a const char array naming the current
686 function. If the VAR_DECL has not yet been created, create it
687 now. RID indicates how it should be formatted and IDENTIFIER_NODE
688 ID is its name (unfortunately C and C++ hold the RID values of
689 keywords in different places, so we can't derive RID from ID in
690 this language independent code. LOC is the location of the
694 fname_decl (location_t loc
, unsigned int rid
, tree id
)
697 tree decl
= NULL_TREE
;
699 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
700 if (fname_vars
[ix
].rid
== rid
)
703 decl
= *fname_vars
[ix
].decl
;
706 /* If a tree is built here, it would normally have the lineno of
707 the current statement. Later this tree will be moved to the
708 beginning of the function and this line number will be wrong.
709 To avoid this problem set the lineno to 0 here; that prevents
710 it from appearing in the RTL. */
712 location_t saved_location
= input_location
;
713 input_location
= UNKNOWN_LOCATION
;
715 stmts
= push_stmt_list ();
716 decl
= (*make_fname_decl
) (loc
, id
, fname_vars
[ix
].pretty
);
717 stmts
= pop_stmt_list (stmts
);
718 if (!IS_EMPTY_STMT (stmts
))
719 saved_function_name_decls
720 = tree_cons (decl
, stmts
, saved_function_name_decls
);
721 *fname_vars
[ix
].decl
= decl
;
722 input_location
= saved_location
;
724 if (!ix
&& !current_function_decl
)
725 pedwarn (loc
, 0, "%qD is not defined outside of function scope", decl
);
730 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
733 fix_string_type (tree value
)
735 int length
= TREE_STRING_LENGTH (value
);
737 tree e_type
, i_type
, a_type
;
739 /* Compute the number of elements, for the array type. */
740 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
743 e_type
= char_type_node
;
745 else if (TREE_TYPE (value
) == char16_array_type_node
)
747 nchars
= length
/ (TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
);
748 e_type
= char16_type_node
;
750 else if (TREE_TYPE (value
) == char32_array_type_node
)
752 nchars
= length
/ (TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
);
753 e_type
= char32_type_node
;
757 nchars
= length
/ (TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
);
758 e_type
= wchar_type_node
;
761 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
762 limit in C++98 Annex B is very large (65536) and is not normative,
763 so we do not diagnose it (warn_overlength_strings is forced off
764 in c_common_post_options). */
765 if (warn_overlength_strings
)
767 const int nchars_max
= flag_isoc99
? 4095 : 509;
768 const int relevant_std
= flag_isoc99
? 99 : 90;
769 if (nchars
- 1 > nchars_max
)
770 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
771 separate the %d from the 'C'. 'ISO' should not be
772 translated, but it may be moved after 'C%d' in languages
773 where modifiers follow nouns. */
774 pedwarn (input_location
, OPT_Woverlength_strings
,
775 "string length %qd is greater than the length %qd "
776 "ISO C%d compilers are required to support",
777 nchars
- 1, nchars_max
, relevant_std
);
780 /* Create the array type for the string constant. The ISO C++
781 standard says that a string literal has type `const char[N]' or
782 `const wchar_t[N]'. We use the same logic when invoked as a C
783 front-end with -Wwrite-strings.
784 ??? We should change the type of an expression depending on the
785 state of a warning flag. We should just be warning -- see how
786 this is handled in the C++ front-end for the deprecated implicit
787 conversion from string literals to `char*' or `wchar_t*'.
789 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
790 array type being the unqualified version of that type.
791 Therefore, if we are constructing an array of const char, we must
792 construct the matching unqualified array type first. The C front
793 end does not require this, but it does no harm, so we do it
795 i_type
= build_index_type (size_int (nchars
- 1));
796 a_type
= build_array_type (e_type
, i_type
);
797 if (c_dialect_cxx() || warn_write_strings
)
798 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
800 TREE_TYPE (value
) = a_type
;
801 TREE_CONSTANT (value
) = 1;
802 TREE_READONLY (value
) = 1;
803 TREE_STATIC (value
) = 1;
807 /* Given a string of type STRING_TYPE, determine what kind of string
808 token would give an equivalent execution encoding: CPP_STRING,
809 CPP_STRING16, or CPP_STRING32. Return CPP_OTHER in case of error.
810 This may not be exactly the string token type that initially created
811 the string, since CPP_WSTRING is indistinguishable from the 16/32 bit
812 string type at this point.
814 This effectively reverses part of the logic in lex_string and
817 static enum cpp_ttype
818 get_cpp_ttype_from_string_type (tree string_type
)
820 gcc_assert (string_type
);
821 if (TREE_CODE (string_type
) == POINTER_TYPE
)
822 string_type
= TREE_TYPE (string_type
);
824 if (TREE_CODE (string_type
) != ARRAY_TYPE
)
827 tree element_type
= TREE_TYPE (string_type
);
828 if (TREE_CODE (element_type
) != INTEGER_TYPE
)
831 int bits_per_character
= TYPE_PRECISION (element_type
);
832 switch (bits_per_character
)
835 return CPP_STRING
; /* It could have also been CPP_UTF8STRING. */
845 /* The global record of string concatentations, for use in
846 extracting locations within string literals. */
848 GTY(()) string_concat_db
*g_string_concat_db
;
850 /* Implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */
853 c_get_substring_location (const substring_loc
&substr_loc
,
856 enum cpp_ttype tok_type
857 = get_cpp_ttype_from_string_type (substr_loc
.get_string_type ());
858 if (tok_type
== CPP_OTHER
)
859 return "unrecognized string type";
861 return get_source_location_for_substring (parse_in
, g_string_concat_db
,
862 substr_loc
.get_fmt_string_loc (),
864 substr_loc
.get_caret_idx (),
865 substr_loc
.get_start_idx (),
866 substr_loc
.get_end_idx (),
871 /* Return true iff T is a boolean promoted to int. */
874 bool_promoted_to_int_p (tree t
)
876 return (CONVERT_EXPR_P (t
)
877 && TREE_TYPE (t
) == integer_type_node
878 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == BOOLEAN_TYPE
);
881 /* vector_targets_convertible_p is used for vector pointer types. The
882 callers perform various checks that the qualifiers are satisfactory,
883 while OTOH vector_targets_convertible_p ignores the number of elements
884 in the vectors. That's fine with vector pointers as we can consider,
885 say, a vector of 8 elements as two consecutive vectors of 4 elements,
886 and that does not require and conversion of the pointer values.
887 In contrast, vector_types_convertible_p and
888 vector_types_compatible_elements_p are used for vector value types. */
889 /* True if pointers to distinct types T1 and T2 can be converted to
890 each other without an explicit cast. Only returns true for opaque
893 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
895 if (VECTOR_TYPE_P (t1
) && VECTOR_TYPE_P (t2
)
896 && (TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
897 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
903 /* vector_types_convertible_p is used for vector value types.
904 It could in principle call vector_targets_convertible_p as a subroutine,
905 but then the check for vector type would be duplicated with its callers,
906 and also the purpose of vector_targets_convertible_p would become
908 Where vector_types_convertible_p returns true, a conversion might still be
909 needed to make the types match.
910 In contrast, vector_targets_convertible_p is used for vector pointer
911 values, and vector_types_compatible_elements_p is used specifically
912 in the context for binary operators, as a check if use is possible without
914 /* True if vector types T1 and T2 can be converted to each other
915 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
916 can only be converted with -flax-vector-conversions yet that is not
917 in effect, emit a note telling the user about that option if such
918 a note has not previously been emitted. */
920 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
922 static bool emitted_lax_note
= false;
923 bool convertible_lax
;
925 if ((TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
926 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
930 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
931 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
932 || known_eq (TYPE_VECTOR_SUBPARTS (t1
),
933 TYPE_VECTOR_SUBPARTS (t2
)))
934 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
935 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
937 if (!convertible_lax
|| flag_lax_vector_conversions
)
938 return convertible_lax
;
940 if (known_eq (TYPE_VECTOR_SUBPARTS (t1
), TYPE_VECTOR_SUBPARTS (t2
))
941 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
944 if (emit_lax_note
&& !emitted_lax_note
)
946 emitted_lax_note
= true;
947 inform (input_location
, "use -flax-vector-conversions to permit "
948 "conversions between vectors with differing "
949 "element types or numbers of subparts");
955 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes
956 and have vector types, V0 has the same type as V1, and the number of
957 elements of V0, V1, MASK is the same.
959 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
960 called with two arguments. In this case implementation passes the
961 first argument twice in order to share the same tree code. This fact
962 could enable the mask-values being twice the vector length. This is
963 an implementation accident and this semantics is not guaranteed to
966 c_build_vec_perm_expr (location_t loc
, tree v0
, tree v1
, tree mask
,
971 bool maybe_const
= false;
972 bool two_arguments
= false;
976 two_arguments
= true;
980 if (v0
== error_mark_node
|| v1
== error_mark_node
981 || mask
== error_mark_node
)
982 return error_mark_node
;
984 if (!VECTOR_INTEGER_TYPE_P (TREE_TYPE (mask
)))
987 error_at (loc
, "__builtin_shuffle last argument must "
988 "be an integer vector");
989 return error_mark_node
;
992 if (!VECTOR_TYPE_P (TREE_TYPE (v0
))
993 || !VECTOR_TYPE_P (TREE_TYPE (v1
)))
996 error_at (loc
, "__builtin_shuffle arguments must be vectors");
997 return error_mark_node
;
1000 if (TYPE_MAIN_VARIANT (TREE_TYPE (v0
)) != TYPE_MAIN_VARIANT (TREE_TYPE (v1
)))
1003 error_at (loc
, "__builtin_shuffle argument vectors must be of "
1005 return error_mark_node
;
1008 if (maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v0
)),
1009 TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask
)))
1010 && maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v1
)),
1011 TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask
))))
1014 error_at (loc
, "__builtin_shuffle number of elements of the "
1015 "argument vector(s) and the mask vector should "
1017 return error_mark_node
;
1020 if (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (TREE_TYPE (v0
))))
1021 != GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (TREE_TYPE (mask
)))))
1024 error_at (loc
, "__builtin_shuffle argument vector(s) inner type "
1025 "must have the same size as inner type of the mask");
1026 return error_mark_node
;
1029 if (!c_dialect_cxx ())
1031 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
1032 v0
= c_fully_fold (v0
, false, &maybe_const
);
1033 wrap
&= maybe_const
;
1036 v1
= v0
= save_expr (v0
);
1039 v1
= c_fully_fold (v1
, false, &maybe_const
);
1040 wrap
&= maybe_const
;
1043 mask
= c_fully_fold (mask
, false, &maybe_const
);
1044 wrap
&= maybe_const
;
1046 else if (two_arguments
)
1047 v1
= v0
= save_expr (v0
);
1049 ret
= build3_loc (loc
, VEC_PERM_EXPR
, TREE_TYPE (v0
), v0
, v1
, mask
);
1051 if (!c_dialect_cxx () && !wrap
)
1052 ret
= c_wrap_maybe_const (ret
, true);
1057 /* Like tree.c:get_narrower, but retain conversion from C++0x scoped enum
1058 to integral type. */
1061 c_common_get_narrower (tree op
, int *unsignedp_ptr
)
1063 op
= get_narrower (op
, unsignedp_ptr
);
1065 if (TREE_CODE (TREE_TYPE (op
)) == ENUMERAL_TYPE
1066 && ENUM_IS_SCOPED (TREE_TYPE (op
)))
1068 /* C++0x scoped enumerations don't implicitly convert to integral
1069 type; if we stripped an explicit conversion to a larger type we
1070 need to replace it so common_type will still work. */
1071 tree type
= c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op
)),
1072 TYPE_UNSIGNED (TREE_TYPE (op
)));
1073 op
= fold_convert (type
, op
);
1078 /* This is a helper function of build_binary_op.
1080 For certain operations if both args were extended from the same
1081 smaller type, do the arithmetic in that type and then extend.
1083 BITWISE indicates a bitwise operation.
1084 For them, this optimization is safe only if
1085 both args are zero-extended or both are sign-extended.
1086 Otherwise, we might change the result.
1087 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1088 but calculated in (unsigned short) it would be (unsigned short)-1.
1091 shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
1093 int unsigned0
, unsigned1
;
1098 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1099 excessive narrowing when we call get_narrower below. For
1100 example, suppose that OP0 is of unsigned int extended
1101 from signed char and that RESULT_TYPE is long long int.
1102 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1105 (long long int) (unsigned int) signed_char
1107 which get_narrower would narrow down to
1109 (unsigned int) signed char
1111 If we do not cast OP0 first, get_narrower would return
1112 signed_char, which is inconsistent with the case of the
1114 op0
= convert (result_type
, op0
);
1115 op1
= convert (result_type
, op1
);
1117 arg0
= c_common_get_narrower (op0
, &unsigned0
);
1118 arg1
= c_common_get_narrower (op1
, &unsigned1
);
1120 /* UNS is 1 if the operation to be done is an unsigned one. */
1121 uns
= TYPE_UNSIGNED (result_type
);
1123 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1124 but it *requires* conversion to FINAL_TYPE. */
1126 if ((TYPE_PRECISION (TREE_TYPE (op0
))
1127 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1128 && TREE_TYPE (op0
) != result_type
)
1129 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1130 if ((TYPE_PRECISION (TREE_TYPE (op1
))
1131 == TYPE_PRECISION (TREE_TYPE (arg1
)))
1132 && TREE_TYPE (op1
) != result_type
)
1133 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1135 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1137 /* For bitwise operations, signedness of nominal type
1138 does not matter. Consider only how operands were extended. */
1142 /* Note that in all three cases below we refrain from optimizing
1143 an unsigned operation on sign-extended args.
1144 That would not be valid. */
1146 /* Both args variable: if both extended in same way
1147 from same width, do it in that width.
1148 Do it unsigned if args were zero-extended. */
1149 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
1150 < TYPE_PRECISION (result_type
))
1151 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1152 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1153 && unsigned0
== unsigned1
1154 && (unsigned0
|| !uns
))
1155 return c_common_signed_or_unsigned_type
1156 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
1158 else if (TREE_CODE (arg0
) == INTEGER_CST
1159 && (unsigned1
|| !uns
)
1160 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1161 < TYPE_PRECISION (result_type
))
1163 = c_common_signed_or_unsigned_type (unsigned1
,
1165 && !POINTER_TYPE_P (type
)
1166 && int_fits_type_p (arg0
, type
))
1169 else if (TREE_CODE (arg1
) == INTEGER_CST
1170 && (unsigned0
|| !uns
)
1171 && (TYPE_PRECISION (TREE_TYPE (arg0
))
1172 < TYPE_PRECISION (result_type
))
1174 = c_common_signed_or_unsigned_type (unsigned0
,
1176 && !POINTER_TYPE_P (type
)
1177 && int_fits_type_p (arg1
, type
))
1183 /* Returns true iff any integer value of type FROM_TYPE can be represented as
1184 real of type TO_TYPE. This is a helper function for unsafe_conversion_p. */
1187 int_safely_convertible_to_real_p (const_tree from_type
, const_tree to_type
)
1189 tree type_low_bound
= TYPE_MIN_VALUE (from_type
);
1190 tree type_high_bound
= TYPE_MAX_VALUE (from_type
);
1191 REAL_VALUE_TYPE real_low_bound
=
1192 real_value_from_int_cst (0, type_low_bound
);
1193 REAL_VALUE_TYPE real_high_bound
=
1194 real_value_from_int_cst (0, type_high_bound
);
1196 return exact_real_truncate (TYPE_MODE (to_type
), &real_low_bound
)
1197 && exact_real_truncate (TYPE_MODE (to_type
), &real_high_bound
);
1200 /* Checks if expression EXPR of complex/real/integer type cannot be converted
1201 to the complex/real/integer type TYPE. Function returns non-zero when:
1202 * EXPR is a constant which cannot be exactly converted to TYPE.
1203 * EXPR is not a constant and size of EXPR's type > than size of TYPE,
1204 for EXPR type and TYPE being both integers or both real, or both
1206 * EXPR is not a constant of complex type and TYPE is a real or
1208 * EXPR is not a constant of real type and TYPE is an integer.
1209 * EXPR is not a constant of integer type which cannot be
1210 exactly converted to real type.
1212 Function allows conversions between types of different signedness and
1213 can return SAFE_CONVERSION (zero) in that case. Function can produce
1214 signedness warnings if PRODUCE_WARNS is true.
1216 RESULT, when non-null is the result of the conversion. When constant
1217 it is included in the text of diagnostics.
1219 Function allows conversions from complex constants to non-complex types,
1220 provided that imaginary part is zero and real part can be safely converted
1223 enum conversion_safety
1224 unsafe_conversion_p (location_t loc
, tree type
, tree expr
, tree result
,
1227 enum conversion_safety give_warning
= SAFE_CONVERSION
; /* is 0 or false */
1228 tree expr_type
= TREE_TYPE (expr
);
1230 bool cstresult
= (result
1231 && TREE_CODE_CLASS (TREE_CODE (result
)) == tcc_constant
);
1233 loc
= expansion_point_location_if_in_system_header (loc
);
1235 if (TREE_CODE (expr
) == REAL_CST
|| TREE_CODE (expr
) == INTEGER_CST
)
1237 /* If type is complex, we are interested in compatibility with
1239 if (TREE_CODE (type
) == COMPLEX_TYPE
)
1240 type
= TREE_TYPE (type
);
1242 /* Warn for real constant that is not an exact integer converted
1244 if (TREE_CODE (expr_type
) == REAL_TYPE
1245 && TREE_CODE (type
) == INTEGER_TYPE
)
1247 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (expr_type
)))
1248 give_warning
= UNSAFE_REAL
;
1250 /* Warn for an integer constant that does not fit into integer type. */
1251 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1252 && TREE_CODE (type
) == INTEGER_TYPE
1253 && !int_fits_type_p (expr
, type
))
1255 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)
1256 && tree_int_cst_sgn (expr
) < 0)
1261 warning_at (loc
, OPT_Wsign_conversion
,
1262 "unsigned conversion from %qT to %qT "
1263 "changes value from %qE to %qE",
1264 expr_type
, type
, expr
, result
);
1266 warning_at (loc
, OPT_Wsign_conversion
,
1267 "unsigned conversion from %qT to %qT "
1268 "changes the value of %qE",
1269 expr_type
, type
, expr
);
1272 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (expr_type
))
1275 warning_at (loc
, OPT_Wsign_conversion
,
1276 "signed conversion from %qT to %qT changes "
1277 "value from %qE to %qE",
1278 expr_type
, type
, expr
, result
);
1280 warning_at (loc
, OPT_Wsign_conversion
,
1281 "signed conversion from %qT to %qT changes "
1283 expr_type
, type
, expr
);
1286 give_warning
= UNSAFE_OTHER
;
1288 else if (TREE_CODE (type
) == REAL_TYPE
)
1290 /* Warn for an integer constant that does not fit into real type. */
1291 if (TREE_CODE (expr_type
) == INTEGER_TYPE
)
1293 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
1294 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1295 give_warning
= UNSAFE_REAL
;
1297 /* Warn for a real constant that does not fit into a smaller
1299 else if (TREE_CODE (expr_type
) == REAL_TYPE
1300 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1302 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
1303 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1304 give_warning
= UNSAFE_REAL
;
1309 else if (TREE_CODE (expr
) == COMPLEX_CST
)
1311 tree imag_part
= TREE_IMAGPART (expr
);
1312 /* Conversion from complex constant with zero imaginary part,
1313 perform check for conversion of real part. */
1314 if ((TREE_CODE (imag_part
) == REAL_CST
1315 && real_zerop (imag_part
))
1316 || (TREE_CODE (imag_part
) == INTEGER_CST
1317 && integer_zerop (imag_part
)))
1318 /* Note: in this branch we use recursive call to unsafe_conversion_p
1319 with different type of EXPR, but it is still safe, because when EXPR
1320 is a constant, it's type is not used in text of generated warnings
1321 (otherwise they could sound misleading). */
1322 return unsafe_conversion_p (loc
, type
, TREE_REALPART (expr
), result
,
1324 /* Conversion from complex constant with non-zero imaginary part. */
1327 /* Conversion to complex type.
1328 Perform checks for both real and imaginary parts. */
1329 if (TREE_CODE (type
) == COMPLEX_TYPE
)
1331 /* Unfortunately, produce_warns must be false in two subsequent
1332 calls of unsafe_conversion_p, because otherwise we could
1333 produce strange "double" warnings, if both real and imaginary
1334 parts have conversion problems related to signedness.
1337 int32_t _Complex a = 0x80000000 + 0x80000000i;
1339 Possible solution: add a separate function for checking
1340 constants and combine result of two calls appropriately. */
1341 enum conversion_safety re_safety
=
1342 unsafe_conversion_p (loc
, type
, TREE_REALPART (expr
),
1344 enum conversion_safety im_safety
=
1345 unsafe_conversion_p (loc
, type
, imag_part
, result
, false);
1347 /* Merge the results into appropriate single warning. */
1349 /* Note: this case includes SAFE_CONVERSION, i.e. success. */
1350 if (re_safety
== im_safety
)
1351 give_warning
= re_safety
;
1352 else if (!re_safety
&& im_safety
)
1353 give_warning
= im_safety
;
1354 else if (re_safety
&& !im_safety
)
1355 give_warning
= re_safety
;
1357 give_warning
= UNSAFE_OTHER
;
1359 /* Warn about conversion from complex to real or integer type. */
1361 give_warning
= UNSAFE_IMAGINARY
;
1365 /* Checks for remaining case: EXPR is not constant. */
1368 /* Warn for real types converted to integer types. */
1369 if (TREE_CODE (expr_type
) == REAL_TYPE
1370 && TREE_CODE (type
) == INTEGER_TYPE
)
1371 give_warning
= UNSAFE_REAL
;
1373 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1374 && TREE_CODE (type
) == INTEGER_TYPE
)
1376 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1377 expr
= get_unwidened (expr
, 0);
1378 expr_type
= TREE_TYPE (expr
);
1380 /* Don't warn for short y; short x = ((int)y & 0xff); */
1381 if (TREE_CODE (expr
) == BIT_AND_EXPR
1382 || TREE_CODE (expr
) == BIT_IOR_EXPR
1383 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
1385 /* If both args were extended from a shortest type,
1386 use that type if that is safe. */
1387 expr_type
= shorten_binary_op (expr_type
,
1388 TREE_OPERAND (expr
, 0),
1389 TREE_OPERAND (expr
, 1),
1392 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
1394 tree op0
= TREE_OPERAND (expr
, 0);
1395 tree op1
= TREE_OPERAND (expr
, 1);
1396 bool unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1397 bool unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1399 /* If one of the operands is a non-negative constant
1400 that fits in the target type, then the type of the
1401 other operand does not matter. */
1402 if ((TREE_CODE (op0
) == INTEGER_CST
1403 && int_fits_type_p (op0
, c_common_signed_type (type
))
1404 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
1405 || (TREE_CODE (op1
) == INTEGER_CST
1406 && int_fits_type_p (op1
, c_common_signed_type (type
))
1407 && int_fits_type_p (op1
,
1408 c_common_unsigned_type (type
))))
1409 return SAFE_CONVERSION
;
1410 /* If constant is unsigned and fits in the target
1411 type, then the result will also fit. */
1412 else if ((TREE_CODE (op0
) == INTEGER_CST
1414 && int_fits_type_p (op0
, type
))
1415 || (TREE_CODE (op1
) == INTEGER_CST
1417 && int_fits_type_p (op1
, type
)))
1418 return SAFE_CONVERSION
;
1421 /* Warn for integer types converted to smaller integer types. */
1422 if (TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1423 give_warning
= UNSAFE_OTHER
;
1425 /* When they are the same width but different signedness,
1426 then the value may change. */
1427 else if (((TYPE_PRECISION (type
) == TYPE_PRECISION (expr_type
)
1428 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
1429 /* Even when converted to a bigger type, if the type is
1430 unsigned but expr is signed, then negative values
1432 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
1434 warning_at (loc
, OPT_Wsign_conversion
, "conversion to %qT from %qT "
1435 "may change the sign of the result",
1439 /* Warn for integer types converted to real types if and only if
1440 all the range of values of the integer type cannot be
1441 represented by the real type. */
1442 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1443 && TREE_CODE (type
) == REAL_TYPE
)
1445 /* Don't warn about char y = 0xff; float x = (int) y; */
1446 expr
= get_unwidened (expr
, 0);
1447 expr_type
= TREE_TYPE (expr
);
1449 if (!int_safely_convertible_to_real_p (expr_type
, type
))
1450 give_warning
= UNSAFE_OTHER
;
1453 /* Warn for real types converted to smaller real types. */
1454 else if (TREE_CODE (expr_type
) == REAL_TYPE
1455 && TREE_CODE (type
) == REAL_TYPE
1456 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1457 give_warning
= UNSAFE_REAL
;
1459 /* Check conversion between two complex types. */
1460 else if (TREE_CODE (expr_type
) == COMPLEX_TYPE
1461 && TREE_CODE (type
) == COMPLEX_TYPE
)
1463 /* Extract underlying types (i.e., type of real and imaginary
1464 parts) of expr_type and type. */
1465 tree from_type
= TREE_TYPE (expr_type
);
1466 tree to_type
= TREE_TYPE (type
);
1468 /* Warn for real types converted to integer types. */
1469 if (TREE_CODE (from_type
) == REAL_TYPE
1470 && TREE_CODE (to_type
) == INTEGER_TYPE
)
1471 give_warning
= UNSAFE_REAL
;
1473 /* Warn for real types converted to smaller real types. */
1474 else if (TREE_CODE (from_type
) == REAL_TYPE
1475 && TREE_CODE (to_type
) == REAL_TYPE
1476 && TYPE_PRECISION (to_type
) < TYPE_PRECISION (from_type
))
1477 give_warning
= UNSAFE_REAL
;
1479 /* Check conversion for complex integer types. Here implementation
1480 is simpler than for real-domain integers because it does not
1481 involve sophisticated cases, such as bitmasks, casts, etc. */
1482 else if (TREE_CODE (from_type
) == INTEGER_TYPE
1483 && TREE_CODE (to_type
) == INTEGER_TYPE
)
1485 /* Warn for integer types converted to smaller integer types. */
1486 if (TYPE_PRECISION (to_type
) < TYPE_PRECISION (from_type
))
1487 give_warning
= UNSAFE_OTHER
;
1489 /* Check for different signedness, see case for real-domain
1490 integers (above) for a more detailed comment. */
1491 else if (((TYPE_PRECISION (to_type
) == TYPE_PRECISION (from_type
)
1492 && TYPE_UNSIGNED (to_type
) != TYPE_UNSIGNED (from_type
))
1493 || (TYPE_UNSIGNED (to_type
) && !TYPE_UNSIGNED (from_type
)))
1495 warning_at (loc
, OPT_Wsign_conversion
,
1496 "conversion to %qT from %qT "
1497 "may change the sign of the result",
1500 else if (TREE_CODE (from_type
) == INTEGER_TYPE
1501 && TREE_CODE (to_type
) == REAL_TYPE
1502 && !int_safely_convertible_to_real_p (from_type
, to_type
))
1503 give_warning
= UNSAFE_OTHER
;
1506 /* Warn for complex types converted to real or integer types. */
1507 else if (TREE_CODE (expr_type
) == COMPLEX_TYPE
1508 && TREE_CODE (type
) != COMPLEX_TYPE
)
1509 give_warning
= UNSAFE_IMAGINARY
;
1512 return give_warning
;
1516 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1517 Invoke this function on every expression that is converted implicitly,
1518 i.e. because of language rules and not because of an explicit cast. */
1521 convert_and_check (location_t loc
, tree type
, tree expr
)
1524 tree expr_for_warning
;
1526 /* Convert from a value with possible excess precision rather than
1527 via the semantic type, but do not warn about values not fitting
1528 exactly in the semantic type. */
1529 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
1531 tree orig_type
= TREE_TYPE (expr
);
1532 expr
= TREE_OPERAND (expr
, 0);
1533 expr_for_warning
= convert (orig_type
, expr
);
1534 if (orig_type
== type
)
1535 return expr_for_warning
;
1538 expr_for_warning
= expr
;
1540 if (TREE_TYPE (expr
) == type
)
1543 result
= convert (type
, expr
);
1545 if (c_inhibit_evaluation_warnings
== 0
1546 && !TREE_OVERFLOW_P (expr
)
1547 && result
!= error_mark_node
)
1548 warnings_for_convert_and_check (loc
, type
, expr_for_warning
, result
);
1553 /* A node in a list that describes references to variables (EXPR), which are
1554 either read accesses if WRITER is zero, or write accesses, in which case
1555 WRITER is the parent of EXPR. */
1562 /* Used to implement a cache the results of a call to verify_tree. We only
1563 use this for SAVE_EXPRs. */
1566 struct tlist_cache
*next
;
1567 struct tlist
*cache_before_sp
;
1568 struct tlist
*cache_after_sp
;
1572 /* Obstack to use when allocating tlist structures, and corresponding
1574 static struct obstack tlist_obstack
;
1575 static char *tlist_firstobj
= 0;
1577 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1579 static struct tlist
*warned_ids
;
1580 /* SAVE_EXPRs need special treatment. We process them only once and then
1581 cache the results. */
1582 static struct tlist_cache
*save_expr_cache
;
1584 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
1585 static void merge_tlist (struct tlist
**, struct tlist
*, int);
1586 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
1587 static bool warning_candidate_p (tree
);
1588 static bool candidate_equal_p (const_tree
, const_tree
);
1589 static void warn_for_collisions (struct tlist
*);
1590 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
1591 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
1593 /* Create a new struct tlist and fill in its fields. */
1594 static struct tlist
*
1595 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1598 l
= XOBNEW (&tlist_obstack
, struct tlist
);
1605 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1606 is nonnull, we ignore any node we find which has a writer equal to it. */
1609 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1613 struct tlist
*next
= add
->next
;
1616 if (!exclude_writer
|| !candidate_equal_p (add
->writer
, exclude_writer
))
1617 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1622 /* Merge the nodes of ADD into TO. This merging process is done so that for
1623 each variable that already exists in TO, no new node is added; however if
1624 there is a write access recorded in ADD, and an occurrence on TO is only
1625 a read access, then the occurrence in TO will be modified to record the
1629 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1631 struct tlist
**end
= to
;
1634 end
= &(*end
)->next
;
1640 struct tlist
*next
= add
->next
;
1642 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1643 if (candidate_equal_p (tmp2
->expr
, add
->expr
))
1647 tmp2
->writer
= add
->writer
;
1651 *end
= copy
? new_tlist (NULL
, add
->expr
, add
->writer
) : add
;
1652 end
= &(*end
)->next
;
1659 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1660 references in list LIST conflict with it, excluding reads if ONLY writers
1664 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1669 /* Avoid duplicate warnings. */
1670 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1671 if (candidate_equal_p (tmp
->expr
, written
))
1676 if (candidate_equal_p (list
->expr
, written
)
1677 && !candidate_equal_p (list
->writer
, writer
)
1678 && (!only_writes
|| list
->writer
))
1680 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1681 warning_at (EXPR_LOC_OR_LOC (writer
, input_location
),
1682 OPT_Wsequence_point
, "operation on %qE may be undefined",
1689 /* Given a list LIST of references to variables, find whether any of these
1690 can cause conflicts due to missing sequence points. */
1693 warn_for_collisions (struct tlist
*list
)
1697 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1700 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1704 /* Return nonzero if X is a tree that can be verified by the sequence point
1708 warning_candidate_p (tree x
)
1710 if (DECL_P (x
) && DECL_ARTIFICIAL (x
))
1713 if (TREE_CODE (x
) == BLOCK
)
1716 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
1717 (lvalue_p) crash on TRY/CATCH. */
1718 if (TREE_TYPE (x
) == NULL_TREE
|| VOID_TYPE_P (TREE_TYPE (x
)))
1724 /* No point to track non-const calls, they will never satisfy
1726 if (TREE_CODE (x
) == CALL_EXPR
&& (call_expr_flags (x
) & ECF_CONST
) == 0)
1729 if (TREE_CODE (x
) == STRING_CST
)
1735 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
1737 candidate_equal_p (const_tree x
, const_tree y
)
1739 return (x
== y
) || (x
&& y
&& operand_equal_p (x
, y
, 0));
1742 /* Walk the tree X, and record accesses to variables. If X is written by the
1743 parent tree, WRITER is the parent.
1744 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1745 expression or its only operand forces a sequence point, then everything up
1746 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1748 Once we return, we will have emitted warnings if any subexpression before
1749 such a sequence point could be undefined. On a higher level, however, the
1750 sequence point may not be relevant, and we'll merge the two lists.
1752 Example: (b++, a) + b;
1753 The call that processes the COMPOUND_EXPR will store the increment of B
1754 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1755 processes the PLUS_EXPR will need to merge the two lists so that
1756 eventually, all accesses end up on the same list (and we'll warn about the
1757 unordered subexpressions b++ and b.
1759 A note on merging. If we modify the former example so that our expression
1762 care must be taken not simply to add all three expressions into the final
1763 PNO_SP list. The function merge_tlist takes care of that by merging the
1764 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1765 way, so that no more than one access to B is recorded. */
1768 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
1771 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1772 enum tree_code code
;
1773 enum tree_code_class cl
;
1775 /* X may be NULL if it is the operand of an empty statement expression
1781 code
= TREE_CODE (x
);
1782 cl
= TREE_CODE_CLASS (code
);
1784 if (warning_candidate_p (x
))
1785 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1794 case TRUTH_ANDIF_EXPR
:
1795 case TRUTH_ORIF_EXPR
:
1796 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1797 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1798 warn_for_collisions (tmp_nosp
);
1799 merge_tlist (pbefore_sp
, tmp_before
, 0);
1800 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1801 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1802 warn_for_collisions (tmp_list2
);
1803 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1804 merge_tlist (pno_sp
, tmp_list2
, 0);
1808 tmp_before
= tmp_list2
= 0;
1809 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1810 warn_for_collisions (tmp_list2
);
1811 merge_tlist (pbefore_sp
, tmp_before
, 0);
1812 merge_tlist (pbefore_sp
, tmp_list2
, 0);
1814 tmp_list3
= tmp_nosp
= 0;
1815 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1816 warn_for_collisions (tmp_nosp
);
1817 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1819 tmp_list3
= tmp_list2
= 0;
1820 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1821 warn_for_collisions (tmp_list2
);
1822 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1823 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1824 two first, to avoid warning for (a ? b++ : b++). */
1825 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1826 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1829 case PREDECREMENT_EXPR
:
1830 case PREINCREMENT_EXPR
:
1831 case POSTDECREMENT_EXPR
:
1832 case POSTINCREMENT_EXPR
:
1833 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1837 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1838 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1839 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1840 /* Expressions inside the LHS are not ordered wrt. the sequence points
1841 in the RHS. Example:
1843 Despite the fact that the modification of "a" is in the before_sp
1844 list (tmp_before), it conflicts with the use of "a" in the LHS.
1845 We can handle this by adding the contents of tmp_list3
1846 to those of tmp_before, and redoing the collision warnings for that
1848 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1849 warn_for_collisions (tmp_before
);
1850 /* Exclude the LHS itself here; we first have to merge it into the
1851 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1852 didn't exclude the LHS, we'd get it twice, once as a read and once
1854 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1855 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1857 merge_tlist (pbefore_sp
, tmp_before
, 0);
1858 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1859 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1860 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1864 /* We need to warn about conflicts among arguments and conflicts between
1865 args and the function address. Side effects of the function address,
1866 however, are not ordered by the sequence point of the call. */
1868 call_expr_arg_iterator iter
;
1870 tmp_before
= tmp_nosp
= 0;
1871 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1872 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
1874 tmp_list2
= tmp_list3
= 0;
1875 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
1876 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1877 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1879 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1880 warn_for_collisions (tmp_before
);
1881 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1886 /* Scan all the list, e.g. indices of multi dimensional array. */
1889 tmp_before
= tmp_nosp
= 0;
1890 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1891 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1892 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1899 struct tlist_cache
*t
;
1900 for (t
= save_expr_cache
; t
; t
= t
->next
)
1901 if (candidate_equal_p (t
->expr
, x
))
1906 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
1907 t
->next
= save_expr_cache
;
1909 save_expr_cache
= t
;
1911 tmp_before
= tmp_nosp
= 0;
1912 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1913 warn_for_collisions (tmp_nosp
);
1916 merge_tlist (&tmp_list3
, tmp_nosp
, 0);
1917 t
->cache_before_sp
= tmp_before
;
1918 t
->cache_after_sp
= tmp_list3
;
1920 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1921 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1926 x
= TREE_OPERAND (x
, 0);
1933 /* For other expressions, simply recurse on their operands.
1934 Manual tail recursion for unary expressions.
1935 Other non-expressions need not be processed. */
1936 if (cl
== tcc_unary
)
1938 x
= TREE_OPERAND (x
, 0);
1942 else if (IS_EXPR_CODE_CLASS (cl
))
1945 int max
= TREE_OPERAND_LENGTH (x
);
1946 for (lp
= 0; lp
< max
; lp
++)
1948 tmp_before
= tmp_nosp
= 0;
1949 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
1950 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1951 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1958 /* Try to warn for undefined behavior in EXPR due to missing sequence
1962 verify_sequence_points (tree expr
)
1964 struct tlist
*before_sp
= 0, *after_sp
= 0;
1967 save_expr_cache
= 0;
1968 if (tlist_firstobj
== 0)
1970 gcc_obstack_init (&tlist_obstack
);
1971 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
1974 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1975 warn_for_collisions (after_sp
);
1976 obstack_free (&tlist_obstack
, tlist_firstobj
);
1979 /* Validate the expression after `case' and apply default promotions. */
1982 check_case_value (location_t loc
, tree value
)
1984 if (value
== NULL_TREE
)
1987 if (TREE_CODE (value
) == INTEGER_CST
)
1988 /* Promote char or short to int. */
1989 value
= perform_integral_promotions (value
);
1990 else if (value
!= error_mark_node
)
1992 error_at (loc
, "case label does not reduce to an integer constant");
1993 value
= error_mark_node
;
1996 constant_expression_warning (value
);
2001 /* See if the case values LOW and HIGH are in the range of the original
2002 type (i.e. before the default conversion to int) of the switch testing
2004 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2005 the type before promoting it. CASE_LOW_P is a pointer to the lower
2006 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2007 if the case is not a case range.
2008 The caller has to make sure that we are not called with NULL for
2009 CASE_LOW_P (i.e. the default case). OUTSIDE_RANGE_P says whether there
2010 was a case value that doesn't fit into the range of the ORIG_TYPE.
2011 Returns true if the case label is in range of ORIG_TYPE (saturated or
2012 untouched) or false if the label is out of range. */
2015 check_case_bounds (location_t loc
, tree type
, tree orig_type
,
2016 tree
*case_low_p
, tree
*case_high_p
,
2017 bool *outside_range_p
)
2019 tree min_value
, max_value
;
2020 tree case_low
= *case_low_p
;
2021 tree case_high
= case_high_p
? *case_high_p
: case_low
;
2023 /* If there was a problem with the original type, do nothing. */
2024 if (orig_type
== error_mark_node
)
2027 min_value
= TYPE_MIN_VALUE (orig_type
);
2028 max_value
= TYPE_MAX_VALUE (orig_type
);
2030 /* We'll really need integer constants here. */
2031 case_low
= fold (case_low
);
2032 case_high
= fold (case_high
);
2034 /* Case label is less than minimum for type. */
2035 if (tree_int_cst_compare (case_low
, min_value
) < 0
2036 && tree_int_cst_compare (case_high
, min_value
) < 0)
2038 warning_at (loc
, 0, "case label value is less than minimum value "
2040 *outside_range_p
= true;
2044 /* Case value is greater than maximum for type. */
2045 if (tree_int_cst_compare (case_low
, max_value
) > 0
2046 && tree_int_cst_compare (case_high
, max_value
) > 0)
2048 warning_at (loc
, 0, "case label value exceeds maximum value for type");
2049 *outside_range_p
= true;
2053 /* Saturate lower case label value to minimum. */
2054 if (tree_int_cst_compare (case_high
, min_value
) >= 0
2055 && tree_int_cst_compare (case_low
, min_value
) < 0)
2057 warning_at (loc
, 0, "lower value in case label range"
2058 " less than minimum value for type");
2059 *outside_range_p
= true;
2060 case_low
= min_value
;
2063 /* Saturate upper case label value to maximum. */
2064 if (tree_int_cst_compare (case_low
, max_value
) <= 0
2065 && tree_int_cst_compare (case_high
, max_value
) > 0)
2067 warning_at (loc
, 0, "upper value in case label range"
2068 " exceeds maximum value for type");
2069 *outside_range_p
= true;
2070 case_high
= max_value
;
2073 if (*case_low_p
!= case_low
)
2074 *case_low_p
= convert (type
, case_low
);
2075 if (case_high_p
&& *case_high_p
!= case_high
)
2076 *case_high_p
= convert (type
, case_high
);
2081 /* Return an integer type with BITS bits of precision,
2082 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2085 c_common_type_for_size (unsigned int bits
, int unsignedp
)
2089 if (bits
== TYPE_PRECISION (integer_type_node
))
2090 return unsignedp
? unsigned_type_node
: integer_type_node
;
2092 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2093 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2095 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2096 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2098 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2099 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2101 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2102 return (unsignedp
? long_long_unsigned_type_node
2103 : long_long_integer_type_node
);
2105 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2106 if (int_n_enabled_p
[i
]
2107 && bits
== int_n_data
[i
].bitsize
)
2108 return (unsignedp
? int_n_trees
[i
].unsigned_type
2109 : int_n_trees
[i
].signed_type
);
2111 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2112 return (unsignedp
? widest_unsigned_literal_type_node
2113 : widest_integer_literal_type_node
);
2115 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2116 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2118 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2119 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2121 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2122 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2124 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2125 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2130 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2131 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2132 and saturating if SATP is nonzero, otherwise not saturating. */
2135 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
2136 int unsignedp
, int satp
)
2138 enum mode_class mclass
;
2140 mclass
= unsignedp
? MODE_UFRACT
: MODE_FRACT
;
2142 mclass
= unsignedp
? MODE_UACCUM
: MODE_ACCUM
;
2144 opt_scalar_mode opt_mode
;
2146 FOR_EACH_MODE_IN_CLASS (opt_mode
, mclass
)
2148 mode
= opt_mode
.require ();
2149 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2153 if (!opt_mode
.exists (&mode
) || !targetm
.scalar_mode_supported_p (mode
))
2155 sorry ("GCC cannot support operators with integer types and "
2156 "fixed-point types that have too many integral and "
2157 "fractional bits together");
2161 return c_common_type_for_mode (mode
, satp
);
2164 /* Used for communication between c_common_type_for_mode and
2165 c_register_builtin_type. */
2166 tree registered_builtin_types
;
2168 /* Return a data type that has machine mode MODE.
2169 If the mode is an integer,
2170 then UNSIGNEDP selects between signed and unsigned types.
2171 If the mode is a fixed-point mode,
2172 then UNSIGNEDP selects between saturating and nonsaturating types. */
2175 c_common_type_for_mode (machine_mode mode
, int unsignedp
)
2180 if (mode
== TYPE_MODE (integer_type_node
))
2181 return unsignedp
? unsigned_type_node
: integer_type_node
;
2183 if (mode
== TYPE_MODE (signed_char_type_node
))
2184 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2186 if (mode
== TYPE_MODE (short_integer_type_node
))
2187 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2189 if (mode
== TYPE_MODE (long_integer_type_node
))
2190 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2192 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2193 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2195 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2196 if (int_n_enabled_p
[i
]
2197 && mode
== int_n_data
[i
].m
)
2198 return (unsignedp
? int_n_trees
[i
].unsigned_type
2199 : int_n_trees
[i
].signed_type
);
2202 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2205 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2208 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2211 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2213 #if HOST_BITS_PER_WIDE_INT >= 64
2214 if (mode
== TYPE_MODE (intTI_type_node
))
2215 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2218 if (mode
== TYPE_MODE (float_type_node
))
2219 return float_type_node
;
2221 if (mode
== TYPE_MODE (double_type_node
))
2222 return double_type_node
;
2224 if (mode
== TYPE_MODE (long_double_type_node
))
2225 return long_double_type_node
;
2227 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
2228 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
2229 && mode
== TYPE_MODE (FLOATN_NX_TYPE_NODE (i
)))
2230 return FLOATN_NX_TYPE_NODE (i
);
2232 if (mode
== TYPE_MODE (void_type_node
))
2233 return void_type_node
;
2235 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
))
2236 || mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2238 unsigned int precision
2239 = GET_MODE_PRECISION (as_a
<scalar_int_mode
> (mode
));
2241 ? make_unsigned_type (precision
)
2242 : make_signed_type (precision
));
2245 if (COMPLEX_MODE_P (mode
))
2247 machine_mode inner_mode
;
2250 if (mode
== TYPE_MODE (complex_float_type_node
))
2251 return complex_float_type_node
;
2252 if (mode
== TYPE_MODE (complex_double_type_node
))
2253 return complex_double_type_node
;
2254 if (mode
== TYPE_MODE (complex_long_double_type_node
))
2255 return complex_long_double_type_node
;
2257 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
2258 if (COMPLEX_FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
2259 && mode
== TYPE_MODE (COMPLEX_FLOATN_NX_TYPE_NODE (i
)))
2260 return COMPLEX_FLOATN_NX_TYPE_NODE (i
);
2262 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
2263 return complex_integer_type_node
;
2265 inner_mode
= GET_MODE_INNER (mode
);
2266 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2267 if (inner_type
!= NULL_TREE
)
2268 return build_complex_type (inner_type
);
2270 else if (GET_MODE_CLASS (mode
) == MODE_VECTOR_BOOL
2271 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
2273 unsigned int elem_bits
= vector_element_size (GET_MODE_BITSIZE (mode
),
2274 GET_MODE_NUNITS (mode
));
2275 tree bool_type
= build_nonstandard_boolean_type (elem_bits
);
2276 return build_vector_type_for_mode (bool_type
, mode
);
2278 else if (VECTOR_MODE_P (mode
)
2279 && valid_vector_subparts_p (GET_MODE_NUNITS (mode
)))
2281 machine_mode inner_mode
= GET_MODE_INNER (mode
);
2282 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2283 if (inner_type
!= NULL_TREE
)
2284 return build_vector_type_for_mode (inner_type
, mode
);
2287 if (mode
== TYPE_MODE (dfloat32_type_node
))
2288 return dfloat32_type_node
;
2289 if (mode
== TYPE_MODE (dfloat64_type_node
))
2290 return dfloat64_type_node
;
2291 if (mode
== TYPE_MODE (dfloat128_type_node
))
2292 return dfloat128_type_node
;
2294 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
2296 if (mode
== TYPE_MODE (short_fract_type_node
))
2297 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
2298 if (mode
== TYPE_MODE (fract_type_node
))
2299 return unsignedp
? sat_fract_type_node
: fract_type_node
;
2300 if (mode
== TYPE_MODE (long_fract_type_node
))
2301 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
2302 if (mode
== TYPE_MODE (long_long_fract_type_node
))
2303 return unsignedp
? sat_long_long_fract_type_node
2304 : long_long_fract_type_node
;
2306 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
2307 return unsignedp
? sat_unsigned_short_fract_type_node
2308 : unsigned_short_fract_type_node
;
2309 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
2310 return unsignedp
? sat_unsigned_fract_type_node
2311 : unsigned_fract_type_node
;
2312 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
2313 return unsignedp
? sat_unsigned_long_fract_type_node
2314 : unsigned_long_fract_type_node
;
2315 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
2316 return unsignedp
? sat_unsigned_long_long_fract_type_node
2317 : unsigned_long_long_fract_type_node
;
2319 if (mode
== TYPE_MODE (short_accum_type_node
))
2320 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
2321 if (mode
== TYPE_MODE (accum_type_node
))
2322 return unsignedp
? sat_accum_type_node
: accum_type_node
;
2323 if (mode
== TYPE_MODE (long_accum_type_node
))
2324 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
2325 if (mode
== TYPE_MODE (long_long_accum_type_node
))
2326 return unsignedp
? sat_long_long_accum_type_node
2327 : long_long_accum_type_node
;
2329 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
2330 return unsignedp
? sat_unsigned_short_accum_type_node
2331 : unsigned_short_accum_type_node
;
2332 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
2333 return unsignedp
? sat_unsigned_accum_type_node
2334 : unsigned_accum_type_node
;
2335 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
2336 return unsignedp
? sat_unsigned_long_accum_type_node
2337 : unsigned_long_accum_type_node
;
2338 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
2339 return unsignedp
? sat_unsigned_long_long_accum_type_node
2340 : unsigned_long_long_accum_type_node
;
2343 return unsignedp
? sat_qq_type_node
: qq_type_node
;
2345 return unsignedp
? sat_hq_type_node
: hq_type_node
;
2347 return unsignedp
? sat_sq_type_node
: sq_type_node
;
2349 return unsignedp
? sat_dq_type_node
: dq_type_node
;
2351 return unsignedp
? sat_tq_type_node
: tq_type_node
;
2353 if (mode
== UQQmode
)
2354 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
2355 if (mode
== UHQmode
)
2356 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
2357 if (mode
== USQmode
)
2358 return unsignedp
? sat_usq_type_node
: usq_type_node
;
2359 if (mode
== UDQmode
)
2360 return unsignedp
? sat_udq_type_node
: udq_type_node
;
2361 if (mode
== UTQmode
)
2362 return unsignedp
? sat_utq_type_node
: utq_type_node
;
2365 return unsignedp
? sat_ha_type_node
: ha_type_node
;
2367 return unsignedp
? sat_sa_type_node
: sa_type_node
;
2369 return unsignedp
? sat_da_type_node
: da_type_node
;
2371 return unsignedp
? sat_ta_type_node
: ta_type_node
;
2373 if (mode
== UHAmode
)
2374 return unsignedp
? sat_uha_type_node
: uha_type_node
;
2375 if (mode
== USAmode
)
2376 return unsignedp
? sat_usa_type_node
: usa_type_node
;
2377 if (mode
== UDAmode
)
2378 return unsignedp
? sat_uda_type_node
: uda_type_node
;
2379 if (mode
== UTAmode
)
2380 return unsignedp
? sat_uta_type_node
: uta_type_node
;
2383 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
2384 if (TYPE_MODE (TREE_VALUE (t
)) == mode
2385 && !!unsignedp
== !!TYPE_UNSIGNED (TREE_VALUE (t
)))
2386 return TREE_VALUE (t
);
2392 c_common_unsigned_type (tree type
)
2394 return c_common_signed_or_unsigned_type (1, type
);
2397 /* Return a signed type the same as TYPE in other respects. */
2400 c_common_signed_type (tree type
)
2402 return c_common_signed_or_unsigned_type (0, type
);
2405 /* Return a type the same as TYPE except unsigned or
2406 signed according to UNSIGNEDP. */
2409 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
2414 /* This block of code emulates the behavior of the old
2415 c_common_unsigned_type. In particular, it returns
2416 long_unsigned_type_node if passed a long, even when a int would
2417 have the same size. This is necessary for warnings to work
2418 correctly in archs where sizeof(int) == sizeof(long) */
2420 type1
= TYPE_MAIN_VARIANT (type
);
2421 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
2422 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2423 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2424 return unsignedp
? unsigned_type_node
: integer_type_node
;
2425 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2426 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2427 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2428 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2429 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
2430 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2432 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2433 if (int_n_enabled_p
[i
]
2434 && (type1
== int_n_trees
[i
].unsigned_type
2435 || type1
== int_n_trees
[i
].signed_type
))
2436 return (unsignedp
? int_n_trees
[i
].unsigned_type
2437 : int_n_trees
[i
].signed_type
);
2439 #if HOST_BITS_PER_WIDE_INT >= 64
2440 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2441 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2443 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2444 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2445 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2446 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2447 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2448 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2449 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2450 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2452 #define C_COMMON_FIXED_TYPES(NAME) \
2453 if (type1 == short_ ## NAME ## _type_node \
2454 || type1 == unsigned_short_ ## NAME ## _type_node) \
2455 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2456 : short_ ## NAME ## _type_node; \
2457 if (type1 == NAME ## _type_node \
2458 || type1 == unsigned_ ## NAME ## _type_node) \
2459 return unsignedp ? unsigned_ ## NAME ## _type_node \
2460 : NAME ## _type_node; \
2461 if (type1 == long_ ## NAME ## _type_node \
2462 || type1 == unsigned_long_ ## NAME ## _type_node) \
2463 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2464 : long_ ## NAME ## _type_node; \
2465 if (type1 == long_long_ ## NAME ## _type_node \
2466 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2467 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2468 : long_long_ ## NAME ## _type_node;
2470 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
2471 if (type1 == NAME ## _type_node \
2472 || type1 == u ## NAME ## _type_node) \
2473 return unsignedp ? u ## NAME ## _type_node \
2474 : NAME ## _type_node;
2476 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
2477 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2478 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2479 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2480 : sat_ ## short_ ## NAME ## _type_node; \
2481 if (type1 == sat_ ## NAME ## _type_node \
2482 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2483 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2484 : sat_ ## NAME ## _type_node; \
2485 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2486 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2487 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2488 : sat_ ## long_ ## NAME ## _type_node; \
2489 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2490 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2491 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2492 : sat_ ## long_long_ ## NAME ## _type_node;
2494 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
2495 if (type1 == sat_ ## NAME ## _type_node \
2496 || type1 == sat_ ## u ## NAME ## _type_node) \
2497 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2498 : sat_ ## NAME ## _type_node;
2500 C_COMMON_FIXED_TYPES (fract
);
2501 C_COMMON_FIXED_TYPES_SAT (fract
);
2502 C_COMMON_FIXED_TYPES (accum
);
2503 C_COMMON_FIXED_TYPES_SAT (accum
);
2505 C_COMMON_FIXED_MODE_TYPES (qq
);
2506 C_COMMON_FIXED_MODE_TYPES (hq
);
2507 C_COMMON_FIXED_MODE_TYPES (sq
);
2508 C_COMMON_FIXED_MODE_TYPES (dq
);
2509 C_COMMON_FIXED_MODE_TYPES (tq
);
2510 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
2511 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
2512 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
2513 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
2514 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
2515 C_COMMON_FIXED_MODE_TYPES (ha
);
2516 C_COMMON_FIXED_MODE_TYPES (sa
);
2517 C_COMMON_FIXED_MODE_TYPES (da
);
2518 C_COMMON_FIXED_MODE_TYPES (ta
);
2519 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
2520 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
2521 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
2522 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
2524 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2525 the precision; they have precision set to match their range, but
2526 may use a wider mode to match an ABI. If we change modes, we may
2527 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2528 the precision as well, so as to yield correct results for
2529 bit-field types. C++ does not have these separate bit-field
2530 types, and producing a signed or unsigned variant of an
2531 ENUMERAL_TYPE may cause other problems as well. */
2533 if (!INTEGRAL_TYPE_P (type
)
2534 || TYPE_UNSIGNED (type
) == unsignedp
)
2537 #define TYPE_OK(node) \
2538 (TYPE_MODE (type) == TYPE_MODE (node) \
2539 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2540 if (TYPE_OK (signed_char_type_node
))
2541 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2542 if (TYPE_OK (integer_type_node
))
2543 return unsignedp
? unsigned_type_node
: integer_type_node
;
2544 if (TYPE_OK (short_integer_type_node
))
2545 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2546 if (TYPE_OK (long_integer_type_node
))
2547 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2548 if (TYPE_OK (long_long_integer_type_node
))
2549 return (unsignedp
? long_long_unsigned_type_node
2550 : long_long_integer_type_node
);
2552 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2553 if (int_n_enabled_p
[i
]
2554 && TYPE_MODE (type
) == int_n_data
[i
].m
2555 && TYPE_PRECISION (type
) == int_n_data
[i
].bitsize
)
2556 return (unsignedp
? int_n_trees
[i
].unsigned_type
2557 : int_n_trees
[i
].signed_type
);
2559 #if HOST_BITS_PER_WIDE_INT >= 64
2560 if (TYPE_OK (intTI_type_node
))
2561 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2563 if (TYPE_OK (intDI_type_node
))
2564 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2565 if (TYPE_OK (intSI_type_node
))
2566 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2567 if (TYPE_OK (intHI_type_node
))
2568 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2569 if (TYPE_OK (intQI_type_node
))
2570 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2573 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2576 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2579 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
2583 /* Extended integer types of the same width as a standard type have
2584 lesser rank, so those of the same width as int promote to int or
2585 unsigned int and are valid for printf formats expecting int or
2586 unsigned int. To avoid such special cases, avoid creating
2587 extended integer types for bit-fields if a standard integer type
2589 if (width
== TYPE_PRECISION (integer_type_node
))
2590 return unsignedp
? unsigned_type_node
: integer_type_node
;
2591 if (width
== TYPE_PRECISION (signed_char_type_node
))
2592 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2593 if (width
== TYPE_PRECISION (short_integer_type_node
))
2594 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2595 if (width
== TYPE_PRECISION (long_integer_type_node
))
2596 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2597 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
2598 return (unsignedp
? long_long_unsigned_type_node
2599 : long_long_integer_type_node
);
2600 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2601 if (int_n_enabled_p
[i
]
2602 && width
== int_n_data
[i
].bitsize
)
2603 return (unsignedp
? int_n_trees
[i
].unsigned_type
2604 : int_n_trees
[i
].signed_type
);
2605 return build_nonstandard_integer_type (width
, unsignedp
);
2608 /* The C version of the register_builtin_type langhook. */
2611 c_register_builtin_type (tree type
, const char* name
)
2615 decl
= build_decl (UNKNOWN_LOCATION
,
2616 TYPE_DECL
, get_identifier (name
), type
);
2617 DECL_ARTIFICIAL (decl
) = 1;
2618 if (!TYPE_NAME (type
))
2619 TYPE_NAME (type
) = decl
;
2620 lang_hooks
.decls
.pushdecl (decl
);
2622 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
2625 /* Print an error message for invalid operands to arith operation
2626 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
2627 RICHLOC is a rich location for the message, containing either
2628 three separate locations for each of the operator and operands
2633 (C FE), or one location ranging over all over them
2641 binary_op_error (rich_location
*richloc
, enum tree_code code
,
2642 tree type0
, tree type1
)
2649 opname
= "+"; break;
2651 opname
= "-"; break;
2653 opname
= "*"; break;
2655 opname
= "max"; break;
2657 opname
= "min"; break;
2659 opname
= "=="; break;
2661 opname
= "!="; break;
2663 opname
= "<="; break;
2665 opname
= ">="; break;
2667 opname
= "<"; break;
2669 opname
= ">"; break;
2671 opname
= "<<"; break;
2673 opname
= ">>"; break;
2674 case TRUNC_MOD_EXPR
:
2675 case FLOOR_MOD_EXPR
:
2676 opname
= "%"; break;
2677 case TRUNC_DIV_EXPR
:
2678 case FLOOR_DIV_EXPR
:
2679 opname
= "/"; break;
2681 opname
= "&"; break;
2683 opname
= "|"; break;
2684 case TRUTH_ANDIF_EXPR
:
2685 opname
= "&&"; break;
2686 case TRUTH_ORIF_EXPR
:
2687 opname
= "||"; break;
2689 opname
= "^"; break;
2694 "invalid operands to binary %s (have %qT and %qT)",
2695 opname
, type0
, type1
);
2698 /* Given an expression as a tree, return its original type. Do this
2699 by stripping any conversion that preserves the sign and precision. */
2701 expr_original_type (tree expr
)
2703 STRIP_SIGN_NOPS (expr
);
2704 return TREE_TYPE (expr
);
2707 /* Subroutine of build_binary_op, used for comparison operations.
2708 See if the operands have both been converted from subword integer types
2709 and, if so, perhaps change them both back to their original type.
2710 This function is also responsible for converting the two operands
2711 to the proper common type for comparison.
2713 The arguments of this function are all pointers to local variables
2714 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2715 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2717 LOC is the location of the comparison.
2719 If this function returns non-NULL_TREE, it means that the comparison has
2720 a constant value. What this function returns is an expression for
2724 shorten_compare (location_t loc
, tree
*op0_ptr
, tree
*op1_ptr
,
2725 tree
*restype_ptr
, enum tree_code
*rescode_ptr
)
2728 tree op0
= *op0_ptr
;
2729 tree op1
= *op1_ptr
;
2730 int unsignedp0
, unsignedp1
;
2732 tree primop0
, primop1
;
2733 enum tree_code code
= *rescode_ptr
;
2735 /* Throw away any conversions to wider types
2736 already present in the operands. */
2738 primop0
= c_common_get_narrower (op0
, &unsignedp0
);
2739 primop1
= c_common_get_narrower (op1
, &unsignedp1
);
2741 /* If primopN is first sign-extended from primopN's precision to opN's
2742 precision, then zero-extended from opN's precision to
2743 *restype_ptr precision, shortenings might be invalid. */
2744 if (TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (TREE_TYPE (op0
))
2745 && TYPE_PRECISION (TREE_TYPE (op0
)) < TYPE_PRECISION (*restype_ptr
)
2747 && TYPE_UNSIGNED (TREE_TYPE (op0
)))
2749 if (TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (TREE_TYPE (op1
))
2750 && TYPE_PRECISION (TREE_TYPE (op1
)) < TYPE_PRECISION (*restype_ptr
)
2752 && TYPE_UNSIGNED (TREE_TYPE (op1
)))
2755 /* Handle the case that OP0 does not *contain* a conversion
2756 but it *requires* conversion to FINAL_TYPE. */
2758 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2759 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2760 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2761 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2763 /* If one of the operands must be floated, we cannot optimize. */
2764 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2765 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2767 /* If first arg is constant, swap the args (changing operation
2768 so value is preserved), for canonicalization. Don't do this if
2769 the second arg is 0. */
2771 if (TREE_CONSTANT (primop0
)
2772 && !integer_zerop (primop1
) && !real_zerop (primop1
)
2773 && !fixed_zerop (primop1
))
2775 std::swap (primop0
, primop1
);
2776 std::swap (op0
, op1
);
2779 std::swap (unsignedp0
, unsignedp1
);
2780 std::swap (real1
, real2
);
2799 *rescode_ptr
= code
;
2802 /* If comparing an integer against a constant more bits wide,
2803 maybe we can deduce a value of 1 or 0 independent of the data.
2804 Or else truncate the constant now
2805 rather than extend the variable at run time.
2807 This is only interesting if the constant is the wider arg.
2808 Also, it is not safe if the constant is unsigned and the
2809 variable arg is signed, since in this case the variable
2810 would be sign-extended and then regarded as unsigned.
2811 Our technique fails in this case because the lowest/highest
2812 possible unsigned results don't follow naturally from the
2813 lowest/highest possible values of the variable operand.
2814 For just EQ_EXPR and NE_EXPR there is another technique that
2815 could be used: see if the constant can be faithfully represented
2816 in the other operand's type, by truncating it and reextending it
2817 and see if that preserves the constant's value. */
2819 if (!real1
&& !real2
2820 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
2821 && TREE_CODE (primop1
) == INTEGER_CST
2822 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2824 int min_gt
, max_gt
, min_lt
, max_lt
;
2825 tree maxval
, minval
;
2826 /* 1 if comparison is nominally unsigned. */
2827 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
2830 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2831 TREE_TYPE (primop0
));
2833 maxval
= TYPE_MAX_VALUE (type
);
2834 minval
= TYPE_MIN_VALUE (type
);
2836 if (unsignedp
&& !unsignedp0
)
2837 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2839 if (TREE_TYPE (primop1
) != *restype_ptr
)
2841 /* Convert primop1 to target type, but do not introduce
2842 additional overflow. We know primop1 is an int_cst. */
2843 primop1
= force_fit_type (*restype_ptr
,
2846 TYPE_PRECISION (*restype_ptr
)),
2847 0, TREE_OVERFLOW (primop1
));
2849 if (type
!= *restype_ptr
)
2851 minval
= convert (*restype_ptr
, minval
);
2852 maxval
= convert (*restype_ptr
, maxval
);
2855 min_gt
= tree_int_cst_lt (primop1
, minval
);
2856 max_gt
= tree_int_cst_lt (primop1
, maxval
);
2857 min_lt
= tree_int_cst_lt (minval
, primop1
);
2858 max_lt
= tree_int_cst_lt (maxval
, primop1
);
2861 /* This used to be a switch, but Genix compiler can't handle that. */
2862 if (code
== NE_EXPR
)
2864 if (max_lt
|| min_gt
)
2865 val
= truthvalue_true_node
;
2867 else if (code
== EQ_EXPR
)
2869 if (max_lt
|| min_gt
)
2870 val
= truthvalue_false_node
;
2872 else if (code
== LT_EXPR
)
2875 val
= truthvalue_true_node
;
2877 val
= truthvalue_false_node
;
2879 else if (code
== GT_EXPR
)
2882 val
= truthvalue_true_node
;
2884 val
= truthvalue_false_node
;
2886 else if (code
== LE_EXPR
)
2889 val
= truthvalue_true_node
;
2891 val
= truthvalue_false_node
;
2893 else if (code
== GE_EXPR
)
2896 val
= truthvalue_true_node
;
2898 val
= truthvalue_false_node
;
2901 /* If primop0 was sign-extended and unsigned comparison specd,
2902 we did a signed comparison above using the signed type bounds.
2903 But the comparison we output must be unsigned.
2905 Also, for inequalities, VAL is no good; but if the signed
2906 comparison had *any* fixed result, it follows that the
2907 unsigned comparison just tests the sign in reverse
2908 (positive values are LE, negative ones GE).
2909 So we can generate an unsigned comparison
2910 against an extreme value of the signed type. */
2912 if (unsignedp
&& !unsignedp0
)
2919 primop1
= TYPE_MIN_VALUE (type
);
2925 primop1
= TYPE_MAX_VALUE (type
);
2932 type
= c_common_unsigned_type (type
);
2935 if (TREE_CODE (primop0
) != INTEGER_CST
2936 /* Don't warn if it's from a (non-system) macro. */
2937 && !(from_macro_expansion_at
2938 (expansion_point_location_if_in_system_header
2939 (EXPR_LOCATION (primop0
)))))
2941 if (val
== truthvalue_false_node
)
2942 warning_at (loc
, OPT_Wtype_limits
,
2943 "comparison is always false due to limited range of data type");
2944 if (val
== truthvalue_true_node
)
2945 warning_at (loc
, OPT_Wtype_limits
,
2946 "comparison is always true due to limited range of data type");
2951 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2952 if (TREE_SIDE_EFFECTS (primop0
))
2953 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2957 /* Value is not predetermined, but do the comparison
2958 in the type of the operand that is not constant.
2959 TYPE is already properly set. */
2962 /* If either arg is decimal float and the other is float, find the
2963 proper common type to use for comparison. */
2964 else if (real1
&& real2
2965 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
2966 && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
))))
2967 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2969 /* If either arg is decimal float and the other is float, fail. */
2970 else if (real1
&& real2
2971 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
2972 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
2975 else if (real1
&& real2
2976 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2977 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2978 type
= TREE_TYPE (primop0
);
2980 /* If args' natural types are both narrower than nominal type
2981 and both extend in the same manner, compare them
2982 in the type of the wider arg.
2983 Otherwise must actually extend both to the nominal
2984 common type lest different ways of extending
2986 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2988 else if (unsignedp0
== unsignedp1
&& real1
== real2
2989 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2990 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2992 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2993 type
= c_common_signed_or_unsigned_type (unsignedp0
2994 || TYPE_UNSIGNED (*restype_ptr
),
2996 /* Make sure shorter operand is extended the right way
2997 to match the longer operand. */
2999 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
3000 TREE_TYPE (primop0
)),
3003 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
3004 TREE_TYPE (primop1
)),
3009 /* Here we must do the comparison on the nominal type
3010 using the args exactly as we received them. */
3011 type
= *restype_ptr
;
3015 if (!real1
&& !real2
&& integer_zerop (primop1
)
3016 && TYPE_UNSIGNED (*restype_ptr
))
3018 tree value
= NULL_TREE
;
3019 /* All unsigned values are >= 0, so we warn. However,
3020 if OP0 is a constant that is >= 0, the signedness of
3021 the comparison isn't an issue, so suppress the
3024 warn_type_limits
&& !in_system_header_at (loc
)
3025 && !(TREE_CODE (primop0
) == INTEGER_CST
3026 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3028 /* Do not warn for enumeration types. */
3029 && (TREE_CODE (expr_original_type (primop0
)) != ENUMERAL_TYPE
);
3035 warning_at (loc
, OPT_Wtype_limits
,
3036 "comparison of unsigned expression >= 0 is always true");
3037 value
= truthvalue_true_node
;
3042 warning_at (loc
, OPT_Wtype_limits
,
3043 "comparison of unsigned expression < 0 is always false");
3044 value
= truthvalue_false_node
;
3051 if (value
!= NULL_TREE
)
3053 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3054 if (TREE_SIDE_EFFECTS (primop0
))
3055 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3062 *op0_ptr
= convert (type
, primop0
);
3063 *op1_ptr
= convert (type
, primop1
);
3065 *restype_ptr
= truthvalue_type_node
;
3070 /* Return a tree for the sum or difference (RESULTCODE says which)
3071 of pointer PTROP and integer INTOP. */
3074 pointer_int_sum (location_t loc
, enum tree_code resultcode
,
3075 tree ptrop
, tree intop
, bool complain
)
3079 /* The result is a pointer of the same type that is being added. */
3080 tree result_type
= TREE_TYPE (ptrop
);
3082 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3084 if (complain
&& warn_pointer_arith
)
3085 pedwarn (loc
, OPT_Wpointer_arith
,
3086 "pointer of type %<void *%> used in arithmetic");
3088 return error_mark_node
;
3089 size_exp
= integer_one_node
;
3091 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3093 if (complain
&& warn_pointer_arith
)
3094 pedwarn (loc
, OPT_Wpointer_arith
,
3095 "pointer to a function used in arithmetic");
3097 return error_mark_node
;
3098 size_exp
= integer_one_node
;
3101 size_exp
= size_in_bytes_loc (loc
, TREE_TYPE (result_type
));
3103 /* We are manipulating pointer values, so we don't need to warn
3104 about relying on undefined signed overflow. We disable the
3105 warning here because we use integer types so fold won't know that
3106 they are really pointers. */
3107 fold_defer_overflow_warnings ();
3109 /* If what we are about to multiply by the size of the elements
3110 contains a constant term, apply distributive law
3111 and multiply that constant term separately.
3112 This helps produce common subexpressions. */
3113 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3114 && !TREE_CONSTANT (intop
)
3115 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3116 && TREE_CONSTANT (size_exp
)
3117 /* If the constant comes from pointer subtraction,
3118 skip this optimization--it would cause an error. */
3119 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
3120 /* If the constant is unsigned, and smaller than the pointer size,
3121 then we must skip this optimization. This is because it could cause
3122 an overflow error if the constant is negative but INTOP is not. */
3123 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
3124 || (TYPE_PRECISION (TREE_TYPE (intop
))
3125 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
3127 enum tree_code subcode
= resultcode
;
3128 tree int_type
= TREE_TYPE (intop
);
3129 if (TREE_CODE (intop
) == MINUS_EXPR
)
3130 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3131 /* Convert both subexpression types to the type of intop,
3132 because weird cases involving pointer arithmetic
3133 can result in a sum or difference with different type args. */
3134 ptrop
= build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop
, 1)),
3136 convert (int_type
, TREE_OPERAND (intop
, 1)),
3138 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
3141 /* Convert the integer argument to a type the same size as sizetype
3142 so the multiply won't overflow spuriously. */
3143 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
3144 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
3145 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
3146 TYPE_UNSIGNED (sizetype
)), intop
);
3148 /* Replace the integer argument with a suitable product by the object size.
3149 Do this multiplication as signed, then convert to the appropriate type
3150 for the pointer operation and disregard an overflow that occurred only
3151 because of the sign-extension change in the latter conversion. */
3153 tree t
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (intop
), intop
,
3154 convert (TREE_TYPE (intop
), size_exp
));
3155 intop
= convert (sizetype
, t
);
3156 if (TREE_OVERFLOW_P (intop
) && !TREE_OVERFLOW (t
))
3157 intop
= wide_int_to_tree (TREE_TYPE (intop
), wi::to_wide (intop
));
3160 /* Create the sum or difference. */
3161 if (resultcode
== MINUS_EXPR
)
3162 intop
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, intop
);
3164 ret
= fold_build_pointer_plus_loc (loc
, ptrop
, intop
);
3166 fold_undefer_and_ignore_overflow_warnings ();
3171 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3172 and if NON_CONST is known not to be permitted in an evaluated part
3173 of a constant expression. */
3176 c_wrap_maybe_const (tree expr
, bool non_const
)
3178 bool nowarning
= TREE_NO_WARNING (expr
);
3179 location_t loc
= EXPR_LOCATION (expr
);
3181 /* This should never be called for C++. */
3182 if (c_dialect_cxx ())
3185 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3186 STRIP_TYPE_NOPS (expr
);
3187 expr
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL
, expr
);
3188 C_MAYBE_CONST_EXPR_NON_CONST (expr
) = non_const
;
3190 TREE_NO_WARNING (expr
) = 1;
3191 protected_set_expr_location (expr
, loc
);
3196 /* Return whether EXPR is a declaration whose address can never be
3200 decl_with_nonnull_addr_p (const_tree expr
)
3202 return (DECL_P (expr
)
3203 && (TREE_CODE (expr
) == PARM_DECL
3204 || TREE_CODE (expr
) == LABEL_DECL
3205 || !DECL_WEAK (expr
)));
3208 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3209 or for an `if' or `while' statement or ?..: exp. It should already
3210 have been validated to be of suitable type; otherwise, a bad
3211 diagnostic may result.
3213 The EXPR is located at LOCATION.
3215 This preparation consists of taking the ordinary
3216 representation of an expression expr and producing a valid tree
3217 boolean expression describing whether expr is nonzero. We could
3218 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3219 but we optimize comparisons, &&, ||, and !.
3221 The resulting type should always be `truthvalue_type_node'. */
3224 c_common_truthvalue_conversion (location_t location
, tree expr
)
3226 switch (TREE_CODE (expr
))
3228 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
3229 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3230 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
3231 case ORDERED_EXPR
: case UNORDERED_EXPR
:
3232 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3234 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3235 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
3238 case TRUTH_ANDIF_EXPR
:
3239 case TRUTH_ORIF_EXPR
:
3240 case TRUTH_AND_EXPR
:
3242 case TRUTH_XOR_EXPR
:
3243 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3245 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3246 c_common_truthvalue_conversion (location
,
3247 TREE_OPERAND (expr
, 0)),
3248 c_common_truthvalue_conversion (location
,
3249 TREE_OPERAND (expr
, 1)));
3252 case TRUTH_NOT_EXPR
:
3253 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3255 expr
= build1 (TREE_CODE (expr
), truthvalue_type_node
,
3256 c_common_truthvalue_conversion (location
,
3257 TREE_OPERAND (expr
, 0)));
3264 if (TREE_CODE (TREE_TYPE (expr
)) == ENUMERAL_TYPE
3265 && !integer_zerop (expr
)
3266 && !integer_onep (expr
))
3267 warning_at (location
, OPT_Wint_in_bool_context
,
3268 "enum constant in boolean context");
3269 return integer_zerop (expr
) ? truthvalue_false_node
3270 : truthvalue_true_node
;
3273 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3274 ? truthvalue_true_node
3275 : truthvalue_false_node
;
3278 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3279 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3280 ? truthvalue_true_node
3281 : truthvalue_false_node
;
3284 expr
= build_unary_op (location
, ADDR_EXPR
, expr
, false);
3289 tree inner
= TREE_OPERAND (expr
, 0);
3290 if (decl_with_nonnull_addr_p (inner
))
3292 /* Common Ada/Pascal programmer's mistake. */
3293 warning_at (location
,
3295 "the address of %qD will always evaluate as %<true%>",
3297 return truthvalue_true_node
;
3303 expr
= build_binary_op (EXPR_LOCATION (expr
),
3304 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3305 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3306 c_common_truthvalue_conversion (location
,
3307 TREE_OPERAND (expr
, 0)),
3308 c_common_truthvalue_conversion (location
,
3309 TREE_OPERAND (expr
, 1)),
3316 case EXCESS_PRECISION_EXPR
:
3317 /* These don't change whether an object is nonzero or zero. */
3318 return c_common_truthvalue_conversion (location
, TREE_OPERAND (expr
, 0));
3322 /* These don't change whether an object is zero or nonzero, but
3323 we can't ignore them if their second arg has side-effects. */
3324 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3326 expr
= build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3327 TREE_OPERAND (expr
, 1),
3328 c_common_truthvalue_conversion
3329 (location
, TREE_OPERAND (expr
, 0)));
3333 return c_common_truthvalue_conversion (location
,
3334 TREE_OPERAND (expr
, 0));
3337 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3338 "%<*%> in boolean context, suggest %<&&%> instead");
3342 /* We will only warn on signed shifts here, because the majority of
3343 false positive warnings happen in code where unsigned arithmetic
3344 was used in anticipation of a possible overflow.
3345 Furthermore, if we see an unsigned type here we know that the
3346 result of the shift is not subject to integer promotion rules. */
3347 if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
3348 && !TYPE_UNSIGNED (TREE_TYPE (expr
)))
3349 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3350 "%<<<%> in boolean context, did you mean %<<%> ?");
3354 if (warn_int_in_bool_context
3355 && !from_macro_definition_at (EXPR_LOCATION (expr
)))
3357 tree val1
= fold_for_warn (TREE_OPERAND (expr
, 1));
3358 tree val2
= fold_for_warn (TREE_OPERAND (expr
, 2));
3359 if (TREE_CODE (val1
) == INTEGER_CST
3360 && TREE_CODE (val2
) == INTEGER_CST
3361 && !integer_zerop (val1
)
3362 && !integer_zerop (val2
)
3363 && (!integer_onep (val1
)
3364 || !integer_onep (val2
)))
3365 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3366 "?: using integer constants in boolean context, "
3367 "the expression will always evaluate to %<true%>");
3368 else if ((TREE_CODE (val1
) == INTEGER_CST
3369 && !integer_zerop (val1
)
3370 && !integer_onep (val1
))
3371 || (TREE_CODE (val2
) == INTEGER_CST
3372 && !integer_zerop (val2
)
3373 && !integer_onep (val2
)))
3374 warning_at (EXPR_LOCATION (expr
), OPT_Wint_in_bool_context
,
3375 "?: using integer constants in boolean context");
3377 /* Distribute the conversion into the arms of a COND_EXPR. */
3378 if (c_dialect_cxx ())
3379 /* Avoid premature folding. */
3383 int w
= warn_int_in_bool_context
;
3384 warn_int_in_bool_context
= 0;
3385 /* Folding will happen later for C. */
3386 expr
= build3 (COND_EXPR
, truthvalue_type_node
,
3387 TREE_OPERAND (expr
, 0),
3388 c_common_truthvalue_conversion (location
,
3389 TREE_OPERAND (expr
, 1)),
3390 c_common_truthvalue_conversion (location
,
3391 TREE_OPERAND (expr
, 2)));
3392 warn_int_in_bool_context
= w
;
3398 tree totype
= TREE_TYPE (expr
);
3399 tree fromtype
= TREE_TYPE (TREE_OPERAND (expr
, 0));
3401 if (POINTER_TYPE_P (totype
)
3402 && !c_inhibit_evaluation_warnings
3403 && TREE_CODE (fromtype
) == REFERENCE_TYPE
)
3409 warning_at (location
,
3411 "the compiler can assume that the address of "
3412 "%qD will always evaluate to %<true%>",
3416 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3417 since that affects how `default_conversion' will behave. */
3418 if (TREE_CODE (totype
) == REFERENCE_TYPE
3419 || TREE_CODE (fromtype
) == REFERENCE_TYPE
)
3421 /* Don't strip a conversion from C++0x scoped enum, since they
3422 don't implicitly convert to other types. */
3423 if (TREE_CODE (fromtype
) == ENUMERAL_TYPE
3424 && ENUM_IS_SCOPED (fromtype
))
3426 /* If this isn't narrowing the argument, we can ignore it. */
3427 if (TYPE_PRECISION (totype
) >= TYPE_PRECISION (fromtype
))
3428 return c_common_truthvalue_conversion (location
,
3429 TREE_OPERAND (expr
, 0));
3434 if (!TREE_NO_WARNING (expr
)
3435 && warn_parentheses
)
3437 warning_at (location
, OPT_Wparentheses
,
3438 "suggest parentheses around assignment used as "
3440 TREE_NO_WARNING (expr
) = 1;
3448 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
3450 tree t
= save_expr (expr
);
3451 expr
= (build_binary_op
3452 (EXPR_LOCATION (expr
),
3453 (TREE_SIDE_EFFECTS (expr
)
3454 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3455 c_common_truthvalue_conversion
3457 build_unary_op (location
, REALPART_EXPR
, t
, false)),
3458 c_common_truthvalue_conversion
3460 build_unary_op (location
, IMAGPART_EXPR
, t
, false)),
3465 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
3467 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
3469 (TREE_TYPE (expr
))));
3470 return build_binary_op (location
, NE_EXPR
, expr
, fixed_zero_node
, true);
3473 return build_binary_op (location
, NE_EXPR
, expr
, integer_zero_node
, true);
3476 protected_set_expr_location (expr
, location
);
3480 static void def_builtin_1 (enum built_in_function fncode
,
3482 enum built_in_class fnclass
,
3483 tree fntype
, tree libtype
,
3484 bool both_p
, bool fallback_p
, bool nonansi_p
,
3485 tree fnattrs
, bool implicit_p
);
3488 /* Apply the TYPE_QUALS to the new DECL. */
3491 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
3493 tree type
= TREE_TYPE (decl
);
3495 if (type
== error_mark_node
)
3498 if ((type_quals
& TYPE_QUAL_CONST
)
3499 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
3500 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
3501 constructor can produce constant init, so rely on cp_finish_decl to
3502 clear TREE_READONLY if the variable has non-constant init. */
3503 TREE_READONLY (decl
) = 1;
3504 if (type_quals
& TYPE_QUAL_VOLATILE
)
3506 TREE_SIDE_EFFECTS (decl
) = 1;
3507 TREE_THIS_VOLATILE (decl
) = 1;
3509 if (type_quals
& TYPE_QUAL_RESTRICT
)
3511 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
3512 /* Allow 'restrict' on arrays of pointers.
3513 FIXME currently we just ignore it. */
3514 type
= TREE_TYPE (type
);
3516 || !POINTER_TYPE_P (type
)
3517 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
3518 error ("invalid use of %<restrict%>");
3522 /* Return the typed-based alias set for T, which may be an expression
3523 or a type. Return -1 if we don't do anything special. */
3526 c_common_get_alias_set (tree t
)
3528 /* For VLAs, use the alias set of the element type rather than the
3529 default of alias set 0 for types compared structurally. */
3530 if (TYPE_P (t
) && TYPE_STRUCTURAL_EQUALITY_P (t
))
3532 if (TREE_CODE (t
) == ARRAY_TYPE
)
3533 return get_alias_set (TREE_TYPE (t
));
3537 /* That's all the expressions we handle specially. */
3541 /* The C standard guarantees that any object may be accessed via an
3542 lvalue that has character type. */
3543 if (t
== char_type_node
3544 || t
== signed_char_type_node
3545 || t
== unsigned_char_type_node
)
3548 /* The C standard specifically allows aliasing between signed and
3549 unsigned variants of the same type. We treat the signed
3550 variant as canonical. */
3551 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
3553 tree t1
= c_common_signed_type (t
);
3555 /* t1 == t can happen for boolean nodes which are always unsigned. */
3557 return get_alias_set (t1
);
3563 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
3564 the IS_SIZEOF parameter indicates which operator is being applied.
3565 The COMPLAIN flag controls whether we should diagnose possibly
3566 ill-formed constructs or not. LOC is the location of the SIZEOF or
3567 TYPEOF operator. If MIN_ALIGNOF, the least alignment required for
3568 a type in any context should be returned, rather than the normal
3569 alignment for that type. */
3572 c_sizeof_or_alignof_type (location_t loc
,
3573 tree type
, bool is_sizeof
, bool min_alignof
,
3576 const char *op_name
;
3578 enum tree_code type_code
= TREE_CODE (type
);
3580 op_name
= is_sizeof
? "sizeof" : "__alignof__";
3582 if (type_code
== FUNCTION_TYPE
)
3586 if (complain
&& warn_pointer_arith
)
3587 pedwarn (loc
, OPT_Wpointer_arith
,
3588 "invalid application of %<sizeof%> to a function type");
3590 return error_mark_node
;
3591 value
= size_one_node
;
3597 if (c_dialect_cxx ())
3598 pedwarn (loc
, OPT_Wpedantic
, "ISO C++ does not permit "
3599 "%<alignof%> applied to a function type");
3601 pedwarn (loc
, OPT_Wpedantic
, "ISO C does not permit "
3602 "%<_Alignof%> applied to a function type");
3604 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3607 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3609 if (type_code
== VOID_TYPE
3610 && complain
&& warn_pointer_arith
)
3611 pedwarn (loc
, OPT_Wpointer_arith
,
3612 "invalid application of %qs to a void type", op_name
);
3614 return error_mark_node
;
3615 value
= size_one_node
;
3617 else if (!COMPLETE_TYPE_P (type
)
3618 && (!c_dialect_cxx () || is_sizeof
|| type_code
!= ARRAY_TYPE
))
3621 error_at (loc
, "invalid application of %qs to incomplete type %qT",
3623 return error_mark_node
;
3625 else if (c_dialect_cxx () && type_code
== ARRAY_TYPE
3626 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
3629 error_at (loc
, "invalid application of %qs to array type %qT of "
3630 "incomplete element type", op_name
, type
);
3631 return error_mark_node
;
3636 /* Convert in case a char is more than one unit. */
3637 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3638 size_int (TYPE_PRECISION (char_type_node
)
3640 else if (min_alignof
)
3641 value
= size_int (min_align_of_type (type
));
3643 value
= size_int (TYPE_ALIGN_UNIT (type
));
3646 /* VALUE will have the middle-end integer type sizetype.
3647 However, we should really return a value of type `size_t',
3648 which is just a typedef for an ordinary integer type. */
3649 value
= fold_convert_loc (loc
, size_type_node
, value
);
3654 /* Implement the __alignof keyword: Return the minimum required
3655 alignment of EXPR, measured in bytes. For VAR_DECLs,
3656 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3657 from an "aligned" __attribute__ specification). LOC is the
3658 location of the ALIGNOF operator. */
3661 c_alignof_expr (location_t loc
, tree expr
)
3665 if (VAR_OR_FUNCTION_DECL_P (expr
))
3666 t
= size_int (DECL_ALIGN_UNIT (expr
));
3668 else if (TREE_CODE (expr
) == COMPONENT_REF
3669 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3671 error_at (loc
, "%<__alignof%> applied to a bit-field");
3674 else if (TREE_CODE (expr
) == COMPONENT_REF
3675 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3676 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
3678 else if (INDIRECT_REF_P (expr
))
3680 tree t
= TREE_OPERAND (expr
, 0);
3682 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3684 while (CONVERT_EXPR_P (t
)
3685 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3689 t
= TREE_OPERAND (t
, 0);
3690 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3691 if (thisalign
> bestalign
)
3692 best
= t
, bestalign
= thisalign
;
3694 return c_alignof (loc
, TREE_TYPE (TREE_TYPE (best
)));
3697 return c_alignof (loc
, TREE_TYPE (expr
));
3699 return fold_convert_loc (loc
, size_type_node
, t
);
3702 /* Handle C and C++ default attributes. */
3704 enum built_in_attribute
3706 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3707 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3708 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
3709 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3710 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3711 #include "builtin-attrs.def"
3712 #undef DEF_ATTR_NULL_TREE
3714 #undef DEF_ATTR_STRING
3715 #undef DEF_ATTR_IDENT
3716 #undef DEF_ATTR_TREE_LIST
3720 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3722 static void c_init_attributes (void);
3726 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3727 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3728 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3729 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3730 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3731 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3732 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3733 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3735 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3737 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3738 ARG6, ARG7, ARG8) NAME,
3739 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3740 ARG6, ARG7, ARG8, ARG9) NAME,
3741 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3742 ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
3743 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3744 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
3745 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3746 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3747 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3748 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3749 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3750 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3752 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3754 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3756 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3757 #include "builtin-types.def"
3758 #undef DEF_PRIMITIVE_TYPE
3759 #undef DEF_FUNCTION_TYPE_0
3760 #undef DEF_FUNCTION_TYPE_1
3761 #undef DEF_FUNCTION_TYPE_2
3762 #undef DEF_FUNCTION_TYPE_3
3763 #undef DEF_FUNCTION_TYPE_4
3764 #undef DEF_FUNCTION_TYPE_5
3765 #undef DEF_FUNCTION_TYPE_6
3766 #undef DEF_FUNCTION_TYPE_7
3767 #undef DEF_FUNCTION_TYPE_8
3768 #undef DEF_FUNCTION_TYPE_9
3769 #undef DEF_FUNCTION_TYPE_10
3770 #undef DEF_FUNCTION_TYPE_11
3771 #undef DEF_FUNCTION_TYPE_VAR_0
3772 #undef DEF_FUNCTION_TYPE_VAR_1
3773 #undef DEF_FUNCTION_TYPE_VAR_2
3774 #undef DEF_FUNCTION_TYPE_VAR_3
3775 #undef DEF_FUNCTION_TYPE_VAR_4
3776 #undef DEF_FUNCTION_TYPE_VAR_5
3777 #undef DEF_FUNCTION_TYPE_VAR_6
3778 #undef DEF_FUNCTION_TYPE_VAR_7
3779 #undef DEF_POINTER_TYPE
3783 typedef enum c_builtin_type builtin_type
;
3785 /* A temporary array for c_common_nodes_and_builtins. Used in
3786 communication with def_fn_type. */
3787 static tree builtin_types
[(int) BT_LAST
+ 1];
3789 /* A helper function for c_common_nodes_and_builtins. Build function type
3790 for DEF with return type RET and N arguments. If VAR is true, then the
3791 function should be variadic after those N arguments.
3793 Takes special care not to ICE if any of the types involved are
3794 error_mark_node, which indicates that said type is not in fact available
3795 (see builtin_type_for_size). In which case the function type as a whole
3796 should be error_mark_node. */
3799 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
3802 tree
*args
= XALLOCAVEC (tree
, n
);
3807 for (i
= 0; i
< n
; ++i
)
3809 builtin_type a
= (builtin_type
) va_arg (list
, int);
3810 t
= builtin_types
[a
];
3811 if (t
== error_mark_node
)
3816 t
= builtin_types
[ret
];
3817 if (t
== error_mark_node
)
3820 t
= build_varargs_function_type_array (t
, n
, args
);
3822 t
= build_function_type_array (t
, n
, args
);
3825 builtin_types
[def
] = t
;
3829 /* Build builtin functions common to both C and C++ language
3833 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
3835 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3836 builtin_types[ENUM] = VALUE;
3837 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3838 def_fn_type (ENUM, RETURN, 0, 0);
3839 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3840 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3841 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3842 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3843 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3844 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3845 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3846 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3847 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3848 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3849 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3851 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3852 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3854 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3855 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3857 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
3859 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3860 ARG6, ARG7, ARG8, ARG9) \
3861 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
3863 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3864 ARG6, ARG7, ARG8, ARG9, ARG10) \
3865 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
3866 ARG7, ARG8, ARG9, ARG10);
3867 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3868 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
3869 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
3870 ARG7, ARG8, ARG9, ARG10, ARG11);
3871 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3872 def_fn_type (ENUM, RETURN, 1, 0);
3873 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3874 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3875 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3876 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3877 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3878 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3879 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3880 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3881 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3882 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3883 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3885 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3886 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3888 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3889 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3890 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3892 #include "builtin-types.def"
3894 #undef DEF_PRIMITIVE_TYPE
3895 #undef DEF_FUNCTION_TYPE_0
3896 #undef DEF_FUNCTION_TYPE_1
3897 #undef DEF_FUNCTION_TYPE_2
3898 #undef DEF_FUNCTION_TYPE_3
3899 #undef DEF_FUNCTION_TYPE_4
3900 #undef DEF_FUNCTION_TYPE_5
3901 #undef DEF_FUNCTION_TYPE_6
3902 #undef DEF_FUNCTION_TYPE_7
3903 #undef DEF_FUNCTION_TYPE_8
3904 #undef DEF_FUNCTION_TYPE_9
3905 #undef DEF_FUNCTION_TYPE_10
3906 #undef DEF_FUNCTION_TYPE_11
3907 #undef DEF_FUNCTION_TYPE_VAR_0
3908 #undef DEF_FUNCTION_TYPE_VAR_1
3909 #undef DEF_FUNCTION_TYPE_VAR_2
3910 #undef DEF_FUNCTION_TYPE_VAR_3
3911 #undef DEF_FUNCTION_TYPE_VAR_4
3912 #undef DEF_FUNCTION_TYPE_VAR_5
3913 #undef DEF_FUNCTION_TYPE_VAR_6
3914 #undef DEF_FUNCTION_TYPE_VAR_7
3915 #undef DEF_POINTER_TYPE
3916 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
3918 c_init_attributes ();
3920 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3921 NONANSI_P, ATTRS, IMPLICIT, COND) \
3923 def_builtin_1 (ENUM, NAME, CLASS, \
3924 builtin_types[(int) TYPE], \
3925 builtin_types[(int) LIBTYPE], \
3926 BOTH_P, FALLBACK_P, NONANSI_P, \
3927 built_in_attributes[(int) ATTRS], IMPLICIT);
3928 #include "builtins.def"
3930 targetm
.init_builtins ();
3932 build_common_builtin_nodes ();
3935 /* Like get_identifier, but avoid warnings about null arguments when
3936 the argument may be NULL for targets where GCC lacks stdint.h type
3940 c_get_ident (const char *id
)
3942 return get_identifier (id
);
3945 /* Build tree nodes and builtin functions common to both C and C++ language
3949 c_common_nodes_and_builtins (void)
3951 int char16_type_size
;
3952 int char32_type_size
;
3953 int wchar_type_size
;
3954 tree array_domain_type
;
3955 tree va_list_ref_type_node
;
3956 tree va_list_arg_type_node
;
3959 build_common_tree_nodes (flag_signed_char
);
3961 /* Define `int' and `char' first so that dbx will output them first. */
3962 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
3963 record_builtin_type (RID_CHAR
, "char", char_type_node
);
3965 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3966 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3967 but not C. Are the conditionals here needed? */
3968 if (c_dialect_cxx ())
3969 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
3970 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
3971 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
3972 record_builtin_type (RID_MAX
, "long unsigned int",
3973 long_unsigned_type_node
);
3975 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
3979 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
3980 record_builtin_type ((enum rid
)(RID_FIRST_INT_N
+ i
), name
,
3981 int_n_trees
[i
].signed_type
);
3982 sprintf (name
, "__int%d unsigned", int_n_data
[i
].bitsize
);
3983 record_builtin_type (RID_MAX
, name
, int_n_trees
[i
].unsigned_type
);
3986 if (c_dialect_cxx ())
3987 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
3988 record_builtin_type (RID_MAX
, "long long int",
3989 long_long_integer_type_node
);
3990 record_builtin_type (RID_MAX
, "long long unsigned int",
3991 long_long_unsigned_type_node
);
3992 if (c_dialect_cxx ())
3993 record_builtin_type (RID_MAX
, "long long unsigned",
3994 long_long_unsigned_type_node
);
3995 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
3996 record_builtin_type (RID_MAX
, "short unsigned int",
3997 short_unsigned_type_node
);
3998 if (c_dialect_cxx ())
3999 record_builtin_type (RID_MAX
, "unsigned short",
4000 short_unsigned_type_node
);
4002 /* Define both `signed char' and `unsigned char'. */
4003 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
4004 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
4006 /* These are types that c_common_type_for_size and
4007 c_common_type_for_mode use. */
4008 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4009 TYPE_DECL
, NULL_TREE
,
4011 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4012 TYPE_DECL
, NULL_TREE
,
4014 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4015 TYPE_DECL
, NULL_TREE
,
4017 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4018 TYPE_DECL
, NULL_TREE
,
4020 #if HOST_BITS_PER_WIDE_INT >= 64
4021 /* Note that this is different than the __int128 type that's part of
4022 the generic __intN support. */
4023 if (targetm
.scalar_mode_supported_p (TImode
))
4024 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4026 get_identifier ("__int128_t"),
4029 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4030 TYPE_DECL
, NULL_TREE
,
4031 unsigned_intQI_type_node
));
4032 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4033 TYPE_DECL
, NULL_TREE
,
4034 unsigned_intHI_type_node
));
4035 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4036 TYPE_DECL
, NULL_TREE
,
4037 unsigned_intSI_type_node
));
4038 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4039 TYPE_DECL
, NULL_TREE
,
4040 unsigned_intDI_type_node
));
4041 #if HOST_BITS_PER_WIDE_INT >= 64
4042 if (targetm
.scalar_mode_supported_p (TImode
))
4043 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4045 get_identifier ("__uint128_t"),
4046 unsigned_intTI_type_node
));
4049 /* Create the widest literal types. */
4050 if (targetm
.scalar_mode_supported_p (TImode
))
4052 widest_integer_literal_type_node
= intTI_type_node
;
4053 widest_unsigned_literal_type_node
= unsigned_intTI_type_node
;
4057 widest_integer_literal_type_node
= intDI_type_node
;
4058 widest_unsigned_literal_type_node
= unsigned_intDI_type_node
;
4061 signed_size_type_node
= c_common_signed_type (size_type_node
);
4064 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
4066 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
4067 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
4068 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
4070 if (!c_dialect_cxx ())
4071 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
4072 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
)
4073 record_builtin_type ((enum rid
) (RID_FLOATN_NX_FIRST
+ i
), NULL
,
4074 FLOATN_NX_TYPE_NODE (i
));
4076 /* Only supported decimal floating point extension if the target
4077 actually supports underlying modes. */
4078 if (targetm
.scalar_mode_supported_p (SDmode
)
4079 && targetm
.scalar_mode_supported_p (DDmode
)
4080 && targetm
.scalar_mode_supported_p (TDmode
))
4082 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
4083 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
4084 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
4087 if (targetm
.fixed_point_supported_p ())
4089 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
4090 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
4091 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
4092 record_builtin_type (RID_MAX
, "long long _Fract",
4093 long_long_fract_type_node
);
4094 record_builtin_type (RID_MAX
, "unsigned short _Fract",
4095 unsigned_short_fract_type_node
);
4096 record_builtin_type (RID_MAX
, "unsigned _Fract",
4097 unsigned_fract_type_node
);
4098 record_builtin_type (RID_MAX
, "unsigned long _Fract",
4099 unsigned_long_fract_type_node
);
4100 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
4101 unsigned_long_long_fract_type_node
);
4102 record_builtin_type (RID_MAX
, "_Sat short _Fract",
4103 sat_short_fract_type_node
);
4104 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
4105 record_builtin_type (RID_MAX
, "_Sat long _Fract",
4106 sat_long_fract_type_node
);
4107 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
4108 sat_long_long_fract_type_node
);
4109 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
4110 sat_unsigned_short_fract_type_node
);
4111 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
4112 sat_unsigned_fract_type_node
);
4113 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
4114 sat_unsigned_long_fract_type_node
);
4115 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
4116 sat_unsigned_long_long_fract_type_node
);
4117 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
4118 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
4119 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
4120 record_builtin_type (RID_MAX
, "long long _Accum",
4121 long_long_accum_type_node
);
4122 record_builtin_type (RID_MAX
, "unsigned short _Accum",
4123 unsigned_short_accum_type_node
);
4124 record_builtin_type (RID_MAX
, "unsigned _Accum",
4125 unsigned_accum_type_node
);
4126 record_builtin_type (RID_MAX
, "unsigned long _Accum",
4127 unsigned_long_accum_type_node
);
4128 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
4129 unsigned_long_long_accum_type_node
);
4130 record_builtin_type (RID_MAX
, "_Sat short _Accum",
4131 sat_short_accum_type_node
);
4132 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
4133 record_builtin_type (RID_MAX
, "_Sat long _Accum",
4134 sat_long_accum_type_node
);
4135 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
4136 sat_long_long_accum_type_node
);
4137 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
4138 sat_unsigned_short_accum_type_node
);
4139 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
4140 sat_unsigned_accum_type_node
);
4141 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
4142 sat_unsigned_long_accum_type_node
);
4143 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
4144 sat_unsigned_long_long_accum_type_node
);
4148 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4150 get_identifier ("complex int"),
4151 complex_integer_type_node
));
4152 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4154 get_identifier ("complex float"),
4155 complex_float_type_node
));
4156 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4158 get_identifier ("complex double"),
4159 complex_double_type_node
));
4160 lang_hooks
.decls
.pushdecl
4161 (build_decl (UNKNOWN_LOCATION
,
4162 TYPE_DECL
, get_identifier ("complex long double"),
4163 complex_long_double_type_node
));
4165 if (!c_dialect_cxx ())
4166 for (i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
4167 if (COMPLEX_FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
)
4170 sprintf (buf
, "complex _Float%d%s", floatn_nx_types
[i
].n
,
4171 floatn_nx_types
[i
].extended
? "x" : "");
4172 lang_hooks
.decls
.pushdecl
4173 (build_decl (UNKNOWN_LOCATION
,
4175 get_identifier (buf
),
4176 COMPLEX_FLOATN_NX_TYPE_NODE (i
)));
4179 if (c_dialect_cxx ())
4181 /* For C++, make fileptr_type_node a distinct void * type until
4182 FILE type is defined. Likewise for const struct tm*. */
4183 for (unsigned i
= 0;
4184 i
< sizeof (builtin_structptr_types
)
4185 / sizeof (builtin_structptr_type
);
4187 builtin_structptr_types
[i
].node
=
4188 build_variant_type_copy (builtin_structptr_types
[i
].base
);
4192 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
4194 /* Set the TYPE_NAME for any variants that were built before
4195 record_builtin_type gave names to the built-in types. */
4197 tree void_name
= TYPE_NAME (void_type_node
);
4198 TYPE_NAME (void_type_node
) = NULL_TREE
;
4199 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
4201 TYPE_NAME (void_type_node
) = void_name
;
4204 void_list_node
= build_void_list_node ();
4206 /* Make a type to be the domain of a few array types
4207 whose domains don't really matter.
4208 200 is small enough that it always fits in size_t
4209 and large enough that it can hold most function names for the
4210 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4211 array_domain_type
= build_index_type (size_int (200));
4213 /* Make a type for arrays of characters.
4214 With luck nothing will ever really depend on the length of this
4216 char_array_type_node
4217 = build_array_type (char_type_node
, array_domain_type
);
4219 string_type_node
= build_pointer_type (char_type_node
);
4220 const_string_type_node
4221 = build_pointer_type (build_qualified_type
4222 (char_type_node
, TYPE_QUAL_CONST
));
4224 /* This is special for C++ so functions can be overloaded. */
4225 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
4226 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
4227 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
4228 underlying_wchar_type_node
= wchar_type_node
;
4229 if (c_dialect_cxx ())
4231 if (TYPE_UNSIGNED (wchar_type_node
))
4232 wchar_type_node
= make_unsigned_type (wchar_type_size
);
4234 wchar_type_node
= make_signed_type (wchar_type_size
);
4235 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
4238 /* This is for wide string constants. */
4239 wchar_array_type_node
4240 = build_array_type (wchar_type_node
, array_domain_type
);
4242 /* Define 'char16_t'. */
4243 char16_type_node
= get_identifier (CHAR16_TYPE
);
4244 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
4245 char16_type_size
= TYPE_PRECISION (char16_type_node
);
4246 if (c_dialect_cxx ())
4248 char16_type_node
= make_unsigned_type (char16_type_size
);
4250 if (cxx_dialect
>= cxx11
)
4251 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
4254 /* This is for UTF-16 string constants. */
4255 char16_array_type_node
4256 = build_array_type (char16_type_node
, array_domain_type
);
4258 /* Define 'char32_t'. */
4259 char32_type_node
= get_identifier (CHAR32_TYPE
);
4260 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
4261 char32_type_size
= TYPE_PRECISION (char32_type_node
);
4262 if (c_dialect_cxx ())
4264 char32_type_node
= make_unsigned_type (char32_type_size
);
4266 if (cxx_dialect
>= cxx11
)
4267 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
4270 /* This is for UTF-32 string constants. */
4271 char32_array_type_node
4272 = build_array_type (char32_type_node
, array_domain_type
);
4275 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
4278 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
4280 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
4282 if (SIG_ATOMIC_TYPE
)
4283 sig_atomic_type_node
=
4284 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE
)));
4287 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE
)));
4290 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE
)));
4293 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE
)));
4296 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE
)));
4299 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE
)));
4301 c_uint16_type_node
= uint16_type_node
=
4302 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE
)));
4304 c_uint32_type_node
= uint32_type_node
=
4305 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE
)));
4307 c_uint64_type_node
= uint64_type_node
=
4308 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE
)));
4309 if (INT_LEAST8_TYPE
)
4310 int_least8_type_node
=
4311 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE
)));
4312 if (INT_LEAST16_TYPE
)
4313 int_least16_type_node
=
4314 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE
)));
4315 if (INT_LEAST32_TYPE
)
4316 int_least32_type_node
=
4317 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE
)));
4318 if (INT_LEAST64_TYPE
)
4319 int_least64_type_node
=
4320 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE
)));
4321 if (UINT_LEAST8_TYPE
)
4322 uint_least8_type_node
=
4323 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE
)));
4324 if (UINT_LEAST16_TYPE
)
4325 uint_least16_type_node
=
4326 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE
)));
4327 if (UINT_LEAST32_TYPE
)
4328 uint_least32_type_node
=
4329 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE
)));
4330 if (UINT_LEAST64_TYPE
)
4331 uint_least64_type_node
=
4332 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE
)));
4334 int_fast8_type_node
=
4335 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE
)));
4336 if (INT_FAST16_TYPE
)
4337 int_fast16_type_node
=
4338 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE
)));
4339 if (INT_FAST32_TYPE
)
4340 int_fast32_type_node
=
4341 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE
)));
4342 if (INT_FAST64_TYPE
)
4343 int_fast64_type_node
=
4344 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE
)));
4345 if (UINT_FAST8_TYPE
)
4346 uint_fast8_type_node
=
4347 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE
)));
4348 if (UINT_FAST16_TYPE
)
4349 uint_fast16_type_node
=
4350 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE
)));
4351 if (UINT_FAST32_TYPE
)
4352 uint_fast32_type_node
=
4353 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE
)));
4354 if (UINT_FAST64_TYPE
)
4355 uint_fast64_type_node
=
4356 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE
)));
4359 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE
)));
4362 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE
)));
4364 default_function_type
4365 = build_varargs_function_type_list (integer_type_node
, NULL_TREE
);
4366 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
4368 lang_hooks
.decls
.pushdecl
4369 (build_decl (UNKNOWN_LOCATION
,
4370 TYPE_DECL
, get_identifier ("__builtin_va_list"),
4371 va_list_type_node
));
4372 if (targetm
.enum_va_list_p
)
4378 for (l
= 0; targetm
.enum_va_list_p (l
, &pname
, &ptype
); ++l
)
4380 lang_hooks
.decls
.pushdecl
4381 (build_decl (UNKNOWN_LOCATION
,
4382 TYPE_DECL
, get_identifier (pname
),
4388 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4390 va_list_arg_type_node
= va_list_ref_type_node
=
4391 build_pointer_type (TREE_TYPE (va_list_type_node
));
4395 va_list_arg_type_node
= va_list_type_node
;
4396 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
4399 if (!flag_preprocess_only
)
4400 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
4402 main_identifier_node
= get_identifier ("main");
4404 /* Create the built-in __null node. It is important that this is
4406 null_node
= make_int_cst (1, 1);
4407 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
4409 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4410 memset (builtin_types
, 0, sizeof (builtin_types
));
4413 /* The number of named compound-literals generated thus far. */
4414 static GTY(()) int compound_literal_number
;
4416 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4419 set_compound_literal_name (tree decl
)
4422 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
4423 compound_literal_number
);
4424 compound_literal_number
++;
4425 DECL_NAME (decl
) = get_identifier (name
);
4428 /* build_va_arg helper function. Return a VA_ARG_EXPR with location LOC, type
4429 TYPE and operand OP. */
4432 build_va_arg_1 (location_t loc
, tree type
, tree op
)
4434 tree expr
= build1 (VA_ARG_EXPR
, type
, op
);
4435 SET_EXPR_LOCATION (expr
, loc
);
4439 /* Return a VA_ARG_EXPR corresponding to a source-level expression
4440 va_arg (EXPR, TYPE) at source location LOC. */
4443 build_va_arg (location_t loc
, tree expr
, tree type
)
4445 tree va_type
= TREE_TYPE (expr
);
4446 tree canon_va_type
= (va_type
== error_mark_node
4448 : targetm
.canonical_va_list_type (va_type
));
4450 if (va_type
== error_mark_node
4451 || canon_va_type
== NULL_TREE
)
4453 if (canon_va_type
== NULL_TREE
)
4454 error_at (loc
, "first argument to %<va_arg%> not of type %<va_list%>");
4456 /* Let's handle things neutrallly, if expr:
4457 - has undeclared type, or
4458 - is not an va_list type. */
4459 return build_va_arg_1 (loc
, type
, error_mark_node
);
4462 if (TREE_CODE (canon_va_type
) != ARRAY_TYPE
)
4464 /* Case 1: Not an array type. */
4466 /* Take the address, to get '&ap'. Note that &ap is not a va_list
4468 mark_addressable (expr
);
4469 expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (expr
)), expr
);
4471 return build_va_arg_1 (loc
, type
, expr
);
4474 /* Case 2: Array type.
4478 For contrast, let's start with the simple case (case 1). If
4479 canon_va_type is not an array type, but say a char *, then when
4480 passing-by-value a va_list, the type of the va_list param decl is
4481 the same as for another va_list decl (all ap's are char *):
4484 D.1815 = VA_ARG (&ap, 0B, 1);
4490 __builtin_va_start (&ap, 0);
4493 __builtin_va_end (&ap);
4497 However, if canon_va_type is ARRAY_TYPE, then when passing-by-value a
4498 va_list the type of the va_list param decl (case 2b, struct * ap) is not
4499 the same as for another va_list decl (case 2a, struct ap[1]).
4502 D.1844 = VA_ARG (ap, 0B, 0);
4507 __builtin_va_start (&ap, 0);
4509 __builtin_va_end (&ap);
4513 Case 2b is different because:
4514 - on the callee side, the parm decl has declared type va_list, but
4515 grokdeclarator changes the type of the parm decl to a pointer to the
4517 - on the caller side, the pass-by-value uses &ap.
4519 We unify these two cases (case 2a: va_list is array type,
4520 case 2b: va_list is pointer to array elem type), by adding '&' for the
4521 array type case, such that we have a pointer to array elem in both
4524 if (TREE_CODE (va_type
) == ARRAY_TYPE
)
4526 /* Case 2a: va_list is array type. */
4528 /* Take the address, to get '&ap'. Make sure it's a pointer to array
4530 mark_addressable (expr
);
4531 expr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (canon_va_type
)),
4534 /* Verify that &ap is still recognized as having va_list type. */
4535 tree canon_expr_type
4536 = targetm
.canonical_va_list_type (TREE_TYPE (expr
));
4537 gcc_assert (canon_expr_type
!= NULL_TREE
);
4541 /* Case 2b: va_list is pointer to array elem type. */
4542 gcc_assert (POINTER_TYPE_P (va_type
));
4544 /* Comparison as in std_canonical_va_list_type. */
4545 gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (va_type
))
4546 == TYPE_MAIN_VARIANT (TREE_TYPE (canon_va_type
)));
4548 /* Don't take the address. We've already got '&ap'. */
4552 return build_va_arg_1 (loc
, type
, expr
);
4556 /* Linked list of disabled built-in functions. */
4558 struct disabled_builtin
4561 struct disabled_builtin
*next
;
4563 static disabled_builtin
*disabled_builtins
= NULL
;
4565 static bool builtin_function_disabled_p (const char *);
4567 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4568 begins with "__builtin_", give an error. */
4571 disable_builtin_function (const char *name
)
4573 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
4574 error ("cannot disable built-in function %qs", name
);
4577 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
4578 new_disabled_builtin
->name
= name
;
4579 new_disabled_builtin
->next
= disabled_builtins
;
4580 disabled_builtins
= new_disabled_builtin
;
4585 /* Return true if the built-in function NAME has been disabled, false
4589 builtin_function_disabled_p (const char *name
)
4591 disabled_builtin
*p
;
4592 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
4594 if (strcmp (name
, p
->name
) == 0)
4601 /* Worker for DEF_BUILTIN.
4602 Possibly define a builtin function with one or two names.
4603 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4604 nonansi_p and flag_no_nonansi_builtin. */
4607 def_builtin_1 (enum built_in_function fncode
,
4609 enum built_in_class fnclass
,
4610 tree fntype
, tree libtype
,
4611 bool both_p
, bool fallback_p
, bool nonansi_p
,
4612 tree fnattrs
, bool implicit_p
)
4615 const char *libname
;
4617 if (fntype
== error_mark_node
)
4620 gcc_assert ((!both_p
&& !fallback_p
)
4621 || !strncmp (name
, "__builtin_",
4622 strlen ("__builtin_")));
4624 libname
= name
+ strlen ("__builtin_");
4625 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
4626 (fallback_p
? libname
: NULL
),
4629 set_builtin_decl (fncode
, decl
, implicit_p
);
4632 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
4633 && !(nonansi_p
&& flag_no_nonansi_builtin
))
4634 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
4638 /* Nonzero if the type T promotes to int. This is (nearly) the
4639 integral promotions defined in ISO C99 6.3.1.1/2. */
4642 c_promoting_integer_type_p (const_tree t
)
4644 switch (TREE_CODE (t
))
4647 return (TYPE_MAIN_VARIANT (t
) == char_type_node
4648 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
4649 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
4650 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
4651 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
4652 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
4655 /* ??? Technically all enumerations not larger than an int
4656 promote to an int. But this is used along code paths
4657 that only want to notice a size change. */
4658 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
4668 /* Return 1 if PARMS specifies a fixed number of parameters
4669 and none of their types is affected by default promotions. */
4672 self_promoting_args_p (const_tree parms
)
4675 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
4677 tree type
= TREE_VALUE (t
);
4679 if (type
== error_mark_node
)
4682 if (TREE_CHAIN (t
) == NULL_TREE
&& type
!= void_type_node
)
4685 if (type
== NULL_TREE
)
4688 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
4691 if (c_promoting_integer_type_p (type
))
4697 /* Recursively remove any '*' or '&' operator from TYPE. */
4699 strip_pointer_operator (tree t
)
4701 while (POINTER_TYPE_P (t
))
4706 /* Recursively remove pointer or array type from TYPE. */
4708 strip_pointer_or_array_types (tree t
)
4710 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
4715 /* Used to compare case labels. K1 and K2 are actually tree nodes
4716 representing case labels, or NULL_TREE for a `default' label.
4717 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4718 K2, and 0 if K1 and K2 are equal. */
4721 case_compare (splay_tree_key k1
, splay_tree_key k2
)
4723 /* Consider a NULL key (such as arises with a `default' label) to be
4724 smaller than anything else. */
4730 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4733 /* Process a case label, located at LOC, for the range LOW_VALUE
4734 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
4735 then this case label is actually a `default' label. If only
4736 HIGH_VALUE is NULL_TREE, then case label was declared using the
4737 usual C/C++ syntax, rather than the GNU case range extension.
4738 CASES is a tree containing all the case ranges processed so far;
4739 COND is the condition for the switch-statement itself.
4740 OUTSIDE_RANGE_P says whether there was a case value that doesn't
4741 fit into the range of the ORIG_TYPE. Returns the CASE_LABEL_EXPR
4742 created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
4745 c_add_case_label (location_t loc
, splay_tree cases
, tree cond
, tree orig_type
,
4746 tree low_value
, tree high_value
, bool *outside_range_p
)
4751 splay_tree_node node
;
4753 /* Create the LABEL_DECL itself. */
4754 label
= create_artificial_label (loc
);
4756 /* If there was an error processing the switch condition, bail now
4757 before we get more confused. */
4758 if (!cond
|| cond
== error_mark_node
)
4761 if ((low_value
&& TREE_TYPE (low_value
)
4762 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
4763 || (high_value
&& TREE_TYPE (high_value
)
4764 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
4766 error_at (loc
, "pointers are not permitted as case values");
4770 /* Case ranges are a GNU extension. */
4772 pedwarn (loc
, OPT_Wpedantic
,
4773 "range expressions in switch statements are non-standard");
4775 type
= TREE_TYPE (cond
);
4778 low_value
= check_case_value (loc
, low_value
);
4779 low_value
= convert_and_check (loc
, type
, low_value
);
4780 if (low_value
== error_mark_node
)
4785 high_value
= check_case_value (loc
, high_value
);
4786 high_value
= convert_and_check (loc
, type
, high_value
);
4787 if (high_value
== error_mark_node
)
4791 if (low_value
&& high_value
)
4793 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4794 really a case range, even though it was written that way.
4795 Remove the HIGH_VALUE to simplify later processing. */
4796 if (tree_int_cst_equal (low_value
, high_value
))
4797 high_value
= NULL_TREE
;
4798 else if (!tree_int_cst_lt (low_value
, high_value
))
4799 warning_at (loc
, 0, "empty range specified");
4802 /* See if the case is in range of the type of the original testing
4803 expression. If both low_value and high_value are out of range,
4804 don't insert the case label and return NULL_TREE. */
4806 && !check_case_bounds (loc
, type
, orig_type
,
4807 &low_value
, high_value
? &high_value
: NULL
,
4811 /* Look up the LOW_VALUE in the table of case labels we already
4813 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
4814 /* If there was not an exact match, check for overlapping ranges.
4815 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4816 that's a `default' label and the only overlap is an exact match. */
4817 if (!node
&& (low_value
|| high_value
))
4819 splay_tree_node low_bound
;
4820 splay_tree_node high_bound
;
4822 /* Even though there wasn't an exact match, there might be an
4823 overlap between this case range and another case range.
4824 Since we've (inductively) not allowed any overlapping case
4825 ranges, we simply need to find the greatest low case label
4826 that is smaller that LOW_VALUE, and the smallest low case
4827 label that is greater than LOW_VALUE. If there is an overlap
4828 it will occur in one of these two ranges. */
4829 low_bound
= splay_tree_predecessor (cases
,
4830 (splay_tree_key
) low_value
);
4831 high_bound
= splay_tree_successor (cases
,
4832 (splay_tree_key
) low_value
);
4834 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4835 the LOW_VALUE, so there is no need to check unless the
4836 LOW_BOUND is in fact itself a case range. */
4838 && CASE_HIGH ((tree
) low_bound
->value
)
4839 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
4842 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4843 range is bigger than the low end of the current range, so we
4844 are only interested if the current range is a real range, and
4845 not an ordinary case label. */
4848 && (tree_int_cst_compare ((tree
) high_bound
->key
,
4853 /* If there was an overlap, issue an error. */
4856 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
4860 error_at (loc
, "duplicate (or overlapping) case value");
4861 inform (DECL_SOURCE_LOCATION (duplicate
),
4862 "this is the first entry overlapping that value");
4866 error_at (loc
, "duplicate case value") ;
4867 inform (DECL_SOURCE_LOCATION (duplicate
), "previously used here");
4871 error_at (loc
, "multiple default labels in one switch");
4872 inform (DECL_SOURCE_LOCATION (duplicate
),
4873 "this is the first default label");
4878 /* Add a CASE_LABEL to the statement-tree. */
4879 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
4880 /* Register this case label in the splay tree. */
4881 splay_tree_insert (cases
,
4882 (splay_tree_key
) low_value
,
4883 (splay_tree_value
) case_label
);
4888 /* Add a label so that the back-end doesn't think that the beginning of
4889 the switch is unreachable. Note that we do not add a case label, as
4890 that just leads to duplicates and thence to failure later on. */
4893 tree t
= create_artificial_label (loc
);
4894 add_stmt (build_stmt (loc
, LABEL_EXPR
, t
));
4896 return error_mark_node
;
4899 /* Subroutine of c_switch_covers_all_cases_p, called via
4900 splay_tree_foreach. Return 1 if it doesn't cover all the cases.
4901 ARGS[0] is initially NULL and after the first iteration is the
4902 so far highest case label. ARGS[1] is the minimum of SWITCH_COND's
4906 c_switch_covers_all_cases_p_1 (splay_tree_node node
, void *data
)
4908 tree label
= (tree
) node
->value
;
4909 tree
*args
= (tree
*) data
;
4911 /* If there is a default case, we shouldn't have called this. */
4912 gcc_assert (CASE_LOW (label
));
4914 if (args
[0] == NULL_TREE
)
4916 if (wi::to_widest (args
[1]) < wi::to_widest (CASE_LOW (label
)))
4919 else if (wi::add (wi::to_widest (args
[0]), 1)
4920 != wi::to_widest (CASE_LOW (label
)))
4922 if (CASE_HIGH (label
))
4923 args
[0] = CASE_HIGH (label
);
4925 args
[0] = CASE_LOW (label
);
4929 /* Return true if switch with CASES and switch condition with type
4930 covers all possible values in the case labels. */
4933 c_switch_covers_all_cases_p (splay_tree cases
, tree type
)
4935 /* If there is default:, this is always the case. */
4936 splay_tree_node default_node
4937 = splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
4941 if (!INTEGRAL_TYPE_P (type
))
4944 tree args
[2] = { NULL_TREE
, TYPE_MIN_VALUE (type
) };
4945 if (splay_tree_foreach (cases
, c_switch_covers_all_cases_p_1
, args
))
4948 /* If there are no cases at all, or if the highest case label
4949 is smaller than TYPE_MAX_VALUE, return false. */
4950 if (args
[0] == NULL_TREE
4951 || wi::to_widest (args
[0]) < wi::to_widest (TYPE_MAX_VALUE (type
)))
4957 /* Finish an expression taking the address of LABEL (an
4958 IDENTIFIER_NODE). Returns an expression for the address.
4960 LOC is the location for the expression returned. */
4963 finish_label_address_expr (tree label
, location_t loc
)
4967 pedwarn (input_location
, OPT_Wpedantic
, "taking the address of a label is non-standard");
4969 if (label
== error_mark_node
)
4970 return error_mark_node
;
4972 label
= lookup_label (label
);
4973 if (label
== NULL_TREE
)
4974 result
= null_pointer_node
;
4977 TREE_USED (label
) = 1;
4978 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4979 /* The current function is not necessarily uninlinable.
4980 Computed gotos are incompatible with inlining, but the value
4981 here could be used only in a diagnostic, for example. */
4982 protected_set_expr_location (result
, loc
);
4989 /* Given a boolean expression ARG, return a tree representing an increment
4990 or decrement (as indicated by CODE) of ARG. The front end must check for
4991 invalid cases (e.g., decrement in C++). */
4993 boolean_increment (enum tree_code code
, tree arg
)
4996 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
4998 arg
= stabilize_reference (arg
);
5001 case PREINCREMENT_EXPR
:
5002 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5004 case POSTINCREMENT_EXPR
:
5005 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5006 arg
= save_expr (arg
);
5007 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5008 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5010 case PREDECREMENT_EXPR
:
5011 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5012 invert_truthvalue_loc (input_location
, arg
));
5014 case POSTDECREMENT_EXPR
:
5015 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5016 invert_truthvalue_loc (input_location
, arg
));
5017 arg
= save_expr (arg
);
5018 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5019 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5024 TREE_SIDE_EFFECTS (val
) = 1;
5028 /* Built-in macros for stddef.h and stdint.h, that require macros
5029 defined in this file. */
5031 c_stddef_cpp_builtins(void)
5033 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
5034 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
5035 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
5036 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
5037 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
5038 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
5039 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
5040 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
5041 if (SIG_ATOMIC_TYPE
)
5042 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE
, 0);
5044 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE
, 0);
5046 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE
, 0);
5048 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE
, 0);
5050 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE
, 0);
5052 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE
, 0);
5054 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE
, 0);
5056 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE
, 0);
5058 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE
, 0);
5059 if (INT_LEAST8_TYPE
)
5060 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE
, 0);
5061 if (INT_LEAST16_TYPE
)
5062 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE
, 0);
5063 if (INT_LEAST32_TYPE
)
5064 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE
, 0);
5065 if (INT_LEAST64_TYPE
)
5066 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE
, 0);
5067 if (UINT_LEAST8_TYPE
)
5068 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE
, 0);
5069 if (UINT_LEAST16_TYPE
)
5070 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE
, 0);
5071 if (UINT_LEAST32_TYPE
)
5072 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE
, 0);
5073 if (UINT_LEAST64_TYPE
)
5074 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE
, 0);
5076 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE
, 0);
5077 if (INT_FAST16_TYPE
)
5078 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE
, 0);
5079 if (INT_FAST32_TYPE
)
5080 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE
, 0);
5081 if (INT_FAST64_TYPE
)
5082 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE
, 0);
5083 if (UINT_FAST8_TYPE
)
5084 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE
, 0);
5085 if (UINT_FAST16_TYPE
)
5086 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE
, 0);
5087 if (UINT_FAST32_TYPE
)
5088 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE
, 0);
5089 if (UINT_FAST64_TYPE
)
5090 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE
, 0);
5092 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE
, 0);
5094 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE
, 0);
5098 c_init_attributes (void)
5100 /* Fill in the built_in_attributes array. */
5101 #define DEF_ATTR_NULL_TREE(ENUM) \
5102 built_in_attributes[(int) ENUM] = NULL_TREE;
5103 #define DEF_ATTR_INT(ENUM, VALUE) \
5104 built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE);
5105 #define DEF_ATTR_STRING(ENUM, VALUE) \
5106 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
5107 #define DEF_ATTR_IDENT(ENUM, STRING) \
5108 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5109 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5110 built_in_attributes[(int) ENUM] \
5111 = tree_cons (built_in_attributes[(int) PURPOSE], \
5112 built_in_attributes[(int) VALUE], \
5113 built_in_attributes[(int) CHAIN]);
5114 #include "builtin-attrs.def"
5115 #undef DEF_ATTR_NULL_TREE
5117 #undef DEF_ATTR_IDENT
5118 #undef DEF_ATTR_TREE_LIST
5121 /* Check whether ALIGN is a valid user-specified alignment. If so,
5122 return its base-2 log; if not, output an error and return -1. If
5123 ALLOW_ZERO then 0 is valid and should result in a return of -1 with
5126 check_user_alignment (const_tree align
, bool allow_zero
)
5130 if (error_operand_p (align
))
5132 if (TREE_CODE (align
) != INTEGER_CST
5133 || !INTEGRAL_TYPE_P (TREE_TYPE (align
)))
5135 error ("requested alignment is not an integer constant");
5138 else if (allow_zero
&& integer_zerop (align
))
5140 else if (tree_int_cst_sgn (align
) == -1
5141 || (i
= tree_log2 (align
)) == -1)
5143 error ("requested alignment is not a positive power of 2");
5146 else if (i
>= HOST_BITS_PER_INT
- LOG2_BITS_PER_UNIT
)
5148 error ("requested alignment is too large");
5154 /* Determine the ELF symbol visibility for DECL, which is either a
5155 variable or a function. It is an error to use this function if a
5156 definition of DECL is not available in this translation unit.
5157 Returns true if the final visibility has been determined by this
5158 function; false if the caller is free to make additional
5162 c_determine_visibility (tree decl
)
5164 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
5166 /* If the user explicitly specified the visibility with an
5167 attribute, honor that. DECL_VISIBILITY will have been set during
5168 the processing of the attribute. We check for an explicit
5169 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5170 to distinguish the use of an attribute from the use of a "#pragma
5171 GCC visibility push(...)"; in the latter case we still want other
5172 considerations to be able to overrule the #pragma. */
5173 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
5174 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5175 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
5176 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
5179 /* Set default visibility to whatever the user supplied with
5180 visibility_specified depending on #pragma GCC visibility. */
5181 if (!DECL_VISIBILITY_SPECIFIED (decl
))
5183 if (visibility_options
.inpragma
5184 || DECL_VISIBILITY (decl
) != default_visibility
)
5186 DECL_VISIBILITY (decl
) = default_visibility
;
5187 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
5188 /* If visibility changed and DECL already has DECL_RTL, ensure
5189 symbol flags are updated. */
5190 if (((VAR_P (decl
) && TREE_STATIC (decl
))
5191 || TREE_CODE (decl
) == FUNCTION_DECL
)
5192 && DECL_RTL_SET_P (decl
))
5193 make_decl_rtl (decl
);
5199 /* Data to communicate through check_function_arguments_recurse between
5200 check_function_nonnull and check_nonnull_arg. */
5202 struct nonnull_arg_ctx
5208 /* Check the argument list of a function call for null in argument slots
5209 that are marked as requiring a non-null pointer argument. The NARGS
5210 arguments are passed in the array ARGARRAY. Return true if we have
5214 check_function_nonnull (location_t loc
, tree attrs
, int nargs
, tree
*argarray
)
5219 attrs
= lookup_attribute ("nonnull", attrs
);
5220 if (attrs
== NULL_TREE
)
5224 /* See if any of the nonnull attributes has no arguments. If so,
5225 then every pointer argument is checked (in which case the check
5226 for pointer type is done in check_nonnull_arg). */
5227 if (TREE_VALUE (a
) != NULL_TREE
)
5229 a
= lookup_attribute ("nonnull", TREE_CHAIN (a
));
5230 while (a
!= NULL_TREE
&& TREE_VALUE (a
) != NULL_TREE
);
5232 struct nonnull_arg_ctx ctx
= { loc
, false };
5234 for (i
= 0; i
< nargs
; i
++)
5235 check_function_arguments_recurse (check_nonnull_arg
, &ctx
, argarray
[i
],
5239 /* Walk the argument list. If we encounter an argument number we
5240 should check for non-null, do it. */
5241 for (i
= 0; i
< nargs
; i
++)
5243 for (a
= attrs
; ; a
= TREE_CHAIN (a
))
5245 a
= lookup_attribute ("nonnull", a
);
5246 if (a
== NULL_TREE
|| nonnull_check_p (TREE_VALUE (a
), i
+ 1))
5251 check_function_arguments_recurse (check_nonnull_arg
, &ctx
,
5252 argarray
[i
], i
+ 1);
5255 return ctx
.warned_p
;
5258 /* Check that the Nth argument of a function call (counting backwards
5259 from the end) is a (pointer)0. The NARGS arguments are passed in the
5263 check_function_sentinel (const_tree fntype
, int nargs
, tree
*argarray
)
5265 tree attr
= lookup_attribute ("sentinel", TYPE_ATTRIBUTES (fntype
));
5272 function_args_iterator iter
;
5275 /* Skip over the named arguments. */
5276 FOREACH_FUNCTION_ARGS (fntype
, t
, iter
)
5283 if (TREE_VALUE (attr
))
5285 tree p
= TREE_VALUE (TREE_VALUE (attr
));
5286 pos
= TREE_INT_CST_LOW (p
);
5289 /* The sentinel must be one of the varargs, i.e.
5290 in position >= the number of fixed arguments. */
5291 if ((nargs
- 1 - pos
) < len
)
5293 warning (OPT_Wformat_
,
5294 "not enough variable arguments to fit a sentinel");
5298 /* Validate the sentinel. */
5299 sentinel
= argarray
[nargs
- 1 - pos
];
5300 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
5301 || !integer_zerop (sentinel
))
5302 /* Although __null (in C++) is only an integer we allow it
5303 nevertheless, as we are guaranteed that it's exactly
5304 as wide as a pointer, and we don't want to force
5305 users to cast the NULL they have written there.
5306 We warn with -Wstrict-null-sentinel, though. */
5307 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
5308 warning (OPT_Wformat_
, "missing sentinel in function call");
5312 /* Check that the same argument isn't passed to two or more
5313 restrict-qualified formal and issue a -Wrestrict warning
5314 if it is. Return true if a warning has been issued. */
5317 check_function_restrict (const_tree fndecl
, const_tree fntype
,
5318 int nargs
, tree
*argarray
)
5321 tree parms
= TYPE_ARG_TYPES (fntype
);
5324 && TREE_CODE (fndecl
) == FUNCTION_DECL
)
5326 /* Avoid diagnosing calls built-ins with a zero size/bound
5327 here. They are checked in more detail elsewhere. */
5328 if (DECL_BUILT_IN (fndecl
)
5329 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
5331 && TREE_CODE (argarray
[2]) == INTEGER_CST
5332 && integer_zerop (argarray
[2]))
5335 if (DECL_ARGUMENTS (fndecl
))
5336 parms
= DECL_ARGUMENTS (fndecl
);
5339 for (i
= 0; i
< nargs
; i
++)
5340 TREE_VISITED (argarray
[i
]) = 0;
5342 bool warned
= false;
5344 for (i
= 0; i
< nargs
&& parms
&& parms
!= void_list_node
; i
++)
5347 if (TREE_CODE (parms
) == PARM_DECL
)
5349 type
= TREE_TYPE (parms
);
5350 parms
= DECL_CHAIN (parms
);
5354 type
= TREE_VALUE (parms
);
5355 parms
= TREE_CHAIN (parms
);
5357 if (POINTER_TYPE_P (type
)
5358 && TYPE_RESTRICT (type
)
5359 && !TYPE_READONLY (TREE_TYPE (type
)))
5360 warned
|= warn_for_restrict (i
, argarray
, nargs
);
5363 for (i
= 0; i
< nargs
; i
++)
5364 TREE_VISITED (argarray
[i
]) = 0;
5369 /* Helper for check_function_nonnull; given a list of operands which
5370 must be non-null in ARGS, determine if operand PARAM_NUM should be
5374 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
5376 unsigned HOST_WIDE_INT arg_num
= 0;
5378 for (; args
; args
= TREE_CHAIN (args
))
5380 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
5384 if (arg_num
== param_num
)
5390 /* Check that the function argument PARAM (which is operand number
5391 PARAM_NUM) is non-null. This is called by check_function_nonnull
5392 via check_function_arguments_recurse. */
5395 check_nonnull_arg (void *ctx
, tree param
, unsigned HOST_WIDE_INT param_num
)
5397 struct nonnull_arg_ctx
*pctx
= (struct nonnull_arg_ctx
*) ctx
;
5399 /* Just skip checking the argument if it's not a pointer. This can
5400 happen if the "nonnull" attribute was given without an operand
5401 list (which means to check every pointer argument). */
5403 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
5406 /* When not optimizing diagnose the simple cases of null arguments.
5407 When optimization is enabled defer the checking until expansion
5408 when more cases can be detected. */
5409 if (integer_zerop (param
))
5411 warning_at (pctx
->loc
, OPT_Wnonnull
, "null argument where non-null "
5412 "required (argument %lu)", (unsigned long) param_num
);
5413 pctx
->warned_p
= true;
5417 /* Helper for nonnull attribute handling; fetch the operand number
5418 from the attribute argument list. */
5421 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
5423 /* Verify the arg number is a small constant. */
5424 if (tree_fits_uhwi_p (arg_num_expr
))
5426 *valp
= tree_to_uhwi (arg_num_expr
);
5433 /* Arguments being collected for optimization. */
5434 typedef const char *const_char_p
; /* For DEF_VEC_P. */
5435 static GTY(()) vec
<const_char_p
, va_gc
> *optimize_args
;
5438 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
5439 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
5440 false for #pragma GCC optimize. */
5443 parse_optimize_options (tree args
, bool attr_p
)
5448 const char **opt_argv
;
5449 struct cl_decoded_option
*decoded_options
;
5450 unsigned int decoded_options_count
;
5453 /* Build up argv vector. Just in case the string is stored away, use garbage
5454 collected strings. */
5455 vec_safe_truncate (optimize_args
, 0);
5456 vec_safe_push (optimize_args
, (const char *) NULL
);
5458 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
5460 tree value
= TREE_VALUE (ap
);
5462 if (TREE_CODE (value
) == INTEGER_CST
)
5465 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
5466 vec_safe_push (optimize_args
, ggc_strdup (buffer
));
5469 else if (TREE_CODE (value
) == STRING_CST
)
5471 /* Split string into multiple substrings. */
5472 size_t len
= TREE_STRING_LENGTH (value
);
5473 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
5474 char *end
= p
+ len
;
5478 while (next_p
!= NULL
)
5484 comma
= strchr (p
, ',');
5497 r
= q
= (char *) ggc_alloc_atomic (len2
+ 3);
5499 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
5501 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
5505 warning (OPT_Wattributes
,
5506 "bad option %qs to attribute %<optimize%>", p
);
5508 warning (OPT_Wpragmas
,
5509 "bad option %qs to pragma %<optimize%>", p
);
5517 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
5518 itself is -Os, and any other switch begins with a -f. */
5519 if ((*p
>= '0' && *p
<= '9')
5520 || (p
[0] == 's' && p
[1] == '\0'))
5526 memcpy (r
, p
, len2
);
5528 vec_safe_push (optimize_args
, (const char *) q
);
5534 opt_argc
= optimize_args
->length ();
5535 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
5537 for (i
= 1; i
< opt_argc
; i
++)
5538 opt_argv
[i
] = (*optimize_args
)[i
];
5540 /* Now parse the options. */
5541 decode_cmdline_options_to_array_default_mask (opt_argc
, opt_argv
,
5543 &decoded_options_count
);
5544 /* Drop non-Optimization options. */
5546 for (i
= 1; i
< decoded_options_count
; ++i
)
5548 if (! (cl_options
[decoded_options
[i
].opt_index
].flags
& CL_OPTIMIZATION
))
5552 warning (OPT_Wattributes
,
5553 "bad option %qs to attribute %<optimize%>",
5554 decoded_options
[i
].orig_option_with_args_text
);
5556 warning (OPT_Wpragmas
,
5557 "bad option %qs to pragma %<optimize%>",
5558 decoded_options
[i
].orig_option_with_args_text
);
5562 decoded_options
[j
] = decoded_options
[i
];
5565 decoded_options_count
= j
;
5566 /* And apply them. */
5567 decode_options (&global_options
, &global_options_set
,
5568 decoded_options
, decoded_options_count
,
5569 input_location
, global_dc
, NULL
);
5571 targetm
.override_options_after_change();
5573 optimize_args
->truncate (0);
5577 /* Check whether ATTR is a valid attribute fallthrough. */
5580 attribute_fallthrough_p (tree attr
)
5582 if (attr
== error_mark_node
)
5584 tree t
= lookup_attribute ("fallthrough", attr
);
5587 /* This attribute shall appear at most once in each attribute-list. */
5588 if (lookup_attribute ("fallthrough", TREE_CHAIN (t
)))
5589 warning (OPT_Wattributes
, "%<fallthrough%> attribute specified multiple "
5591 /* No attribute-argument-clause shall be present. */
5592 else if (TREE_VALUE (t
) != NULL_TREE
)
5593 warning (OPT_Wattributes
, "%<fallthrough%> attribute specified with "
5595 /* Warn if other attributes are found. */
5596 for (t
= attr
; t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
5598 tree name
= get_attribute_name (t
);
5599 if (!is_attribute_p ("fallthrough", name
))
5600 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5606 /* Check for valid arguments being passed to a function with FNTYPE.
5607 There are NARGS arguments in the array ARGARRAY. LOC should be used
5608 for diagnostics. Return true if either -Wnonnull or -Wrestrict has
5612 check_function_arguments (location_t loc
, const_tree fndecl
, const_tree fntype
,
5613 int nargs
, tree
*argarray
, vec
<location_t
> *arglocs
)
5615 bool warned_p
= false;
5617 /* Check for null being passed in a pointer argument that must be
5618 non-null. We also need to do this if format checking is enabled. */
5621 warned_p
= check_function_nonnull (loc
, TYPE_ATTRIBUTES (fntype
),
5624 /* Check for errors in format strings. */
5626 if (warn_format
|| warn_suggest_attribute_format
)
5627 check_function_format (TYPE_ATTRIBUTES (fntype
), nargs
, argarray
, arglocs
);
5630 check_function_sentinel (fntype
, nargs
, argarray
);
5633 warned_p
|= check_function_restrict (fndecl
, fntype
, nargs
, argarray
);
5637 /* Generic argument checking recursion routine. PARAM is the argument to
5638 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5639 once the argument is resolved. CTX is context for the callback. */
5641 check_function_arguments_recurse (void (*callback
)
5642 (void *, tree
, unsigned HOST_WIDE_INT
),
5643 void *ctx
, tree param
,
5644 unsigned HOST_WIDE_INT param_num
)
5646 if (CONVERT_EXPR_P (param
)
5647 && (TYPE_PRECISION (TREE_TYPE (param
))
5648 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
5650 /* Strip coercion. */
5651 check_function_arguments_recurse (callback
, ctx
,
5652 TREE_OPERAND (param
, 0), param_num
);
5656 if (TREE_CODE (param
) == CALL_EXPR
)
5658 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
5660 bool found_format_arg
= false;
5662 /* See if this is a call to a known internationalization function
5663 that modifies a format arg. Such a function may have multiple
5664 format_arg attributes (for example, ngettext). */
5666 for (attrs
= TYPE_ATTRIBUTES (type
);
5668 attrs
= TREE_CHAIN (attrs
))
5669 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
5672 tree format_num_expr
;
5675 call_expr_arg_iterator iter
;
5677 /* Extract the argument number, which was previously checked
5679 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
5681 format_num
= tree_to_uhwi (format_num_expr
);
5683 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
5684 inner_arg
!= NULL_TREE
;
5685 inner_arg
= next_call_expr_arg (&iter
), i
++)
5686 if (i
== format_num
)
5688 check_function_arguments_recurse (callback
, ctx
,
5689 inner_arg
, param_num
);
5690 found_format_arg
= true;
5695 /* If we found a format_arg attribute and did a recursive check,
5696 we are done with checking this argument. Otherwise, we continue
5697 and this will be considered a non-literal. */
5698 if (found_format_arg
)
5702 if (TREE_CODE (param
) == COND_EXPR
)
5704 /* Simplify to avoid warning for an impossible case. */
5705 param
= fold_for_warn (param
);
5706 if (TREE_CODE (param
) == COND_EXPR
)
5708 /* Check both halves of the conditional expression. */
5709 check_function_arguments_recurse (callback
, ctx
,
5710 TREE_OPERAND (param
, 1),
5712 check_function_arguments_recurse (callback
, ctx
,
5713 TREE_OPERAND (param
, 2),
5719 (*callback
) (ctx
, param
, param_num
);
5722 /* Checks for a builtin function FNDECL that the number of arguments
5723 NARGS against the required number REQUIRED and issues an error if
5724 there is a mismatch. Returns true if the number of arguments is
5725 correct, otherwise false. LOC is the location of FNDECL. */
5728 builtin_function_validate_nargs (location_t loc
, tree fndecl
, int nargs
,
5731 if (nargs
< required
)
5733 error_at (loc
, "too few arguments to function %qE", fndecl
);
5736 else if (nargs
> required
)
5738 error_at (loc
, "too many arguments to function %qE", fndecl
);
5744 /* Helper macro for check_builtin_function_arguments. */
5745 #define ARG_LOCATION(N) \
5746 (arg_loc.is_empty () \
5747 ? EXPR_LOC_OR_LOC (args[(N)], input_location) \
5748 : expansion_point_location (arg_loc[(N)]))
5750 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
5751 Returns false if there was an error, otherwise true. LOC is the
5752 location of the function; ARG_LOC is a vector of locations of the
5756 check_builtin_function_arguments (location_t loc
, vec
<location_t
> arg_loc
,
5757 tree fndecl
, int nargs
, tree
*args
)
5759 if (!DECL_BUILT_IN (fndecl
)
5760 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
5763 switch (DECL_FUNCTION_CODE (fndecl
))
5765 case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
:
5766 if (!tree_fits_uhwi_p (args
[2]))
5768 error_at (ARG_LOCATION (2),
5769 "third argument to function %qE must be a constant integer",
5775 case BUILT_IN_ALLOCA_WITH_ALIGN
:
5777 /* Get the requested alignment (in bits) if it's a constant
5778 integer expression. */
5779 unsigned HOST_WIDE_INT align
5780 = tree_fits_uhwi_p (args
[1]) ? tree_to_uhwi (args
[1]) : 0;
5782 /* Determine if the requested alignment is a power of 2. */
5783 if ((align
& (align
- 1)))
5786 /* The maximum alignment in bits corresponding to the same
5787 maximum in bytes enforced in check_user_alignment(). */
5788 unsigned maxalign
= (UINT_MAX
>> 1) + 1;
5790 /* Reject invalid alignments. */
5791 if (align
< BITS_PER_UNIT
|| maxalign
< align
)
5793 error_at (ARG_LOCATION (1),
5794 "second argument to function %qE must be a constant "
5795 "integer power of 2 between %qi and %qu bits",
5796 fndecl
, BITS_PER_UNIT
, maxalign
);
5802 case BUILT_IN_CONSTANT_P
:
5803 return builtin_function_validate_nargs (loc
, fndecl
, nargs
, 1);
5805 case BUILT_IN_ISFINITE
:
5806 case BUILT_IN_ISINF
:
5807 case BUILT_IN_ISINF_SIGN
:
5808 case BUILT_IN_ISNAN
:
5809 case BUILT_IN_ISNORMAL
:
5810 case BUILT_IN_SIGNBIT
:
5811 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 1))
5813 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
5815 error_at (ARG_LOCATION (0), "non-floating-point argument in "
5816 "call to function %qE", fndecl
);
5823 case BUILT_IN_ISGREATER
:
5824 case BUILT_IN_ISGREATEREQUAL
:
5825 case BUILT_IN_ISLESS
:
5826 case BUILT_IN_ISLESSEQUAL
:
5827 case BUILT_IN_ISLESSGREATER
:
5828 case BUILT_IN_ISUNORDERED
:
5829 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 2))
5831 enum tree_code code0
, code1
;
5832 code0
= TREE_CODE (TREE_TYPE (args
[0]));
5833 code1
= TREE_CODE (TREE_TYPE (args
[1]));
5834 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
5835 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
5836 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
5838 error_at (loc
, "non-floating-point arguments in call to "
5839 "function %qE", fndecl
);
5846 case BUILT_IN_FPCLASSIFY
:
5847 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 6))
5849 for (unsigned int i
= 0; i
< 5; i
++)
5850 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
5852 error_at (ARG_LOCATION (i
), "non-const integer argument %u in "
5853 "call to function %qE", i
+ 1, fndecl
);
5857 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
5859 error_at (ARG_LOCATION (5), "non-floating-point argument in "
5860 "call to function %qE", fndecl
);
5867 case BUILT_IN_ASSUME_ALIGNED
:
5868 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 2 + (nargs
> 2)))
5870 if (nargs
>= 3 && TREE_CODE (TREE_TYPE (args
[2])) != INTEGER_TYPE
)
5872 error_at (ARG_LOCATION (2), "non-integer argument 3 in call to "
5873 "function %qE", fndecl
);
5880 case BUILT_IN_ADD_OVERFLOW
:
5881 case BUILT_IN_SUB_OVERFLOW
:
5882 case BUILT_IN_MUL_OVERFLOW
:
5883 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 3))
5886 for (i
= 0; i
< 2; i
++)
5887 if (!INTEGRAL_TYPE_P (TREE_TYPE (args
[i
])))
5889 error_at (ARG_LOCATION (i
), "argument %u in call to function "
5890 "%qE does not have integral type", i
+ 1, fndecl
);
5893 if (TREE_CODE (TREE_TYPE (args
[2])) != POINTER_TYPE
5894 || !INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (args
[2]))))
5896 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
5897 "does not have pointer to integral type", fndecl
);
5900 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args
[2]))) == ENUMERAL_TYPE
)
5902 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
5903 "has pointer to enumerated type", fndecl
);
5906 else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args
[2]))) == BOOLEAN_TYPE
)
5908 error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
5909 "has pointer to boolean type", fndecl
);
5916 case BUILT_IN_ADD_OVERFLOW_P
:
5917 case BUILT_IN_SUB_OVERFLOW_P
:
5918 case BUILT_IN_MUL_OVERFLOW_P
:
5919 if (builtin_function_validate_nargs (loc
, fndecl
, nargs
, 3))
5922 for (i
= 0; i
< 3; i
++)
5923 if (!INTEGRAL_TYPE_P (TREE_TYPE (args
[i
])))
5925 error_at (ARG_LOCATION (i
), "argument %u in call to function "
5926 "%qE does not have integral type", i
+ 1, fndecl
);
5929 if (TREE_CODE (TREE_TYPE (args
[2])) == ENUMERAL_TYPE
)
5931 error_at (ARG_LOCATION (2), "argument 3 in call to function "
5932 "%qE has enumerated type", fndecl
);
5935 else if (TREE_CODE (TREE_TYPE (args
[2])) == BOOLEAN_TYPE
)
5937 error_at (ARG_LOCATION (2), "argument 3 in call to function "
5938 "%qE has boolean type", fndecl
);
5950 /* Subroutine of c_parse_error.
5951 Return the result of concatenating LHS and RHS. RHS is really
5952 a string literal, its first character is indicated by RHS_START and
5953 RHS_SIZE is its length (including the terminating NUL character).
5955 The caller is responsible for deleting the returned pointer. */
5958 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
5960 const size_t lhs_size
= strlen (lhs
);
5961 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
5962 memcpy (result
, lhs
, lhs_size
);
5963 memcpy (result
+ lhs_size
, rhs_start
, rhs_size
);
5967 /* Issue the error given by GMSGID at RICHLOC, indicating that it occurred
5968 before TOKEN, which had the associated VALUE. */
5971 c_parse_error (const char *gmsgid
, enum cpp_ttype token_type
,
5972 tree value
, unsigned char token_flags
,
5973 rich_location
*richloc
)
5975 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
5977 char *message
= NULL
;
5979 if (token_type
== CPP_EOF
)
5980 message
= catenate_messages (gmsgid
, " at end of input");
5981 else if (token_type
== CPP_CHAR
5982 || token_type
== CPP_WCHAR
5983 || token_type
== CPP_CHAR16
5984 || token_type
== CPP_CHAR32
5985 || token_type
== CPP_UTF8CHAR
)
5987 unsigned int val
= TREE_INT_CST_LOW (value
);
6009 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
6010 message
= catenate_messages (gmsgid
, " before %s'%c'");
6012 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
6014 error_at (richloc
, message
, prefix
, val
);
6018 else if (token_type
== CPP_CHAR_USERDEF
6019 || token_type
== CPP_WCHAR_USERDEF
6020 || token_type
== CPP_CHAR16_USERDEF
6021 || token_type
== CPP_CHAR32_USERDEF
6022 || token_type
== CPP_UTF8CHAR_USERDEF
)
6023 message
= catenate_messages (gmsgid
,
6024 " before user-defined character literal");
6025 else if (token_type
== CPP_STRING_USERDEF
6026 || token_type
== CPP_WSTRING_USERDEF
6027 || token_type
== CPP_STRING16_USERDEF
6028 || token_type
== CPP_STRING32_USERDEF
6029 || token_type
== CPP_UTF8STRING_USERDEF
)
6030 message
= catenate_messages (gmsgid
, " before user-defined string literal");
6031 else if (token_type
== CPP_STRING
6032 || token_type
== CPP_WSTRING
6033 || token_type
== CPP_STRING16
6034 || token_type
== CPP_STRING32
6035 || token_type
== CPP_UTF8STRING
)
6036 message
= catenate_messages (gmsgid
, " before string constant");
6037 else if (token_type
== CPP_NUMBER
)
6038 message
= catenate_messages (gmsgid
, " before numeric constant");
6039 else if (token_type
== CPP_NAME
)
6041 message
= catenate_messages (gmsgid
, " before %qE");
6042 error_at (richloc
, message
, value
);
6046 else if (token_type
== CPP_PRAGMA
)
6047 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
6048 else if (token_type
== CPP_PRAGMA_EOL
)
6049 message
= catenate_messages (gmsgid
, " before end of line");
6050 else if (token_type
== CPP_DECLTYPE
)
6051 message
= catenate_messages (gmsgid
, " before %<decltype%>");
6052 else if (token_type
< N_TTYPES
)
6054 message
= catenate_messages (gmsgid
, " before %qs token");
6055 error_at (richloc
, message
, cpp_type2name (token_type
, token_flags
));
6060 error_at (richloc
, gmsgid
);
6064 error_at (richloc
, message
);
6067 #undef catenate_messages
6070 /* Return the gcc option code associated with the reason for a cpp
6071 message, or 0 if none. */
6074 c_option_controlling_cpp_error (int reason
)
6076 const struct cpp_reason_option_codes_t
*entry
;
6078 for (entry
= cpp_reason_option_codes
; entry
->reason
!= CPP_W_NONE
; entry
++)
6080 if (entry
->reason
== reason
)
6081 return entry
->option_code
;
6086 /* Callback from cpp_error for PFILE to print diagnostics from the
6087 preprocessor. The diagnostic is of type LEVEL, with REASON set
6088 to the reason code if LEVEL is represents a warning, at location
6089 RICHLOC unless this is after lexing and the compiler's location
6090 should be used instead; MSG is the translated message and AP
6091 the arguments. Returns true if a diagnostic was emitted, false
6095 c_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
, int reason
,
6096 rich_location
*richloc
,
6097 const char *msg
, va_list *ap
)
6099 diagnostic_info diagnostic
;
6100 diagnostic_t dlevel
;
6101 bool save_warn_system_headers
= global_dc
->dc_warn_system_headers
;
6106 case CPP_DL_WARNING_SYSHDR
:
6109 global_dc
->dc_warn_system_headers
= 1;
6111 case CPP_DL_WARNING
:
6114 dlevel
= DK_WARNING
;
6116 case CPP_DL_PEDWARN
:
6117 if (flag_no_output
&& !flag_pedantic_errors
)
6119 dlevel
= DK_PEDWARN
;
6137 richloc
->set_range (line_table
, 0, input_location
, true);
6138 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
6140 diagnostic_override_option_index (&diagnostic
,
6141 c_option_controlling_cpp_error (reason
));
6142 ret
= diagnostic_report_diagnostic (global_dc
, &diagnostic
);
6143 if (level
== CPP_DL_WARNING_SYSHDR
)
6144 global_dc
->dc_warn_system_headers
= save_warn_system_headers
;
6148 /* Convert a character from the host to the target execution character
6149 set. cpplib handles this, mostly. */
6152 c_common_to_target_charset (HOST_WIDE_INT c
)
6154 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6155 zero-extended under -fno-signed-char. cpplib insists that characters
6156 and character constants are always unsigned. Hence we must convert
6158 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
6160 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
6162 if (flag_signed_char
)
6163 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
6164 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
6169 /* Fold an offsetof-like expression. EXPR is a nested sequence of component
6170 references with an INDIRECT_REF of a constant at the bottom; much like the
6171 traditional rendering of offsetof as a macro. TYPE is the desired type of
6172 the whole expression. Return the folded result. */
6175 fold_offsetof (tree expr
, tree type
, enum tree_code ctx
)
6178 tree_code code
= TREE_CODE (expr
);
6185 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
6186 return error_mark_node
;
6190 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6191 return error_mark_node
;
6195 if (!TREE_CONSTANT (TREE_OPERAND (expr
, 0)))
6197 error ("cannot apply %<offsetof%> to a non constant address");
6198 return error_mark_node
;
6200 return convert (type
, TREE_OPERAND (expr
, 0));
6203 base
= fold_offsetof (TREE_OPERAND (expr
, 0), type
, code
);
6204 if (base
== error_mark_node
)
6207 t
= TREE_OPERAND (expr
, 1);
6208 if (DECL_C_BIT_FIELD (t
))
6210 error ("attempt to take address of bit-field structure "
6212 return error_mark_node
;
6214 off
= size_binop_loc (input_location
, PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
6215 size_int (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (t
))
6220 base
= fold_offsetof (TREE_OPERAND (expr
, 0), type
, code
);
6221 if (base
== error_mark_node
)
6224 t
= TREE_OPERAND (expr
, 1);
6226 /* Check if the offset goes beyond the upper bound of the array. */
6227 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) >= 0)
6229 tree upbound
= array_ref_up_bound (expr
);
6230 if (upbound
!= NULL_TREE
6231 && TREE_CODE (upbound
) == INTEGER_CST
6232 && !tree_int_cst_equal (upbound
,
6233 TYPE_MAX_VALUE (TREE_TYPE (upbound
))))
6235 if (ctx
!= ARRAY_REF
&& ctx
!= COMPONENT_REF
)
6236 upbound
= size_binop (PLUS_EXPR
, upbound
,
6237 build_int_cst (TREE_TYPE (upbound
), 1));
6238 if (tree_int_cst_lt (upbound
, t
))
6242 for (v
= TREE_OPERAND (expr
, 0);
6243 TREE_CODE (v
) == COMPONENT_REF
;
6244 v
= TREE_OPERAND (v
, 0))
6245 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v
, 0)))
6248 tree fld_chain
= DECL_CHAIN (TREE_OPERAND (v
, 1));
6249 for (; fld_chain
; fld_chain
= DECL_CHAIN (fld_chain
))
6250 if (TREE_CODE (fld_chain
) == FIELD_DECL
)
6256 /* Don't warn if the array might be considered a poor
6257 man's flexible array member with a very permissive
6258 definition thereof. */
6259 if (TREE_CODE (v
) == ARRAY_REF
6260 || TREE_CODE (v
) == COMPONENT_REF
)
6261 warning (OPT_Warray_bounds
,
6262 "index %E denotes an offset "
6263 "greater than size of %qT",
6264 t
, TREE_TYPE (TREE_OPERAND (expr
, 0)));
6269 t
= convert (sizetype
, t
);
6270 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
6274 /* Handle static members of volatile structs. */
6275 t
= TREE_OPERAND (expr
, 1);
6276 gcc_checking_assert (VAR_P (get_base_address (t
)));
6277 return fold_offsetof (t
, type
);
6283 if (!POINTER_TYPE_P (type
))
6284 return size_binop (PLUS_EXPR
, base
, convert (type
, off
));
6285 return fold_build_pointer_plus (base
, off
);
6288 /* *PTYPE is an incomplete array. Complete it with a domain based on
6289 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6290 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6291 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6294 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
6296 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
6297 int failure
= 0, quals
;
6298 bool overflow_p
= false;
6300 maxindex
= size_zero_node
;
6303 if (TREE_CODE (initial_value
) == STRING_CST
)
6306 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
6307 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
6309 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
6311 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
6313 if (vec_safe_is_empty (v
))
6317 maxindex
= ssize_int (-1);
6322 unsigned HOST_WIDE_INT cnt
;
6323 constructor_elt
*ce
;
6324 bool fold_p
= false;
6327 maxindex
= (*v
)[0].index
, fold_p
= true;
6329 curindex
= maxindex
;
6331 for (cnt
= 1; vec_safe_iterate (v
, cnt
, &ce
); cnt
++)
6333 bool curfold_p
= false;
6335 curindex
= ce
->index
, curfold_p
= true;
6340 /* Since we treat size types now as ordinary
6341 unsigned types, we need an explicit overflow
6343 tree orig
= curindex
;
6344 curindex
= fold_convert (sizetype
, curindex
);
6345 overflow_p
|= tree_int_cst_lt (curindex
, orig
);
6347 curindex
= size_binop (PLUS_EXPR
, curindex
,
6350 if (tree_int_cst_lt (maxindex
, curindex
))
6351 maxindex
= curindex
, fold_p
= curfold_p
;
6355 tree orig
= maxindex
;
6356 maxindex
= fold_convert (sizetype
, maxindex
);
6357 overflow_p
|= tree_int_cst_lt (maxindex
, orig
);
6363 /* Make an error message unless that happened already. */
6364 if (initial_value
!= error_mark_node
)
6376 elt
= TREE_TYPE (type
);
6377 quals
= TYPE_QUALS (strip_array_types (elt
));
6381 unqual_elt
= c_build_qualified_type (elt
, KEEP_QUAL_ADDR_SPACE (quals
));
6383 /* Using build_distinct_type_copy and modifying things afterward instead
6384 of using build_array_type to create a new type preserves all of the
6385 TYPE_LANG_FLAG_? bits that the front end may have set. */
6386 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6387 TREE_TYPE (main_type
) = unqual_elt
;
6388 TYPE_DOMAIN (main_type
)
6389 = build_range_type (TREE_TYPE (maxindex
),
6390 build_int_cst (TREE_TYPE (maxindex
), 0), maxindex
);
6391 TYPE_TYPELESS_STORAGE (main_type
) = TYPE_TYPELESS_STORAGE (type
);
6392 layout_type (main_type
);
6394 /* Make sure we have the canonical MAIN_TYPE. */
6395 hashval_t hashcode
= type_hash_canon_hash (main_type
);
6396 main_type
= type_hash_canon (hashcode
, main_type
);
6398 /* Fix the canonical type. */
6399 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
6400 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
6401 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
6402 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
6403 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
6404 != TYPE_DOMAIN (main_type
)))
6405 TYPE_CANONICAL (main_type
)
6406 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
6407 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)),
6408 TYPE_TYPELESS_STORAGE (main_type
));
6410 TYPE_CANONICAL (main_type
) = main_type
;
6415 type
= c_build_qualified_type (main_type
, quals
);
6417 if (COMPLETE_TYPE_P (type
)
6418 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
6419 && (overflow_p
|| TREE_OVERFLOW (TYPE_SIZE_UNIT (type
))))
6421 error ("size of array is too large");
6422 /* If we proceed with the array type as it is, we'll eventually
6423 crash in tree_to_[su]hwi(). */
6424 type
= error_mark_node
;
6431 /* Like c_mark_addressable but don't check register qualifier. */
6433 c_common_mark_addressable_vec (tree t
)
6435 if (TREE_CODE (t
) == C_MAYBE_CONST_EXPR
)
6436 t
= C_MAYBE_CONST_EXPR_EXPR (t
);
6437 while (handled_component_p (t
))
6438 t
= TREE_OPERAND (t
, 0);
6440 && TREE_CODE (t
) != PARM_DECL
6441 && TREE_CODE (t
) != COMPOUND_LITERAL_EXPR
)
6443 if (!VAR_P (t
) || !DECL_HARD_REGISTER (t
))
6444 TREE_ADDRESSABLE (t
) = 1;
6449 /* Used to help initialize the builtin-types.def table. When a type of
6450 the correct size doesn't exist, use error_mark_node instead of NULL.
6451 The later results in segfaults even when a decl using the type doesn't
6455 builtin_type_for_size (int size
, bool unsignedp
)
6457 tree type
= c_common_type_for_size (size
, unsignedp
);
6458 return type
? type
: error_mark_node
;
6461 /* A helper function for resolve_overloaded_builtin in resolving the
6462 overloaded __sync_ builtins. Returns a positive power of 2 if the
6463 first operand of PARAMS is a pointer to a supported data type.
6464 Returns 0 if an error is encountered.
6465 FETCH is true when FUNCTION is one of the _FETCH_OP_ or _OP_FETCH_
6469 sync_resolve_size (tree function
, vec
<tree
, va_gc
> *params
, bool fetch
)
6471 /* Type of the argument. */
6473 /* Type the argument points to. */
6477 if (vec_safe_is_empty (params
))
6479 error ("too few arguments to function %qE", function
);
6483 argtype
= type
= TREE_TYPE ((*params
)[0]);
6484 if (TREE_CODE (type
) == ARRAY_TYPE
&& c_dialect_cxx ())
6486 /* Force array-to-pointer decay for C++. */
6487 (*params
)[0] = default_conversion ((*params
)[0]);
6488 type
= TREE_TYPE ((*params
)[0]);
6490 if (TREE_CODE (type
) != POINTER_TYPE
)
6493 type
= TREE_TYPE (type
);
6494 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
6497 if (!COMPLETE_TYPE_P (type
))
6500 if (fetch
&& TREE_CODE (type
) == BOOLEAN_TYPE
)
6503 size
= tree_to_uhwi (TYPE_SIZE_UNIT (type
));
6504 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
6508 /* Issue the diagnostic only if the argument is valid, otherwise
6509 it would be redundant at best and could be misleading. */
6510 if (argtype
!= error_mark_node
)
6511 error ("operand type %qT is incompatible with argument %d of %qE",
6512 argtype
, 1, function
);
6516 /* A helper function for resolve_overloaded_builtin. Adds casts to
6517 PARAMS to make arguments match up with those of FUNCTION. Drops
6518 the variadic arguments at the end. Returns false if some error
6519 was encountered; true on success. */
6522 sync_resolve_params (location_t loc
, tree orig_function
, tree function
,
6523 vec
<tree
, va_gc
> *params
, bool orig_format
)
6525 function_args_iterator iter
;
6527 unsigned int parmnum
;
6529 function_args_iter_init (&iter
, TREE_TYPE (function
));
6530 /* We've declared the implementation functions to use "volatile void *"
6531 as the pointer parameter, so we shouldn't get any complaints from the
6532 call to check_function_arguments what ever type the user used. */
6533 function_args_iter_next (&iter
);
6534 ptype
= TREE_TYPE (TREE_TYPE ((*params
)[0]));
6535 ptype
= TYPE_MAIN_VARIANT (ptype
);
6537 /* For the rest of the values, we need to cast these to FTYPE, so that we
6538 don't get warnings for passing pointer types, etc. */
6544 arg_type
= function_args_iter_cond (&iter
);
6545 /* XXX void_type_node belies the abstraction. */
6546 if (arg_type
== void_type_node
)
6550 if (params
->length () <= parmnum
)
6552 error_at (loc
, "too few arguments to function %qE", orig_function
);
6556 /* Only convert parameters if arg_type is unsigned integer type with
6557 new format sync routines, i.e. don't attempt to convert pointer
6558 arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n),
6559 bool arguments (e.g. WEAK argument) or signed int arguments (memmodel
6561 if (TREE_CODE (arg_type
) == INTEGER_TYPE
&& TYPE_UNSIGNED (arg_type
))
6563 /* Ideally for the first conversion we'd use convert_for_assignment
6564 so that we get warnings for anything that doesn't match the pointer
6565 type. This isn't portable across the C and C++ front ends atm. */
6566 val
= (*params
)[parmnum
];
6567 val
= convert (ptype
, val
);
6568 val
= convert (arg_type
, val
);
6569 (*params
)[parmnum
] = val
;
6572 function_args_iter_next (&iter
);
6575 /* __atomic routines are not variadic. */
6576 if (!orig_format
&& params
->length () != parmnum
+ 1)
6578 error_at (loc
, "too many arguments to function %qE", orig_function
);
6582 /* The definition of these primitives is variadic, with the remaining
6583 being "an optional list of variables protected by the memory barrier".
6584 No clue what that's supposed to mean, precisely, but we consider all
6585 call-clobbered variables to be protected so we're safe. */
6586 params
->truncate (parmnum
+ 1);
6591 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6592 RESULT to make it match the type of the first pointer argument in
6596 sync_resolve_return (tree first_param
, tree result
, bool orig_format
)
6598 tree ptype
= TREE_TYPE (TREE_TYPE (first_param
));
6599 tree rtype
= TREE_TYPE (result
);
6600 ptype
= TYPE_MAIN_VARIANT (ptype
);
6602 /* New format doesn't require casting unless the types are the same size. */
6603 if (orig_format
|| tree_int_cst_equal (TYPE_SIZE (ptype
), TYPE_SIZE (rtype
)))
6604 return convert (ptype
, result
);
6609 /* This function verifies the PARAMS to generic atomic FUNCTION.
6610 It returns the size if all the parameters are the same size, otherwise
6611 0 is returned if the parameters are invalid. */
6614 get_atomic_generic_size (location_t loc
, tree function
,
6615 vec
<tree
, va_gc
> *params
)
6617 unsigned int n_param
;
6618 unsigned int n_model
;
6623 /* Determine the parameter makeup. */
6624 switch (DECL_FUNCTION_CODE (function
))
6626 case BUILT_IN_ATOMIC_EXCHANGE
:
6630 case BUILT_IN_ATOMIC_LOAD
:
6631 case BUILT_IN_ATOMIC_STORE
:
6635 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
6643 if (vec_safe_length (params
) != n_param
)
6645 error_at (loc
, "incorrect number of arguments to function %qE", function
);
6649 /* Get type of first parameter, and determine its size. */
6650 type_0
= TREE_TYPE ((*params
)[0]);
6651 if (TREE_CODE (type_0
) == ARRAY_TYPE
&& c_dialect_cxx ())
6653 /* Force array-to-pointer decay for C++. */
6654 (*params
)[0] = default_conversion ((*params
)[0]);
6655 type_0
= TREE_TYPE ((*params
)[0]);
6657 if (TREE_CODE (type_0
) != POINTER_TYPE
|| VOID_TYPE_P (TREE_TYPE (type_0
)))
6659 error_at (loc
, "argument 1 of %qE must be a non-void pointer type",
6664 /* Types must be compile time constant sizes. */
6665 if (TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type_0
)))) != INTEGER_CST
)
6668 "argument 1 of %qE must be a pointer to a constant size type",
6673 size_0
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (type_0
)));
6675 /* Zero size objects are not allowed. */
6679 "argument 1 of %qE must be a pointer to a nonzero size object",
6684 /* Check each other parameter is a pointer and the same size. */
6685 for (x
= 0; x
< n_param
- n_model
; x
++)
6688 tree type
= TREE_TYPE ((*params
)[x
]);
6689 /* __atomic_compare_exchange has a bool in the 4th position, skip it. */
6690 if (n_param
== 6 && x
== 3)
6692 if (TREE_CODE (type
) == ARRAY_TYPE
&& c_dialect_cxx ())
6694 /* Force array-to-pointer decay for C++. */
6695 (*params
)[x
] = default_conversion ((*params
)[x
]);
6696 type
= TREE_TYPE ((*params
)[x
]);
6698 if (!POINTER_TYPE_P (type
))
6700 error_at (loc
, "argument %d of %qE must be a pointer type", x
+ 1,
6704 else if (TYPE_SIZE_UNIT (TREE_TYPE (type
))
6705 && TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type
))))
6708 error_at (loc
, "argument %d of %qE must be a pointer to a constant "
6709 "size type", x
+ 1, function
);
6712 else if (FUNCTION_POINTER_TYPE_P (type
))
6714 error_at (loc
, "argument %d of %qE must not be a pointer to a "
6715 "function", x
+ 1, function
);
6718 tree type_size
= TYPE_SIZE_UNIT (TREE_TYPE (type
));
6719 size
= type_size
? tree_to_uhwi (type_size
) : 0;
6722 error_at (loc
, "size mismatch in argument %d of %qE", x
+ 1,
6728 /* Check memory model parameters for validity. */
6729 for (x
= n_param
- n_model
; x
< n_param
; x
++)
6731 tree p
= (*params
)[x
];
6732 if (!INTEGRAL_TYPE_P (TREE_TYPE (p
)))
6734 error_at (loc
, "non-integer memory model argument %d of %qE", x
+ 1,
6738 p
= fold_for_warn (p
);
6739 if (TREE_CODE (p
) == INTEGER_CST
)
6741 /* memmodel_base masks the low 16 bits, thus ignore any bits above
6742 it by using TREE_INT_CST_LOW instead of tree_to_*hwi. Those high
6743 bits will be checked later during expansion in target specific
6745 if (memmodel_base (TREE_INT_CST_LOW (p
)) >= MEMMODEL_LAST
)
6746 warning_at (loc
, OPT_Winvalid_memory_model
,
6747 "invalid memory model argument %d of %qE", x
+ 1,
6756 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N
6757 at the beginning of the parameter list PARAMS representing the size of the
6758 objects. This is to match the library ABI requirement. LOC is the location
6759 of the function call.
6760 The new function is returned if it needed rebuilding, otherwise NULL_TREE is
6761 returned to allow the external call to be constructed. */
6764 add_atomic_size_parameter (unsigned n
, location_t loc
, tree function
,
6765 vec
<tree
, va_gc
> *params
)
6769 /* Insert a SIZE_T parameter as the first param. If there isn't
6770 enough space, allocate a new vector and recursively re-build with that. */
6771 if (!params
->space (1))
6773 unsigned int z
, len
;
6774 vec
<tree
, va_gc
> *v
;
6777 len
= params
->length ();
6778 vec_alloc (v
, len
+ 1);
6779 v
->quick_push (build_int_cst (size_type_node
, n
));
6780 for (z
= 0; z
< len
; z
++)
6781 v
->quick_push ((*params
)[z
]);
6782 f
= build_function_call_vec (loc
, vNULL
, function
, v
, NULL
);
6787 /* Add the size parameter and leave as a function call for processing. */
6788 size_node
= build_int_cst (size_type_node
, n
);
6789 params
->quick_insert (0, size_node
);
6794 /* Return whether atomic operations for naturally aligned N-byte
6795 arguments are supported, whether inline or through libatomic. */
6797 atomic_size_supported_p (int n
)
6808 return targetm
.scalar_mode_supported_p (TImode
);
6815 /* This will process an __atomic_exchange function call, determine whether it
6816 needs to be mapped to the _N variation, or turned into a library call.
6817 LOC is the location of the builtin call.
6818 FUNCTION is the DECL that has been invoked;
6819 PARAMS is the argument list for the call. The return value is non-null
6820 TRUE is returned if it is translated into the proper format for a call to the
6821 external library, and NEW_RETURN is set the tree for that function.
6822 FALSE is returned if processing for the _N variation is required, and
6823 NEW_RETURN is set to the return value the result is copied into. */
6825 resolve_overloaded_atomic_exchange (location_t loc
, tree function
,
6826 vec
<tree
, va_gc
> *params
, tree
*new_return
)
6828 tree p0
, p1
, p2
, p3
;
6829 tree I_type
, I_type_ptr
;
6830 int n
= get_atomic_generic_size (loc
, function
, params
);
6832 /* Size of 0 is an error condition. */
6835 *new_return
= error_mark_node
;
6839 /* If not a lock-free size, change to the library generic format. */
6840 if (!atomic_size_supported_p (n
))
6842 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
6846 /* Otherwise there is a lockfree match, transform the call from:
6847 void fn(T* mem, T* desired, T* return, model)
6849 *return = (T) (fn (In* mem, (In) *desired, model)) */
6856 /* Create pointer to appropriate size. */
6857 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
6858 I_type_ptr
= build_pointer_type (I_type
);
6860 /* Convert object pointer to required type. */
6861 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
6863 /* Convert new value to required type, and dereference it. */
6864 p1
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
6865 p1
= build1 (VIEW_CONVERT_EXPR
, I_type
, p1
);
6868 /* Move memory model to the 3rd position, and end param list. */
6870 params
->truncate (3);
6872 /* Convert return pointer and dereference it for later assignment. */
6873 *new_return
= build_indirect_ref (loc
, p2
, RO_UNARY_STAR
);
6879 /* This will process an __atomic_compare_exchange function call, determine
6880 whether it needs to be mapped to the _N variation, or turned into a lib call.
6881 LOC is the location of the builtin call.
6882 FUNCTION is the DECL that has been invoked;
6883 PARAMS is the argument list for the call. The return value is non-null
6884 TRUE is returned if it is translated into the proper format for a call to the
6885 external library, and NEW_RETURN is set the tree for that function.
6886 FALSE is returned if processing for the _N variation is required. */
6889 resolve_overloaded_atomic_compare_exchange (location_t loc
, tree function
,
6890 vec
<tree
, va_gc
> *params
,
6894 tree I_type
, I_type_ptr
;
6895 int n
= get_atomic_generic_size (loc
, function
, params
);
6897 /* Size of 0 is an error condition. */
6900 *new_return
= error_mark_node
;
6904 /* If not a lock-free size, change to the library generic format. */
6905 if (!atomic_size_supported_p (n
))
6907 /* The library generic format does not have the weak parameter, so
6908 remove it from the param list. Since a parameter has been removed,
6909 we can be sure that there is room for the SIZE_T parameter, meaning
6910 there will not be a recursive rebuilding of the parameter list, so
6911 there is no danger this will be done twice. */
6914 (*params
)[3] = (*params
)[4];
6915 (*params
)[4] = (*params
)[5];
6916 params
->truncate (5);
6918 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
6922 /* Otherwise, there is a match, so the call needs to be transformed from:
6923 bool fn(T* mem, T* desired, T* return, weak, success, failure)
6925 bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */
6931 /* Create pointer to appropriate size. */
6932 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
6933 I_type_ptr
= build_pointer_type (I_type
);
6935 /* Convert object pointer to required type. */
6936 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
6939 /* Convert expected pointer to required type. */
6940 p1
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p1
);
6943 /* Convert desired value to required type, and dereference it. */
6944 p2
= build_indirect_ref (loc
, p2
, RO_UNARY_STAR
);
6945 p2
= build1 (VIEW_CONVERT_EXPR
, I_type
, p2
);
6948 /* The rest of the parameters are fine. NULL means no special return value
6955 /* This will process an __atomic_load function call, determine whether it
6956 needs to be mapped to the _N variation, or turned into a library call.
6957 LOC is the location of the builtin call.
6958 FUNCTION is the DECL that has been invoked;
6959 PARAMS is the argument list for the call. The return value is non-null
6960 TRUE is returned if it is translated into the proper format for a call to the
6961 external library, and NEW_RETURN is set the tree for that function.
6962 FALSE is returned if processing for the _N variation is required, and
6963 NEW_RETURN is set to the return value the result is copied into. */
6966 resolve_overloaded_atomic_load (location_t loc
, tree function
,
6967 vec
<tree
, va_gc
> *params
, tree
*new_return
)
6970 tree I_type
, I_type_ptr
;
6971 int n
= get_atomic_generic_size (loc
, function
, params
);
6973 /* Size of 0 is an error condition. */
6976 *new_return
= error_mark_node
;
6980 /* If not a lock-free size, change to the library generic format. */
6981 if (!atomic_size_supported_p (n
))
6983 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
6987 /* Otherwise, there is a match, so the call needs to be transformed from:
6988 void fn(T* mem, T* return, model)
6990 *return = (T) (fn ((In *) mem, model)) */
6996 /* Create pointer to appropriate size. */
6997 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
6998 I_type_ptr
= build_pointer_type (I_type
);
7000 /* Convert object pointer to required type. */
7001 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7004 /* Move memory model to the 2nd position, and end param list. */
7006 params
->truncate (2);
7008 /* Convert return pointer and dereference it for later assignment. */
7009 *new_return
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
7015 /* This will process an __atomic_store function call, determine whether it
7016 needs to be mapped to the _N variation, or turned into a library call.
7017 LOC is the location of the builtin call.
7018 FUNCTION is the DECL that has been invoked;
7019 PARAMS is the argument list for the call. The return value is non-null
7020 TRUE is returned if it is translated into the proper format for a call to the
7021 external library, and NEW_RETURN is set the tree for that function.
7022 FALSE is returned if processing for the _N variation is required, and
7023 NEW_RETURN is set to the return value the result is copied into. */
7026 resolve_overloaded_atomic_store (location_t loc
, tree function
,
7027 vec
<tree
, va_gc
> *params
, tree
*new_return
)
7030 tree I_type
, I_type_ptr
;
7031 int n
= get_atomic_generic_size (loc
, function
, params
);
7033 /* Size of 0 is an error condition. */
7036 *new_return
= error_mark_node
;
7040 /* If not a lock-free size, change to the library generic format. */
7041 if (!atomic_size_supported_p (n
))
7043 *new_return
= add_atomic_size_parameter (n
, loc
, function
, params
);
7047 /* Otherwise, there is a match, so the call needs to be transformed from:
7048 void fn(T* mem, T* value, model)
7050 fn ((In *) mem, (In) *value, model) */
7055 /* Create pointer to appropriate size. */
7056 I_type
= builtin_type_for_size (BITS_PER_UNIT
* n
, 1);
7057 I_type_ptr
= build_pointer_type (I_type
);
7059 /* Convert object pointer to required type. */
7060 p0
= build1 (VIEW_CONVERT_EXPR
, I_type_ptr
, p0
);
7063 /* Convert new value to required type, and dereference it. */
7064 p1
= build_indirect_ref (loc
, p1
, RO_UNARY_STAR
);
7065 p1
= build1 (VIEW_CONVERT_EXPR
, I_type
, p1
);
7068 /* The memory model is in the right spot already. Return is void. */
7069 *new_return
= NULL_TREE
;
7075 /* Some builtin functions are placeholders for other expressions. This
7076 function should be called immediately after parsing the call expression
7077 before surrounding code has committed to the type of the expression.
7079 LOC is the location of the builtin call.
7081 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7082 PARAMS is the argument list for the call. The return value is non-null
7083 when expansion is complete, and null if normal processing should
7087 resolve_overloaded_builtin (location_t loc
, tree function
,
7088 vec
<tree
, va_gc
> *params
)
7090 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
7092 /* Is function one of the _FETCH_OP_ or _OP_FETCH_ built-ins?
7093 Those are not valid to call with a pointer to _Bool (or C++ bool)
7094 and so must be rejected. */
7095 bool fetch_op
= true;
7096 bool orig_format
= true;
7097 tree new_return
= NULL_TREE
;
7099 switch (DECL_BUILT_IN_CLASS (function
))
7101 case BUILT_IN_NORMAL
:
7104 if (targetm
.resolve_overloaded_builtin
)
7105 return targetm
.resolve_overloaded_builtin (loc
, function
, params
);
7112 /* Handle BUILT_IN_NORMAL here. */
7115 case BUILT_IN_ATOMIC_EXCHANGE
:
7116 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
7117 case BUILT_IN_ATOMIC_LOAD
:
7118 case BUILT_IN_ATOMIC_STORE
:
7120 /* Handle these 4 together so that they can fall through to the next
7121 case if the call is transformed to an _N variant. */
7124 case BUILT_IN_ATOMIC_EXCHANGE
:
7126 if (resolve_overloaded_atomic_exchange (loc
, function
, params
,
7129 /* Change to the _N variant. */
7130 orig_code
= BUILT_IN_ATOMIC_EXCHANGE_N
;
7134 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE
:
7136 if (resolve_overloaded_atomic_compare_exchange (loc
, function
,
7140 /* Change to the _N variant. */
7141 orig_code
= BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
;
7144 case BUILT_IN_ATOMIC_LOAD
:
7146 if (resolve_overloaded_atomic_load (loc
, function
, params
,
7149 /* Change to the _N variant. */
7150 orig_code
= BUILT_IN_ATOMIC_LOAD_N
;
7153 case BUILT_IN_ATOMIC_STORE
:
7155 if (resolve_overloaded_atomic_store (loc
, function
, params
,
7158 /* Change to the _N variant. */
7159 orig_code
= BUILT_IN_ATOMIC_STORE_N
;
7167 case BUILT_IN_ATOMIC_EXCHANGE_N
:
7168 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
:
7169 case BUILT_IN_ATOMIC_LOAD_N
:
7170 case BUILT_IN_ATOMIC_STORE_N
:
7173 case BUILT_IN_ATOMIC_ADD_FETCH_N
:
7174 case BUILT_IN_ATOMIC_SUB_FETCH_N
:
7175 case BUILT_IN_ATOMIC_AND_FETCH_N
:
7176 case BUILT_IN_ATOMIC_NAND_FETCH_N
:
7177 case BUILT_IN_ATOMIC_XOR_FETCH_N
:
7178 case BUILT_IN_ATOMIC_OR_FETCH_N
:
7179 case BUILT_IN_ATOMIC_FETCH_ADD_N
:
7180 case BUILT_IN_ATOMIC_FETCH_SUB_N
:
7181 case BUILT_IN_ATOMIC_FETCH_AND_N
:
7182 case BUILT_IN_ATOMIC_FETCH_NAND_N
:
7183 case BUILT_IN_ATOMIC_FETCH_XOR_N
:
7184 case BUILT_IN_ATOMIC_FETCH_OR_N
:
7185 orig_format
= false;
7187 case BUILT_IN_SYNC_FETCH_AND_ADD_N
:
7188 case BUILT_IN_SYNC_FETCH_AND_SUB_N
:
7189 case BUILT_IN_SYNC_FETCH_AND_OR_N
:
7190 case BUILT_IN_SYNC_FETCH_AND_AND_N
:
7191 case BUILT_IN_SYNC_FETCH_AND_XOR_N
:
7192 case BUILT_IN_SYNC_FETCH_AND_NAND_N
:
7193 case BUILT_IN_SYNC_ADD_AND_FETCH_N
:
7194 case BUILT_IN_SYNC_SUB_AND_FETCH_N
:
7195 case BUILT_IN_SYNC_OR_AND_FETCH_N
:
7196 case BUILT_IN_SYNC_AND_AND_FETCH_N
:
7197 case BUILT_IN_SYNC_XOR_AND_FETCH_N
:
7198 case BUILT_IN_SYNC_NAND_AND_FETCH_N
:
7199 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
:
7200 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N
:
7201 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_N
:
7202 case BUILT_IN_SYNC_LOCK_RELEASE_N
:
7204 /* The following are not _FETCH_OPs and must be accepted with
7205 pointers to _Bool (or C++ bool). */
7208 (orig_code
!= BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
7209 && orig_code
!= BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N
7210 && orig_code
!= BUILT_IN_SYNC_LOCK_TEST_AND_SET_N
7211 && orig_code
!= BUILT_IN_SYNC_LOCK_RELEASE_N
);
7213 int n
= sync_resolve_size (function
, params
, fetch_op
);
7214 tree new_function
, first_param
, result
;
7215 enum built_in_function fncode
;
7218 return error_mark_node
;
7220 fncode
= (enum built_in_function
)((int)orig_code
+ exact_log2 (n
) + 1);
7221 new_function
= builtin_decl_explicit (fncode
);
7222 if (!sync_resolve_params (loc
, function
, new_function
, params
,
7224 return error_mark_node
;
7226 first_param
= (*params
)[0];
7227 result
= build_function_call_vec (loc
, vNULL
, new_function
, params
,
7229 if (result
== error_mark_node
)
7231 if (orig_code
!= BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
7232 && orig_code
!= BUILT_IN_SYNC_LOCK_RELEASE_N
7233 && orig_code
!= BUILT_IN_ATOMIC_STORE_N
7234 && orig_code
!= BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N
)
7235 result
= sync_resolve_return (first_param
, result
, orig_format
);
7238 /* Prevent -Wunused-value warning. */
7239 TREE_USED (result
) = true;
7241 /* If new_return is set, assign function to that expr and cast the
7242 result to void since the generic interface returned void. */
7245 /* Cast function result from I{1,2,4,8,16} to the required type. */
7246 result
= build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (new_return
), result
);
7247 result
= build2 (MODIFY_EXPR
, TREE_TYPE (new_return
), new_return
,
7249 TREE_SIDE_EFFECTS (result
) = 1;
7250 protected_set_expr_location (result
, loc
);
7251 result
= convert (void_type_node
, result
);
7261 /* vector_types_compatible_elements_p is used in type checks of vectors
7262 values used as operands of binary operators. Where it returns true, and
7263 the other checks of the caller succeed (being vector types in he first
7264 place, and matching number of elements), we can just treat the types
7265 as essentially the same.
7266 Contrast with vector_targets_convertible_p, which is used for vector
7267 pointer types, and vector_types_convertible_p, which will allow
7268 language-specific matches under the control of flag_lax_vector_conversions,
7269 and might still require a conversion. */
7270 /* True if vector types T1 and T2 can be inputs to the same binary
7271 operator without conversion.
7272 We don't check the overall vector size here because some of our callers
7273 want to give different error messages when the vectors are compatible
7274 except for the element count. */
7277 vector_types_compatible_elements_p (tree t1
, tree t2
)
7279 bool opaque
= TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
);
7280 t1
= TREE_TYPE (t1
);
7281 t2
= TREE_TYPE (t2
);
7283 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
7285 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
|| c1
== FIXED_POINT_TYPE
)
7286 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
7287 || c2
== FIXED_POINT_TYPE
));
7289 t1
= c_common_signed_type (t1
);
7290 t2
= c_common_signed_type (t2
);
7291 /* Equality works here because c_common_signed_type uses
7292 TYPE_MAIN_VARIANT. */
7295 if (opaque
&& c1
== c2
7296 && (c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
)
7297 && TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
7302 /* Check for missing format attributes on function pointers. LTYPE is
7303 the new type or left-hand side type. RTYPE is the old type or
7304 right-hand side type. Returns TRUE if LTYPE is missing the desired
7308 check_missing_format_attribute (tree ltype
, tree rtype
)
7310 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
7313 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
7314 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
7319 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
7320 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
7328 /* Setup a TYPE_DECL node as a typedef representation.
7330 X is a TYPE_DECL for a typedef statement. Create a brand new
7331 ..._TYPE node (which will be just a variant of the existing
7332 ..._TYPE node with identical properties) and then install X
7333 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
7335 The whole point here is to end up with a situation where each
7336 and every ..._TYPE node the compiler creates will be uniquely
7337 associated with AT MOST one node representing a typedef name.
7338 This way, even though the compiler substitutes corresponding
7339 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
7340 early on, later parts of the compiler can always do the reverse
7341 translation and get back the corresponding typedef name. For
7344 typedef struct S MY_TYPE;
7347 Later parts of the compiler might only know that `object' was of
7348 type `struct S' if it were not for code just below. With this
7349 code however, later parts of the compiler see something like:
7351 struct S' == struct S
7352 typedef struct S' MY_TYPE;
7355 And they can then deduce (from the node for type struct S') that
7356 the original object declaration was:
7360 Being able to do this is important for proper support of protoize,
7361 and also for generating precise symbolic debugging information
7362 which takes full account of the programmer's (typedef) vocabulary.
7364 Obviously, we don't want to generate a duplicate ..._TYPE node if
7365 the TYPE_DECL node that we are now processing really represents a
7366 standard built-in type. */
7369 set_underlying_type (tree x
)
7371 if (x
== error_mark_node
)
7373 if (DECL_IS_BUILTIN (x
) && TREE_CODE (TREE_TYPE (x
)) != ARRAY_TYPE
)
7375 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
7376 TYPE_NAME (TREE_TYPE (x
)) = x
;
7378 else if (TREE_TYPE (x
) != error_mark_node
7379 && DECL_ORIGINAL_TYPE (x
) == NULL_TREE
)
7381 tree tt
= TREE_TYPE (x
);
7382 DECL_ORIGINAL_TYPE (x
) = tt
;
7383 tt
= build_variant_type_copy (tt
);
7384 TYPE_STUB_DECL (tt
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
7387 /* Mark the type as used only when its type decl is decorated
7388 with attribute unused. */
7389 if (lookup_attribute ("unused", DECL_ATTRIBUTES (x
)))
7396 /* Record the types used by the current global variable declaration
7397 being parsed, so that we can decide later to emit their debug info.
7398 Those types are in types_used_by_cur_var_decl, and we are going to
7399 store them in the types_used_by_vars_hash hash table.
7400 DECL is the declaration of the global variable that has been parsed. */
7403 record_types_used_by_current_var_decl (tree decl
)
7405 gcc_assert (decl
&& DECL_P (decl
) && TREE_STATIC (decl
));
7407 while (types_used_by_cur_var_decl
&& !types_used_by_cur_var_decl
->is_empty ())
7409 tree type
= types_used_by_cur_var_decl
->pop ();
7410 types_used_by_var_decl_insert (type
, decl
);
7414 /* The C and C++ parsers both use vectors to hold function arguments.
7415 For efficiency, we keep a cache of unused vectors. This is the
7418 typedef vec
<tree
, va_gc
> *tree_gc_vec
;
7419 static GTY((deletable
)) vec
<tree_gc_vec
, va_gc
> *tree_vector_cache
;
7421 /* Return a new vector from the cache. If the cache is empty,
7422 allocate a new vector. These vectors are GC'ed, so it is OK if the
7423 pointer is not released.. */
7426 make_tree_vector (void)
7428 if (tree_vector_cache
&& !tree_vector_cache
->is_empty ())
7429 return tree_vector_cache
->pop ();
7432 /* Passing 0 to vec::alloc returns NULL, and our callers require
7433 that we always return a non-NULL value. The vector code uses
7434 4 when growing a NULL vector, so we do too. */
7435 vec
<tree
, va_gc
> *v
;
7441 /* Release a vector of trees back to the cache. */
7444 release_tree_vector (vec
<tree
, va_gc
> *vec
)
7449 vec_safe_push (tree_vector_cache
, vec
);
7453 /* Get a new tree vector holding a single tree. */
7456 make_tree_vector_single (tree t
)
7458 vec
<tree
, va_gc
> *ret
= make_tree_vector ();
7459 ret
->quick_push (t
);
7463 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */
7466 make_tree_vector_from_list (tree list
)
7468 vec
<tree
, va_gc
> *ret
= make_tree_vector ();
7469 for (; list
; list
= TREE_CHAIN (list
))
7470 vec_safe_push (ret
, TREE_VALUE (list
));
7474 /* Get a new tree vector of the values of a CONSTRUCTOR. */
7477 make_tree_vector_from_ctor (tree ctor
)
7479 vec
<tree
,va_gc
> *ret
= make_tree_vector ();
7480 vec_safe_reserve (ret
, CONSTRUCTOR_NELTS (ctor
));
7481 for (unsigned i
= 0; i
< CONSTRUCTOR_NELTS (ctor
); ++i
)
7482 ret
->quick_push (CONSTRUCTOR_ELT (ctor
, i
)->value
);
7486 /* Get a new tree vector which is a copy of an existing one. */
7489 make_tree_vector_copy (const vec
<tree
, va_gc
> *orig
)
7491 vec
<tree
, va_gc
> *ret
;
7495 ret
= make_tree_vector ();
7496 vec_safe_reserve (ret
, vec_safe_length (orig
));
7497 FOR_EACH_VEC_SAFE_ELT (orig
, ix
, t
)
7498 ret
->quick_push (t
);
7502 /* Return true if KEYWORD starts a type specifier. */
7505 keyword_begins_type_specifier (enum rid keyword
)
7538 if (keyword
>= RID_FIRST_INT_N
7539 && keyword
< RID_FIRST_INT_N
+ NUM_INT_N_ENTS
7540 && int_n_enabled_p
[keyword
-RID_FIRST_INT_N
])
7546 /* Return true if KEYWORD names a type qualifier. */
7549 keyword_is_type_qualifier (enum rid keyword
)
7563 /* Return true if KEYWORD names a storage class specifier.
7565 RID_TYPEDEF is not included in this list despite `typedef' being
7566 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
7567 such for syntactic convenience only. */
7570 keyword_is_storage_class_specifier (enum rid keyword
)
7586 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
7589 keyword_is_function_specifier (enum rid keyword
)
7603 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
7604 declaration-specifier (C99 6.7). */
7607 keyword_is_decl_specifier (enum rid keyword
)
7609 if (keyword_is_storage_class_specifier (keyword
)
7610 || keyword_is_type_qualifier (keyword
)
7611 || keyword_is_function_specifier (keyword
))
7625 /* Initialize language-specific-bits of tree_contains_struct. */
7628 c_common_init_ts (void)
7630 MARK_TS_TYPED (C_MAYBE_CONST_EXPR
);
7631 MARK_TS_TYPED (EXCESS_PRECISION_EXPR
);
7634 /* Build a user-defined numeric literal out of an integer constant type VALUE
7635 with identifier SUFFIX. */
7638 build_userdef_literal (tree suffix_id
, tree value
,
7639 enum overflow_type overflow
, tree num_string
)
7641 tree literal
= make_node (USERDEF_LITERAL
);
7642 USERDEF_LITERAL_SUFFIX_ID (literal
) = suffix_id
;
7643 USERDEF_LITERAL_VALUE (literal
) = value
;
7644 USERDEF_LITERAL_OVERFLOW (literal
) = overflow
;
7645 USERDEF_LITERAL_NUM_STRING (literal
) = num_string
;
7649 /* For vector[index], convert the vector to an array of the underlying type.
7650 Return true if the resulting ARRAY_REF should not be an lvalue. */
7653 convert_vector_to_array_for_subscript (location_t loc
,
7654 tree
*vecp
, tree index
)
7657 if (VECTOR_TYPE_P (TREE_TYPE (*vecp
)))
7659 tree type
= TREE_TYPE (*vecp
);
7661 ret
= !lvalue_p (*vecp
);
7663 if (TREE_CODE (index
) == INTEGER_CST
)
7664 if (!tree_fits_uhwi_p (index
)
7665 || maybe_ge (tree_to_uhwi (index
), TYPE_VECTOR_SUBPARTS (type
)))
7666 warning_at (loc
, OPT_Warray_bounds
, "index value is out of bound");
7668 /* We are building an ARRAY_REF so mark the vector as addressable
7669 to not run into the gimplifiers premature setting of DECL_GIMPLE_REG_P
7670 for function parameters. */
7671 c_common_mark_addressable_vec (*vecp
);
7673 *vecp
= build1 (VIEW_CONVERT_EXPR
,
7674 build_array_type_nelts (TREE_TYPE (type
),
7675 TYPE_VECTOR_SUBPARTS (type
)),
7681 /* Determine which of the operands, if any, is a scalar that needs to be
7682 converted to a vector, for the range of operations. */
7684 scalar_to_vector (location_t loc
, enum tree_code code
, tree op0
, tree op1
,
7687 tree type0
= TREE_TYPE (op0
);
7688 tree type1
= TREE_TYPE (op1
);
7689 bool integer_only_op
= false;
7690 enum stv_conv ret
= stv_firstarg
;
7692 gcc_assert (VECTOR_TYPE_P (type0
) || VECTOR_TYPE_P (type1
));
7695 /* Most GENERIC binary expressions require homogeneous arguments.
7696 LSHIFT_EXPR and RSHIFT_EXPR are exceptions and accept a first
7697 argument that is a vector and a second one that is a scalar, so
7698 we never return stv_secondarg for them. */
7701 if (TREE_CODE (type0
) == INTEGER_TYPE
7702 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
7704 if (unsafe_conversion_p (loc
, TREE_TYPE (type1
), op0
,
7708 error_at (loc
, "conversion of scalar %qT to vector %qT "
7709 "involves truncation", type0
, type1
);
7713 return stv_firstarg
;
7720 integer_only_op
= true;
7728 case TRUNC_DIV_EXPR
:
7730 case FLOOR_DIV_EXPR
:
7731 case ROUND_DIV_EXPR
:
7732 case EXACT_DIV_EXPR
:
7733 case TRUNC_MOD_EXPR
:
7734 case FLOOR_MOD_EXPR
:
7742 /* What about UNLT_EXPR? */
7743 if (VECTOR_TYPE_P (type0
))
7745 ret
= stv_secondarg
;
7746 std::swap (type0
, type1
);
7747 std::swap (op0
, op1
);
7750 if (TREE_CODE (type0
) == INTEGER_TYPE
7751 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
7753 if (unsafe_conversion_p (loc
, TREE_TYPE (type1
), op0
,
7757 error_at (loc
, "conversion of scalar %qT to vector %qT "
7758 "involves truncation", type0
, type1
);
7763 else if (!integer_only_op
7764 /* Allow integer --> real conversion if safe. */
7765 && (TREE_CODE (type0
) == REAL_TYPE
7766 || TREE_CODE (type0
) == INTEGER_TYPE
)
7767 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (type1
)))
7769 if (unsafe_conversion_p (loc
, TREE_TYPE (type1
), op0
,
7773 error_at (loc
, "conversion of scalar %qT to vector %qT "
7774 "involves truncation", type0
, type1
);
7786 /* Return the alignment of std::max_align_t.
7788 [support.types.layout] The type max_align_t is a POD type whose alignment
7789 requirement is at least as great as that of every scalar type, and whose
7790 alignment requirement is supported in every context. */
7793 max_align_t_align ()
7795 unsigned int max_align
= MAX (TYPE_ALIGN (long_long_integer_type_node
),
7796 TYPE_ALIGN (long_double_type_node
));
7797 if (float128_type_node
!= NULL_TREE
)
7798 max_align
= MAX (max_align
, TYPE_ALIGN (float128_type_node
));
7802 /* Return true iff ALIGN is an integral constant that is a fundamental
7803 alignment, as defined by [basic.align] in the c++-11
7808 [A fundamental alignment is represented by an alignment less than or
7809 equal to the greatest alignment supported by the implementation
7810 in all contexts, which is equal to alignof(max_align_t)]. */
7813 cxx_fundamental_alignment_p (unsigned align
)
7815 return (align
<= max_align_t_align ());
7818 /* Return true if T is a pointer to a zero-sized aggregate. */
7821 pointer_to_zero_sized_aggr_p (tree t
)
7823 if (!POINTER_TYPE_P (t
))
7826 return (TYPE_SIZE (t
) && integer_zerop (TYPE_SIZE (t
)));
7829 /* For an EXPR of a FUNCTION_TYPE that references a GCC built-in function
7830 with no library fallback or for an ADDR_EXPR whose operand is such type
7831 issues an error pointing to the location LOC.
7832 Returns true when the expression has been diagnosed and false
7836 reject_gcc_builtin (const_tree expr
, location_t loc
/* = UNKNOWN_LOCATION */)
7838 if (TREE_CODE (expr
) == ADDR_EXPR
)
7839 expr
= TREE_OPERAND (expr
, 0);
7841 STRIP_ANY_LOCATION_WRAPPER (expr
);
7843 if (TREE_TYPE (expr
)
7844 && TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
7845 && TREE_CODE (expr
) == FUNCTION_DECL
7846 /* The intersection of DECL_BUILT_IN and DECL_IS_BUILTIN avoids
7847 false positives for user-declared built-ins such as abs or
7848 strlen, and for C++ operators new and delete.
7849 The c_decl_implicit() test avoids false positives for implicitly
7850 declared built-ins with library fallbacks (such as abs). */
7851 && DECL_BUILT_IN (expr
)
7852 && DECL_IS_BUILTIN (expr
)
7853 && !c_decl_implicit (expr
)
7854 && !DECL_ASSEMBLER_NAME_SET_P (expr
))
7856 if (loc
== UNKNOWN_LOCATION
)
7857 loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
7859 /* Reject arguments that are built-in functions with
7860 no library fallback. */
7861 error_at (loc
, "built-in function %qE must be directly called", expr
);
7869 /* Check if array size calculations overflow or if the array covers more
7870 than half of the address space. Return true if the size of the array
7871 is valid, false otherwise. TYPE is the type of the array and NAME is
7872 the name of the array, or NULL_TREE for unnamed arrays. */
7875 valid_array_size_p (location_t loc
, tree type
, tree name
, bool complain
)
7877 if (type
!= error_mark_node
7878 && COMPLETE_TYPE_P (type
)
7879 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
7880 && !valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
7885 error_at (loc
, "size of array %qE is too large", name
);
7887 error_at (loc
, "size of unnamed array is too large");
7894 /* Read SOURCE_DATE_EPOCH from environment to have a deterministic
7895 timestamp to replace embedded current dates to get reproducible
7896 results. Returns -1 if SOURCE_DATE_EPOCH is not defined. */
7899 cb_get_source_date_epoch (cpp_reader
*pfile ATTRIBUTE_UNUSED
)
7901 char *source_date_epoch
;
7905 source_date_epoch
= getenv ("SOURCE_DATE_EPOCH");
7906 if (!source_date_epoch
)
7910 #if defined(INT64_T_IS_LONG)
7911 epoch
= strtol (source_date_epoch
, &endptr
, 10);
7913 epoch
= strtoll (source_date_epoch
, &endptr
, 10);
7915 if (errno
!= 0 || endptr
== source_date_epoch
|| *endptr
!= '\0'
7916 || epoch
< 0 || epoch
> MAX_SOURCE_DATE_EPOCH
)
7918 error_at (input_location
, "environment variable SOURCE_DATE_EPOCH must "
7919 "expand to a non-negative integer less than or equal to %wd",
7920 MAX_SOURCE_DATE_EPOCH
);
7924 return (time_t) epoch
;
7927 /* Callback for libcpp for offering spelling suggestions for misspelled
7928 directives. GOAL is an unrecognized string; CANDIDATES is a
7929 NULL-terminated array of candidate strings. Return the closest
7930 match to GOAL within CANDIDATES, or NULL if none are good
7934 cb_get_suggestion (cpp_reader
*, const char *goal
,
7935 const char *const *candidates
)
7937 best_match
<const char *, const char *> bm (goal
);
7939 bm
.consider (*candidates
++);
7940 return bm
.get_best_meaningful_candidate ();
7943 /* Return the latice point which is the wider of the two FLT_EVAL_METHOD
7944 modes X, Y. This isn't just >, as the FLT_EVAL_METHOD values added
7945 by C TS 18661-3 for interchange types that are computed in their
7946 native precision are larger than the C11 values for evaluating in the
7947 precision of float/double/long double. If either mode is
7948 FLT_EVAL_METHOD_UNPREDICTABLE, return that. */
7950 enum flt_eval_method
7951 excess_precision_mode_join (enum flt_eval_method x
,
7952 enum flt_eval_method y
)
7954 if (x
== FLT_EVAL_METHOD_UNPREDICTABLE
7955 || y
== FLT_EVAL_METHOD_UNPREDICTABLE
)
7956 return FLT_EVAL_METHOD_UNPREDICTABLE
;
7958 /* GCC only supports one interchange type right now, _Float16. If
7959 we're evaluating _Float16 in 16-bit precision, then flt_eval_method
7960 will be FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */
7961 if (x
== FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
)
7963 if (y
== FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
)
7966 /* Other values for flt_eval_method are directly comparable, and we want
7971 /* Return the value that should be set for FLT_EVAL_METHOD in the
7972 context of ISO/IEC TS 18861-3.
7974 This relates to the effective excess precision seen by the user,
7975 which is the join point of the precision the target requests for
7976 -fexcess-precision={standard,fast} and the implicit excess precision
7979 static enum flt_eval_method
7980 c_ts18661_flt_eval_method (void)
7982 enum flt_eval_method implicit
7983 = targetm
.c
.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT
);
7985 enum excess_precision_type flag_type
7986 = (flag_excess_precision_cmdline
== EXCESS_PRECISION_STANDARD
7987 ? EXCESS_PRECISION_TYPE_STANDARD
7988 : EXCESS_PRECISION_TYPE_FAST
);
7990 enum flt_eval_method requested
7991 = targetm
.c
.excess_precision (flag_type
);
7993 return excess_precision_mode_join (implicit
, requested
);
7996 /* As c_cpp_ts18661_flt_eval_method, but clamps the expected values to
7997 those that were permitted by C11. That is to say, eliminates
7998 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */
8000 static enum flt_eval_method
8001 c_c11_flt_eval_method (void)
8003 return excess_precision_mode_join (c_ts18661_flt_eval_method (),
8004 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
);
8007 /* Return the value that should be set for FLT_EVAL_METHOD.
8008 MAYBE_C11_ONLY_P is TRUE if we should check
8009 FLAG_PERMITTED_EVAL_METHODS as to whether we should limit the possible
8010 values we can return to those from C99/C11, and FALSE otherwise.
8011 See the comments on c_ts18661_flt_eval_method for what value we choose
8015 c_flt_eval_method (bool maybe_c11_only_p
)
8017 if (maybe_c11_only_p
8018 && flag_permitted_flt_eval_methods
8019 == PERMITTED_FLT_EVAL_METHODS_C11
)
8020 return c_c11_flt_eval_method ();
8022 return c_ts18661_flt_eval_method ();
8025 /* An enum for get_missing_token_insertion_kind for describing the best
8026 place to insert a missing token, if there is one. */
8028 enum missing_token_insertion_kind
8031 MTIK_INSERT_BEFORE_NEXT
,
8032 MTIK_INSERT_AFTER_PREV
8035 /* Given a missing token of TYPE, determine if it is reasonable to
8036 emit a fix-it hint suggesting the insertion of the token, and,
8037 if so, where the token should be inserted relative to other tokens.
8039 It only makes sense to do this for values of TYPE that are symbols.
8041 Some symbols should go before the next token, e.g. in:
8043 we want to insert the missing '(' immediately before "flag",
8048 These use MTIK_INSERT_BEFORE_NEXT.
8050 Other symbols should go after the previous token, e.g. in:
8053 we want to insert the missing ')' immediately after the "flag",
8060 These use MTIK_INSERT_AFTER_PREV. */
8062 static enum missing_token_insertion_kind
8063 get_missing_token_insertion_kind (enum cpp_ttype type
)
8067 /* Insert missing "opening" brackets immediately
8068 before the next token. */
8069 case CPP_OPEN_SQUARE
:
8070 case CPP_OPEN_PAREN
:
8071 return MTIK_INSERT_BEFORE_NEXT
;
8073 /* Insert other missing symbols immediately after
8074 the previous token. */
8075 case CPP_CLOSE_PAREN
:
8076 case CPP_CLOSE_SQUARE
:
8080 return MTIK_INSERT_AFTER_PREV
;
8082 /* Other kinds of token don't get fix-it hints. */
8084 return MTIK_IMPOSSIBLE
;
8088 /* Given RICHLOC, a location for a diagnostic describing a missing token
8089 of kind TOKEN_TYPE, potentially add a fix-it hint suggesting the
8090 insertion of the token.
8092 The location of the attempted fix-it hint depends on TOKEN_TYPE:
8094 (a) immediately after PREV_TOKEN_LOC, or
8096 (b) immediately before the primary location within RICHLOC (taken to
8097 be that of the token following where the token was expected).
8099 If we manage to add a fix-it hint, then the location of the
8100 fix-it hint is likely to be more useful as the primary location
8101 of the diagnostic than that of the following token, so we swap
8104 For example, given this bogus code:
8105 123456789012345678901234567890
8106 1 | int missing_semicolon (void)
8113 "expected ';' before '}'"
8115 RICHLOC's primary location is at the closing brace, so before "swapping"
8116 we would emit the error at line 4 column 1:
8118 123456789012345678901234567890
8119 3 | return 42 |< fix-it hint emitted for this line
8121 4 | } |< "expected ';' before '}'" emitted at this line
8124 It's more useful for the location of the diagnostic to be at the
8125 fix-it hint, so we swap the locations, so the primary location
8126 is at the fix-it hint, with the old primary location inserted
8127 as a secondary location, giving this, with the error at line 3
8130 123456789012345678901234567890
8131 3 | return 42 |< "expected ';' before '}'" emitted at this line,
8132 | ^ | with fix-it hint
8134 | } |< secondary range emitted here
8138 maybe_suggest_missing_token_insertion (rich_location
*richloc
,
8139 enum cpp_ttype token_type
,
8140 location_t prev_token_loc
)
8142 gcc_assert (richloc
);
8144 enum missing_token_insertion_kind mtik
8145 = get_missing_token_insertion_kind (token_type
);
8153 case MTIK_IMPOSSIBLE
:
8156 case MTIK_INSERT_BEFORE_NEXT
:
8157 /* Attempt to add the fix-it hint before the primary location
8159 richloc
->add_fixit_insert_before (cpp_type2name (token_type
, 0));
8162 case MTIK_INSERT_AFTER_PREV
:
8163 /* Attempt to add the fix-it hint after PREV_TOKEN_LOC. */
8164 richloc
->add_fixit_insert_after (prev_token_loc
,
8165 cpp_type2name (token_type
, 0));
8169 /* If we were successful, use the fix-it hint's location as the
8170 primary location within RICHLOC, adding the old primary location
8171 back as a secondary location. */
8172 if (!richloc
->seen_impossible_fixit_p ())
8174 fixit_hint
*hint
= richloc
->get_last_fixit_hint ();
8175 location_t hint_loc
= hint
->get_start_loc ();
8176 location_t old_loc
= richloc
->get_loc ();
8178 richloc
->set_range (line_table
, 0, hint_loc
, true);
8179 richloc
->add_range (old_loc
, false);
8185 namespace selftest
{
8187 /* Verify that fold_for_warn on error_mark_node is safe. */
8190 test_fold_for_warn ()
8192 ASSERT_EQ (error_mark_node
, fold_for_warn (error_mark_node
));
8195 /* Run all of the selftests within this file. */
8200 test_fold_for_warn ();
8203 /* Run all of the tests within c-family. */
8206 c_family_tests (void)
8208 c_common_c_tests ();
8209 c_format_c_tests ();
8210 c_pretty_print_c_tests ();
8211 c_spellcheck_cc_tests ();
8214 } // namespace selftest
8216 #endif /* #if CHECKING_P */
8218 /* Attempt to locate a suitable location within FILE for a
8219 #include directive to be inserted before. FILE should
8220 be a string from libcpp (pointer equality is used).
8221 LOC is the location of the relevant diagnostic.
8223 Attempt to return the location within FILE immediately
8224 after the last #include within that file, or the start of
8225 that file if it has no #include directives.
8227 Return UNKNOWN_LOCATION if no suitable location is found,
8228 or if an error occurs. */
8231 try_to_locate_new_include_insertion_point (const char *file
, location_t loc
)
8233 /* Locate the last ordinary map within FILE that ended with a #include. */
8234 const line_map_ordinary
*last_include_ord_map
= NULL
;
8236 /* ...and the next ordinary map within FILE after that one. */
8237 const line_map_ordinary
*last_ord_map_after_include
= NULL
;
8239 /* ...and the first ordinary map within FILE. */
8240 const line_map_ordinary
*first_ord_map_in_file
= NULL
;
8242 /* Get ordinary map containing LOC (or its expansion). */
8243 const line_map_ordinary
*ord_map_for_loc
= NULL
;
8244 loc
= linemap_resolve_location (line_table
, loc
, LRK_MACRO_EXPANSION_POINT
,
8246 gcc_assert (ord_map_for_loc
);
8248 for (unsigned int i
= 0; i
< LINEMAPS_ORDINARY_USED (line_table
); i
++)
8250 const line_map_ordinary
*ord_map
8251 = LINEMAPS_ORDINARY_MAP_AT (line_table
, i
);
8253 const line_map_ordinary
*from
= INCLUDED_FROM (line_table
, ord_map
);
8255 if (from
->to_file
== file
)
8257 last_include_ord_map
= from
;
8258 last_ord_map_after_include
= NULL
;
8261 if (ord_map
->to_file
== file
)
8263 if (!first_ord_map_in_file
)
8264 first_ord_map_in_file
= ord_map
;
8265 if (last_include_ord_map
&& !last_ord_map_after_include
)
8266 last_ord_map_after_include
= ord_map
;
8269 /* Stop searching when reaching the ord_map containing LOC,
8270 as it makes no sense to provide fix-it hints that appear
8271 after the diagnostic in question. */
8272 if (ord_map
== ord_map_for_loc
)
8276 /* Determine where to insert the #include. */
8277 const line_map_ordinary
*ord_map_for_insertion
;
8279 /* We want the next ordmap in the file after the last one that's a
8280 #include, but failing that, the start of the file. */
8281 if (last_ord_map_after_include
)
8282 ord_map_for_insertion
= last_ord_map_after_include
;
8284 ord_map_for_insertion
= first_ord_map_in_file
;
8286 if (!ord_map_for_insertion
)
8287 return UNKNOWN_LOCATION
;
8289 /* The "start_location" is column 0, meaning "the whole line".
8290 rich_location and edit_context can't cope with this, so use
8291 column 1 instead. */
8292 location_t col_0
= ord_map_for_insertion
->start_location
;
8293 return linemap_position_for_loc_and_offset (line_table
, col_0
, 1);
8296 /* A map from filenames to sets of headers added to them, for
8297 ensuring idempotency within maybe_add_include_fixit. */
8299 /* The values within the map. We need string comparison as there's
8300 no guarantee that two different diagnostics that are recommending
8301 adding e.g. "<stdio.h>" are using the same buffer. */
8303 typedef hash_set
<const char *, nofree_string_hash
> per_file_includes_t
;
8305 /* The map itself. We don't need string comparison for the filename keys,
8306 as they come from libcpp. */
8308 typedef hash_map
<const char *, per_file_includes_t
*> added_includes_t
;
8309 static added_includes_t
*added_includes
;
8311 /* Attempt to add a fix-it hint to RICHLOC, adding "#include HEADER\n"
8312 in a suitable location within the file of RICHLOC's primary
8315 This function is idempotent: a header will be added at most once to
8319 maybe_add_include_fixit (rich_location
*richloc
, const char *header
)
8321 location_t loc
= richloc
->get_loc ();
8322 const char *file
= LOCATION_FILE (loc
);
8326 /* Idempotency: don't add the same header more than once to a given file. */
8327 if (!added_includes
)
8328 added_includes
= new added_includes_t ();
8329 per_file_includes_t
*&set
= added_includes
->get_or_insert (file
);
8331 if (set
->contains (header
))
8332 /* ...then we've already added HEADER to that file. */
8335 set
= new per_file_includes_t ();
8338 /* Attempt to locate a suitable place for the new directive. */
8339 location_t include_insert_loc
8340 = try_to_locate_new_include_insertion_point (file
, loc
);
8341 if (include_insert_loc
== UNKNOWN_LOCATION
)
8344 char *text
= xasprintf ("#include %s\n", header
);
8345 richloc
->add_fixit_insert_before (include_insert_loc
, text
);
8349 #include "gt-c-family-c-common.h"