1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
37 #include "langhooks.h"
38 #include "tree-inline.h"
40 #include "diagnostic.h"
41 #include "tree-iterator.h"
43 #include "tree-mudflap.h"
46 #include "target-def.h"
49 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
51 /* The following symbols are subsumed in the c_global_trees array, and
52 listed here individually for documentation purposes.
54 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
56 tree short_integer_type_node;
57 tree long_integer_type_node;
58 tree long_long_integer_type_node;
59 tree int128_integer_type_node;
61 tree short_unsigned_type_node;
62 tree long_unsigned_type_node;
63 tree long_long_unsigned_type_node;
64 tree int128_unsigned_type_node;
66 tree truthvalue_type_node;
67 tree truthvalue_false_node;
68 tree truthvalue_true_node;
70 tree ptrdiff_type_node;
72 tree unsigned_char_type_node;
73 tree signed_char_type_node;
76 tree char16_type_node;
77 tree char32_type_node;
80 tree double_type_node;
81 tree long_double_type_node;
83 tree complex_integer_type_node;
84 tree complex_float_type_node;
85 tree complex_double_type_node;
86 tree complex_long_double_type_node;
88 tree dfloat32_type_node;
89 tree dfloat64_type_node;
90 tree_dfloat128_type_node;
98 tree unsigned_intQI_type_node;
99 tree unsigned_intHI_type_node;
100 tree unsigned_intSI_type_node;
101 tree unsigned_intDI_type_node;
102 tree unsigned_intTI_type_node;
104 tree widest_integer_literal_type_node;
105 tree widest_unsigned_literal_type_node;
107 Nodes for types `void *' and `const void *'.
109 tree ptr_type_node, const_ptr_type_node;
111 Nodes for types `char *' and `const char *'.
113 tree string_type_node, const_string_type_node;
115 Type `char[SOMENUMBER]'.
116 Used when an array of char is needed and the size is irrelevant.
118 tree char_array_type_node;
120 Type `int[SOMENUMBER]' or something like it.
121 Used when an array of int needed and the size is irrelevant.
123 tree int_array_type_node;
125 Type `wchar_t[SOMENUMBER]' or something like it.
126 Used when a wide string literal is created.
128 tree wchar_array_type_node;
130 Type `char16_t[SOMENUMBER]' or something like it.
131 Used when a UTF-16 string literal is created.
133 tree char16_array_type_node;
135 Type `char32_t[SOMENUMBER]' or something like it.
136 Used when a UTF-32 string literal is created.
138 tree char32_array_type_node;
140 Type `int ()' -- used for implicit declaration of functions.
142 tree default_function_type;
144 A VOID_TYPE node, packaged in a TREE_LIST.
148 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
149 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
150 VAR_DECLS, but C++ does.)
152 tree function_name_decl_node;
153 tree pretty_function_name_decl_node;
154 tree c99_function_name_decl_node;
156 Stack of nested function name VAR_DECLs.
158 tree saved_function_name_decls;
162 tree c_global_trees
[CTI_MAX
];
164 /* Switches common to the C front ends. */
166 /* Nonzero means don't output line number information. */
168 char flag_no_line_commands
;
170 /* Nonzero causes -E output not to be done, but directives such as
171 #define that have side effects are still obeyed. */
175 /* Nonzero means dump macros in some fashion. */
177 char flag_dump_macros
;
179 /* Nonzero means pass #include lines through to the output. */
181 char flag_dump_includes
;
183 /* Nonzero means process PCH files while preprocessing. */
185 bool flag_pch_preprocess
;
187 /* The file name to which we should write a precompiled header, or
188 NULL if no header will be written in this compile. */
190 const char *pch_file
;
192 /* Nonzero if an ISO standard was selected. It rejects macros in the
196 /* Warn about #pragma directives that are not recognized. */
198 int warn_unknown_pragmas
; /* Tri state variable. */
200 /* Warn about format/argument anomalies in calls to formatted I/O functions
201 (*printf, *scanf, strftime, strfmon, etc.). */
205 /* C/ObjC language option variables. */
208 /* Nonzero means allow type mismatches in conditional expressions;
209 just make their values `void'. */
211 int flag_cond_mismatch
;
213 /* Nonzero means enable C89 Amendment 1 features. */
217 /* Nonzero means use the ISO C99 (or C1X) dialect of C. */
221 /* Nonzero means use the ISO C1X dialect of C. */
225 /* Nonzero means that we have builtin functions, and main is an int. */
230 /* ObjC language option variables. */
233 /* Tells the compiler that this is a special run. Do not perform any
234 compiling, instead we are to test some platform dependent features
235 and output a C header file with appropriate definitions. */
237 int print_struct_values
;
239 /* Tells the compiler what is the constant string class for ObjC. */
241 const char *constant_string_class_name
;
244 /* C++ language option variables. */
247 /* Nonzero means generate separate instantiation control files and
248 juggle them at link time. */
250 int flag_use_repository
;
252 /* The C++ dialect being used. C++98 is the default. */
254 enum cxx_dialect cxx_dialect
= cxx98
;
256 /* Maximum template instantiation depth. This limit exists to limit the
257 time it takes to notice infinite template instantiations; the default
258 value of 1024 is likely to be in the next C++ standard. */
260 int max_tinst_depth
= 1024;
264 /* The elements of `ridpointers' are identifier nodes for the reserved
265 type names and storage classes. It is indexed by a RID_... value. */
268 tree (*make_fname_decl
) (location_t
, tree
, int);
270 /* Nonzero means don't warn about problems that occur when the code is
272 int c_inhibit_evaluation_warnings
;
274 /* Whether lexing has been completed, so subsequent preprocessor
275 errors should use the compiler's input_location. */
276 bool done_lexing
= false;
278 /* Information about how a function name is generated. */
281 tree
*const decl
; /* pointer to the VAR_DECL. */
282 const unsigned rid
; /* RID number for the identifier. */
283 const int pretty
; /* How pretty is it? */
286 /* The three ways of getting then name of the current function. */
288 const struct fname_var_t fname_vars
[] =
290 /* C99 compliant __func__, must be first. */
291 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
292 /* GCC __FUNCTION__ compliant. */
293 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
294 /* GCC __PRETTY_FUNCTION__ compliant. */
295 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
299 static tree
c_fully_fold_internal (tree expr
, bool, bool *, bool *);
300 static tree
check_case_value (tree
);
301 static bool check_case_bounds (tree
, tree
, tree
*, tree
*);
303 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
304 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
305 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
306 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
307 static tree
handle_hot_attribute (tree
*, tree
, tree
, int, bool *);
308 static tree
handle_cold_attribute (tree
*, tree
, tree
, int, bool *);
309 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
310 static tree
handle_noclone_attribute (tree
*, tree
, tree
, int, bool *);
311 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
313 static tree
handle_gnu_inline_attribute (tree
*, tree
, tree
, int, bool *);
314 static tree
handle_artificial_attribute (tree
*, tree
, tree
, int, bool *);
315 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
316 static tree
handle_error_attribute (tree
*, tree
, tree
, int, bool *);
317 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
318 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
319 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
321 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
322 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
324 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
325 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
326 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
327 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
328 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
329 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
330 static tree
handle_alias_ifunc_attribute (bool, tree
*, tree
, tree
, bool *);
331 static tree
handle_ifunc_attribute (tree
*, tree
, tree
, int, bool *);
332 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
333 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
334 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
336 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
338 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
340 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
341 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
342 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
344 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
345 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
346 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
348 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
350 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
351 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
352 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
353 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
355 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
356 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
357 static tree
handle_alloc_size_attribute (tree
*, tree
, tree
, int, bool *);
358 static tree
handle_target_attribute (tree
*, tree
, tree
, int, bool *);
359 static tree
handle_optimize_attribute (tree
*, tree
, tree
, int, bool *);
360 static tree
handle_no_split_stack_attribute (tree
*, tree
, tree
, int, bool *);
361 static tree
handle_fnspec_attribute (tree
*, tree
, tree
, int, bool *);
363 static void check_function_nonnull (tree
, int, tree
*);
364 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
365 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
366 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
367 static int resort_field_decl_cmp (const void *, const void *);
369 /* Reserved words. The third field is a mask: keywords are disabled
370 if they match the mask.
373 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
374 C --std=c99: D_CXXONLY | D_OBJC
375 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
376 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
377 C++ --std=c0x: D_CONLY | D_OBJC
378 ObjC++ is like C++ except that D_OBJC is not set
380 If -fno-asm is used, D_ASM is added to the mask. If
381 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
382 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
383 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
385 const struct c_common_resword c_common_reswords
[] =
387 { "_Bool", RID_BOOL
, D_CONLY
},
388 { "_Complex", RID_COMPLEX
, 0 },
389 { "_Imaginary", RID_IMAGINARY
, D_CONLY
},
390 { "_Decimal32", RID_DFLOAT32
, D_CONLY
| D_EXT
},
391 { "_Decimal64", RID_DFLOAT64
, D_CONLY
| D_EXT
},
392 { "_Decimal128", RID_DFLOAT128
, D_CONLY
| D_EXT
},
393 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
394 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
395 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
396 { "_Static_assert", RID_STATIC_ASSERT
, D_CONLY
},
397 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
398 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
399 { "__alignof", RID_ALIGNOF
, 0 },
400 { "__alignof__", RID_ALIGNOF
, 0 },
401 { "__asm", RID_ASM
, 0 },
402 { "__asm__", RID_ASM
, 0 },
403 { "__attribute", RID_ATTRIBUTE
, 0 },
404 { "__attribute__", RID_ATTRIBUTE
, 0 },
405 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
406 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
407 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
408 { "__builtin_va_arg", RID_VA_ARG
, 0 },
409 { "__complex", RID_COMPLEX
, 0 },
410 { "__complex__", RID_COMPLEX
, 0 },
411 { "__const", RID_CONST
, 0 },
412 { "__const__", RID_CONST
, 0 },
413 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
414 { "__extension__", RID_EXTENSION
, 0 },
415 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
416 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
417 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
418 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
419 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
420 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
421 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
422 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
423 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
424 { "__int128", RID_INT128
, 0 },
425 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
426 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
427 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
428 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO
, D_CXXONLY
},
429 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
430 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
431 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
432 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
433 { "__is_standard_layout", RID_IS_STD_LAYOUT
, D_CXXONLY
},
434 { "__is_trivial", RID_IS_TRIVIAL
, D_CXXONLY
},
435 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
436 { "__imag", RID_IMAGPART
, 0 },
437 { "__imag__", RID_IMAGPART
, 0 },
438 { "__inline", RID_INLINE
, 0 },
439 { "__inline__", RID_INLINE
, 0 },
440 { "__label__", RID_LABEL
, 0 },
441 { "__null", RID_NULL
, 0 },
442 { "__real", RID_REALPART
, 0 },
443 { "__real__", RID_REALPART
, 0 },
444 { "__restrict", RID_RESTRICT
, 0 },
445 { "__restrict__", RID_RESTRICT
, 0 },
446 { "__signed", RID_SIGNED
, 0 },
447 { "__signed__", RID_SIGNED
, 0 },
448 { "__thread", RID_THREAD
, 0 },
449 { "__typeof", RID_TYPEOF
, 0 },
450 { "__typeof__", RID_TYPEOF
, 0 },
451 { "__volatile", RID_VOLATILE
, 0 },
452 { "__volatile__", RID_VOLATILE
, 0 },
453 { "alignof", RID_ALIGNOF
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
454 { "asm", RID_ASM
, D_ASM
},
455 { "auto", RID_AUTO
, 0 },
456 { "bool", RID_BOOL
, D_CXXONLY
| D_CXXWARN
},
457 { "break", RID_BREAK
, 0 },
458 { "case", RID_CASE
, 0 },
459 { "catch", RID_CATCH
, D_CXX_OBJC
| D_CXXWARN
},
460 { "char", RID_CHAR
, 0 },
461 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
462 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
463 { "class", RID_CLASS
, D_CXX_OBJC
| D_CXXWARN
},
464 { "const", RID_CONST
, 0 },
465 { "constexpr", RID_CONSTEXPR
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
466 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
467 { "continue", RID_CONTINUE
, 0 },
468 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
469 { "default", RID_DEFAULT
, 0 },
470 { "delete", RID_DELETE
, D_CXXONLY
| D_CXXWARN
},
472 { "double", RID_DOUBLE
, 0 },
473 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
474 { "else", RID_ELSE
, 0 },
475 { "enum", RID_ENUM
, 0 },
476 { "explicit", RID_EXPLICIT
, D_CXXONLY
| D_CXXWARN
},
477 { "export", RID_EXPORT
, D_CXXONLY
| D_CXXWARN
},
478 { "extern", RID_EXTERN
, 0 },
479 { "false", RID_FALSE
, D_CXXONLY
| D_CXXWARN
},
480 { "float", RID_FLOAT
, 0 },
481 { "for", RID_FOR
, 0 },
482 { "friend", RID_FRIEND
, D_CXXONLY
| D_CXXWARN
},
483 { "goto", RID_GOTO
, 0 },
485 { "inline", RID_INLINE
, D_EXT89
},
486 { "int", RID_INT
, 0 },
487 { "long", RID_LONG
, 0 },
488 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
489 { "namespace", RID_NAMESPACE
, D_CXXONLY
| D_CXXWARN
},
490 { "new", RID_NEW
, D_CXXONLY
| D_CXXWARN
},
491 { "noexcept", RID_NOEXCEPT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
492 { "nullptr", RID_NULLPTR
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
493 { "operator", RID_OPERATOR
, D_CXXONLY
| D_CXXWARN
},
494 { "private", RID_PRIVATE
, D_CXX_OBJC
| D_CXXWARN
},
495 { "protected", RID_PROTECTED
, D_CXX_OBJC
| D_CXXWARN
},
496 { "public", RID_PUBLIC
, D_CXX_OBJC
| D_CXXWARN
},
497 { "register", RID_REGISTER
, 0 },
498 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
499 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
500 { "return", RID_RETURN
, 0 },
501 { "short", RID_SHORT
, 0 },
502 { "signed", RID_SIGNED
, 0 },
503 { "sizeof", RID_SIZEOF
, 0 },
504 { "static", RID_STATIC
, 0 },
505 { "static_assert", RID_STATIC_ASSERT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
506 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
507 { "struct", RID_STRUCT
, 0 },
508 { "switch", RID_SWITCH
, 0 },
509 { "template", RID_TEMPLATE
, D_CXXONLY
| D_CXXWARN
},
510 { "this", RID_THIS
, D_CXXONLY
| D_CXXWARN
},
511 { "throw", RID_THROW
, D_CXX_OBJC
| D_CXXWARN
},
512 { "true", RID_TRUE
, D_CXXONLY
| D_CXXWARN
},
513 { "try", RID_TRY
, D_CXX_OBJC
| D_CXXWARN
},
514 { "typedef", RID_TYPEDEF
, 0 },
515 { "typename", RID_TYPENAME
, D_CXXONLY
| D_CXXWARN
},
516 { "typeid", RID_TYPEID
, D_CXXONLY
| D_CXXWARN
},
517 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
518 { "union", RID_UNION
, 0 },
519 { "unsigned", RID_UNSIGNED
, 0 },
520 { "using", RID_USING
, D_CXXONLY
| D_CXXWARN
},
521 { "virtual", RID_VIRTUAL
, D_CXXONLY
| D_CXXWARN
},
522 { "void", RID_VOID
, 0 },
523 { "volatile", RID_VOLATILE
, 0 },
524 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
525 { "while", RID_WHILE
, 0 },
526 /* These Objective-C keywords are recognized only immediately after
528 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
529 { "defs", RID_AT_DEFS
, D_OBJC
},
530 { "encode", RID_AT_ENCODE
, D_OBJC
},
531 { "end", RID_AT_END
, D_OBJC
},
532 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
533 { "interface", RID_AT_INTERFACE
, D_OBJC
},
534 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
535 { "selector", RID_AT_SELECTOR
, D_OBJC
},
536 { "finally", RID_AT_FINALLY
, D_OBJC
},
537 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
538 /* These are recognized only in protocol-qualifier context
540 { "bycopy", RID_BYCOPY
, D_OBJC
},
541 { "byref", RID_BYREF
, D_OBJC
},
542 { "in", RID_IN
, D_OBJC
},
543 { "inout", RID_INOUT
, D_OBJC
},
544 { "oneway", RID_ONEWAY
, D_OBJC
},
545 { "out", RID_OUT
, D_OBJC
},
548 const unsigned int num_c_common_reswords
=
549 sizeof c_common_reswords
/ sizeof (struct c_common_resword
);
551 /* Table of machine-independent attributes common to all C-like languages. */
552 const struct attribute_spec c_common_attribute_table
[] =
554 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
555 { "packed", 0, 0, false, false, false,
556 handle_packed_attribute
},
557 { "nocommon", 0, 0, true, false, false,
558 handle_nocommon_attribute
},
559 { "common", 0, 0, true, false, false,
560 handle_common_attribute
},
561 /* FIXME: logically, noreturn attributes should be listed as
562 "false, true, true" and apply to function types. But implementing this
563 would require all the places in the compiler that use TREE_THIS_VOLATILE
564 on a decl to identify non-returning functions to be located and fixed
565 to check the function type instead. */
566 { "noreturn", 0, 0, true, false, false,
567 handle_noreturn_attribute
},
568 { "volatile", 0, 0, true, false, false,
569 handle_noreturn_attribute
},
570 { "noinline", 0, 0, true, false, false,
571 handle_noinline_attribute
},
572 { "noclone", 0, 0, true, false, false,
573 handle_noclone_attribute
},
574 { "always_inline", 0, 0, true, false, false,
575 handle_always_inline_attribute
},
576 { "gnu_inline", 0, 0, true, false, false,
577 handle_gnu_inline_attribute
},
578 { "artificial", 0, 0, true, false, false,
579 handle_artificial_attribute
},
580 { "flatten", 0, 0, true, false, false,
581 handle_flatten_attribute
},
582 { "used", 0, 0, true, false, false,
583 handle_used_attribute
},
584 { "unused", 0, 0, false, false, false,
585 handle_unused_attribute
},
586 { "externally_visible", 0, 0, true, false, false,
587 handle_externally_visible_attribute
},
588 /* The same comments as for noreturn attributes apply to const ones. */
589 { "const", 0, 0, true, false, false,
590 handle_const_attribute
},
591 { "transparent_union", 0, 0, false, false, false,
592 handle_transparent_union_attribute
},
593 { "constructor", 0, 1, true, false, false,
594 handle_constructor_attribute
},
595 { "destructor", 0, 1, true, false, false,
596 handle_destructor_attribute
},
597 { "mode", 1, 1, false, true, false,
598 handle_mode_attribute
},
599 { "section", 1, 1, true, false, false,
600 handle_section_attribute
},
601 { "aligned", 0, 1, false, false, false,
602 handle_aligned_attribute
},
603 { "weak", 0, 0, true, false, false,
604 handle_weak_attribute
},
605 { "ifunc", 1, 1, true, false, false,
606 handle_ifunc_attribute
},
607 { "alias", 1, 1, true, false, false,
608 handle_alias_attribute
},
609 { "weakref", 0, 1, true, false, false,
610 handle_weakref_attribute
},
611 { "no_instrument_function", 0, 0, true, false, false,
612 handle_no_instrument_function_attribute
},
613 { "malloc", 0, 0, true, false, false,
614 handle_malloc_attribute
},
615 { "returns_twice", 0, 0, true, false, false,
616 handle_returns_twice_attribute
},
617 { "no_stack_limit", 0, 0, true, false, false,
618 handle_no_limit_stack_attribute
},
619 { "pure", 0, 0, true, false, false,
620 handle_pure_attribute
},
621 /* For internal use (marking of builtins) only. The name contains space
622 to prevent its usage in source code. */
623 { "no vops", 0, 0, true, false, false,
624 handle_novops_attribute
},
625 { "deprecated", 0, 1, false, false, false,
626 handle_deprecated_attribute
},
627 { "vector_size", 1, 1, false, true, false,
628 handle_vector_size_attribute
},
629 { "visibility", 1, 1, false, false, false,
630 handle_visibility_attribute
},
631 { "tls_model", 1, 1, true, false, false,
632 handle_tls_model_attribute
},
633 { "nonnull", 0, -1, false, true, true,
634 handle_nonnull_attribute
},
635 { "nothrow", 0, 0, true, false, false,
636 handle_nothrow_attribute
},
637 { "may_alias", 0, 0, false, true, false, NULL
},
638 { "cleanup", 1, 1, true, false, false,
639 handle_cleanup_attribute
},
640 { "warn_unused_result", 0, 0, false, true, true,
641 handle_warn_unused_result_attribute
},
642 { "sentinel", 0, 1, false, true, true,
643 handle_sentinel_attribute
},
644 /* For internal use (marking of builtins) only. The name contains space
645 to prevent its usage in source code. */
646 { "type generic", 0, 0, false, true, true,
647 handle_type_generic_attribute
},
648 { "alloc_size", 1, 2, false, true, true,
649 handle_alloc_size_attribute
},
650 { "cold", 0, 0, true, false, false,
651 handle_cold_attribute
},
652 { "hot", 0, 0, true, false, false,
653 handle_hot_attribute
},
654 { "warning", 1, 1, true, false, false,
655 handle_error_attribute
},
656 { "error", 1, 1, true, false, false,
657 handle_error_attribute
},
658 { "target", 1, -1, true, false, false,
659 handle_target_attribute
},
660 { "optimize", 1, -1, true, false, false,
661 handle_optimize_attribute
},
662 { "no_split_stack", 0, 0, true, false, false,
663 handle_no_split_stack_attribute
},
664 /* For internal use (marking of builtins and runtime functions) only.
665 The name contains space to prevent its usage in source code. */
666 { "fn spec", 1, 1, false, true, true,
667 handle_fnspec_attribute
},
668 { NULL
, 0, 0, false, false, false, NULL
}
671 /* Give the specifications for the format attributes, used by C and all
674 const struct attribute_spec c_common_format_attribute_table
[] =
676 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
677 { "format", 3, 3, false, true, true,
678 handle_format_attribute
},
679 { "format_arg", 1, 1, false, true, true,
680 handle_format_arg_attribute
},
681 { NULL
, 0, 0, false, false, false, NULL
}
684 /* Return identifier for address space AS. */
687 c_addr_space_name (addr_space_t as
)
689 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
690 gcc_assert (ridpointers
[rid
]);
691 return IDENTIFIER_POINTER (ridpointers
[rid
]);
694 /* Push current bindings for the function name VAR_DECLS. */
697 start_fname_decls (void)
700 tree saved
= NULL_TREE
;
702 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
704 tree decl
= *fname_vars
[ix
].decl
;
708 saved
= tree_cons (decl
, build_int_cst (NULL_TREE
, ix
), saved
);
709 *fname_vars
[ix
].decl
= NULL_TREE
;
712 if (saved
|| saved_function_name_decls
)
713 /* Normally they'll have been NULL, so only push if we've got a
714 stack, or they are non-NULL. */
715 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
716 saved_function_name_decls
);
719 /* Finish up the current bindings, adding them into the current function's
720 statement tree. This must be done _before_ finish_stmt_tree is called.
721 If there is no current function, we must be at file scope and no statements
722 are involved. Pop the previous bindings. */
725 finish_fname_decls (void)
728 tree stmts
= NULL_TREE
;
729 tree stack
= saved_function_name_decls
;
731 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
732 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
736 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
738 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
739 bodyp
= &BIND_EXPR_BODY (*bodyp
);
741 append_to_statement_list_force (*bodyp
, &stmts
);
745 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
746 *fname_vars
[ix
].decl
= NULL_TREE
;
750 /* We had saved values, restore them. */
753 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
755 tree decl
= TREE_PURPOSE (saved
);
756 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
758 *fname_vars
[ix
].decl
= decl
;
760 stack
= TREE_CHAIN (stack
);
762 saved_function_name_decls
= stack
;
765 /* Return the text name of the current function, suitably prettified
766 by PRETTY_P. Return string must be freed by caller. */
769 fname_as_string (int pretty_p
)
771 const char *name
= "top level";
774 cpp_string cstr
= { 0, 0 }, strname
;
782 if (current_function_decl
)
783 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
785 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
787 namep
= XNEWVEC (char, len
);
788 snprintf (namep
, len
, "\"%s\"", name
);
789 strname
.text
= (unsigned char *) namep
;
790 strname
.len
= len
- 1;
792 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
795 return (const char *) cstr
.text
;
801 /* Return the VAR_DECL for a const char array naming the current
802 function. If the VAR_DECL has not yet been created, create it
803 now. RID indicates how it should be formatted and IDENTIFIER_NODE
804 ID is its name (unfortunately C and C++ hold the RID values of
805 keywords in different places, so we can't derive RID from ID in
806 this language independent code. LOC is the location of the
810 fname_decl (location_t loc
, unsigned int rid
, tree id
)
813 tree decl
= NULL_TREE
;
815 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
816 if (fname_vars
[ix
].rid
== rid
)
819 decl
= *fname_vars
[ix
].decl
;
822 /* If a tree is built here, it would normally have the lineno of
823 the current statement. Later this tree will be moved to the
824 beginning of the function and this line number will be wrong.
825 To avoid this problem set the lineno to 0 here; that prevents
826 it from appearing in the RTL. */
828 location_t saved_location
= input_location
;
829 input_location
= UNKNOWN_LOCATION
;
831 stmts
= push_stmt_list ();
832 decl
= (*make_fname_decl
) (loc
, id
, fname_vars
[ix
].pretty
);
833 stmts
= pop_stmt_list (stmts
);
834 if (!IS_EMPTY_STMT (stmts
))
835 saved_function_name_decls
836 = tree_cons (decl
, stmts
, saved_function_name_decls
);
837 *fname_vars
[ix
].decl
= decl
;
838 input_location
= saved_location
;
840 if (!ix
&& !current_function_decl
)
841 pedwarn (loc
, 0, "%qD is not defined outside of function scope", decl
);
846 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
849 fix_string_type (tree value
)
851 int length
= TREE_STRING_LENGTH (value
);
853 tree e_type
, i_type
, a_type
;
855 /* Compute the number of elements, for the array type. */
856 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
859 e_type
= char_type_node
;
861 else if (TREE_TYPE (value
) == char16_array_type_node
)
863 nchars
= length
/ (TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
);
864 e_type
= char16_type_node
;
866 else if (TREE_TYPE (value
) == char32_array_type_node
)
868 nchars
= length
/ (TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
);
869 e_type
= char32_type_node
;
873 nchars
= length
/ (TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
);
874 e_type
= wchar_type_node
;
877 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
878 limit in C++98 Annex B is very large (65536) and is not normative,
879 so we do not diagnose it (warn_overlength_strings is forced off
880 in c_common_post_options). */
881 if (warn_overlength_strings
)
883 const int nchars_max
= flag_isoc99
? 4095 : 509;
884 const int relevant_std
= flag_isoc99
? 99 : 90;
885 if (nchars
- 1 > nchars_max
)
886 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
887 separate the %d from the 'C'. 'ISO' should not be
888 translated, but it may be moved after 'C%d' in languages
889 where modifiers follow nouns. */
890 pedwarn (input_location
, OPT_Woverlength_strings
,
891 "string length %qd is greater than the length %qd "
892 "ISO C%d compilers are required to support",
893 nchars
- 1, nchars_max
, relevant_std
);
896 /* Create the array type for the string constant. The ISO C++
897 standard says that a string literal has type `const char[N]' or
898 `const wchar_t[N]'. We use the same logic when invoked as a C
899 front-end with -Wwrite-strings.
900 ??? We should change the type of an expression depending on the
901 state of a warning flag. We should just be warning -- see how
902 this is handled in the C++ front-end for the deprecated implicit
903 conversion from string literals to `char*' or `wchar_t*'.
905 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
906 array type being the unqualified version of that type.
907 Therefore, if we are constructing an array of const char, we must
908 construct the matching unqualified array type first. The C front
909 end does not require this, but it does no harm, so we do it
911 i_type
= build_index_type (build_int_cst (NULL_TREE
, nchars
- 1));
912 a_type
= build_array_type (e_type
, i_type
);
913 if (c_dialect_cxx() || warn_write_strings
)
914 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
916 TREE_TYPE (value
) = a_type
;
917 TREE_CONSTANT (value
) = 1;
918 TREE_READONLY (value
) = 1;
919 TREE_STATIC (value
) = 1;
923 /* Fully fold EXPR, an expression that was not folded (beyond integer
924 constant expressions and null pointer constants) when being built
925 up. If IN_INIT, this is in a static initializer and certain
926 changes are made to the folding done. Clear *MAYBE_CONST if
927 MAYBE_CONST is not NULL and EXPR is definitely not a constant
928 expression because it contains an evaluated operator (in C99) or an
929 operator outside of sizeof returning an integer constant (in C90)
930 not permitted in constant expressions, or because it contains an
931 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
932 set to true by callers before calling this function.) Return the
933 folded expression. Function arguments have already been folded
934 before calling this function, as have the contents of SAVE_EXPR,
935 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
936 C_MAYBE_CONST_EXPR. */
939 c_fully_fold (tree expr
, bool in_init
, bool *maybe_const
)
942 tree eptype
= NULL_TREE
;
944 bool maybe_const_itself
= true;
945 location_t loc
= EXPR_LOCATION (expr
);
947 /* This function is not relevant to C++ because C++ folds while
948 parsing, and may need changes to be correct for C++ when C++
949 stops folding while parsing. */
950 if (c_dialect_cxx ())
954 maybe_const
= &dummy
;
955 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
957 eptype
= TREE_TYPE (expr
);
958 expr
= TREE_OPERAND (expr
, 0);
960 ret
= c_fully_fold_internal (expr
, in_init
, maybe_const
,
961 &maybe_const_itself
);
963 ret
= fold_convert_loc (loc
, eptype
, ret
);
964 *maybe_const
&= maybe_const_itself
;
968 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
969 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
970 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
971 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
972 both evaluated and unevaluated subexpressions while
973 *MAYBE_CONST_ITSELF is carried from only evaluated
977 c_fully_fold_internal (tree expr
, bool in_init
, bool *maybe_const_operands
,
978 bool *maybe_const_itself
)
981 enum tree_code code
= TREE_CODE (expr
);
982 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
983 location_t loc
= EXPR_LOCATION (expr
);
984 tree op0
, op1
, op2
, op3
;
985 tree orig_op0
, orig_op1
, orig_op2
;
986 bool op0_const
= true, op1_const
= true, op2_const
= true;
987 bool op0_const_self
= true, op1_const_self
= true, op2_const_self
= true;
988 bool nowarning
= TREE_NO_WARNING (expr
);
991 /* This function is not relevant to C++ because C++ folds while
992 parsing, and may need changes to be correct for C++ when C++
993 stops folding while parsing. */
994 if (c_dialect_cxx ())
997 /* Constants, declarations, statements, errors, SAVE_EXPRs and
998 anything else not counted as an expression cannot usefully be
999 folded further at this point. */
1000 if (!IS_EXPR_CODE_CLASS (kind
)
1001 || kind
== tcc_statement
1002 || code
== SAVE_EXPR
)
1005 /* Operands of variable-length expressions (function calls) have
1006 already been folded, as have __builtin_* function calls, and such
1007 expressions cannot occur in constant expressions. */
1008 if (kind
== tcc_vl_exp
)
1010 *maybe_const_operands
= false;
1015 if (code
== C_MAYBE_CONST_EXPR
)
1017 tree pre
= C_MAYBE_CONST_EXPR_PRE (expr
);
1018 tree inner
= C_MAYBE_CONST_EXPR_EXPR (expr
);
1019 if (C_MAYBE_CONST_EXPR_NON_CONST (expr
))
1020 *maybe_const_operands
= false;
1021 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr
))
1022 *maybe_const_itself
= false;
1023 if (pre
&& !in_init
)
1024 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), pre
, inner
);
1030 /* Assignment, increment, decrement, function call and comma
1031 operators, and statement expressions, cannot occur in constant
1032 expressions if evaluated / outside of sizeof. (Function calls
1033 were handled above, though VA_ARG_EXPR is treated like a function
1034 call here, and statement expressions are handled through
1035 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1039 case PREDECREMENT_EXPR
:
1040 case PREINCREMENT_EXPR
:
1041 case POSTDECREMENT_EXPR
:
1042 case POSTINCREMENT_EXPR
:
1044 *maybe_const_operands
= false;
1051 *maybe_const_operands
= false;
1059 /* Fold individual tree codes as appropriate. */
1062 case COMPOUND_LITERAL_EXPR
:
1063 /* Any non-constancy will have been marked in a containing
1064 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1068 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1069 op1
= TREE_OPERAND (expr
, 1);
1070 op2
= TREE_OPERAND (expr
, 2);
1071 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1072 maybe_const_itself
);
1073 STRIP_TYPE_NOPS (op0
);
1074 if (op0
!= orig_op0
)
1075 ret
= build3 (COMPONENT_REF
, TREE_TYPE (expr
), op0
, op1
, op2
);
1078 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1079 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1084 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1085 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1086 op2
= TREE_OPERAND (expr
, 2);
1087 op3
= TREE_OPERAND (expr
, 3);
1088 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1089 maybe_const_itself
);
1090 STRIP_TYPE_NOPS (op0
);
1091 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1092 maybe_const_itself
);
1093 STRIP_TYPE_NOPS (op1
);
1094 op1
= decl_constant_value_for_optimization (op1
);
1095 if (op0
!= orig_op0
|| op1
!= orig_op1
)
1096 ret
= build4 (ARRAY_REF
, TREE_TYPE (expr
), op0
, op1
, op2
, op3
);
1099 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1100 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1101 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1108 case PREDECREMENT_EXPR
:
1109 case PREINCREMENT_EXPR
:
1110 case POSTDECREMENT_EXPR
:
1111 case POSTINCREMENT_EXPR
:
1115 case POINTER_PLUS_EXPR
:
1116 case TRUNC_DIV_EXPR
:
1118 case FLOOR_DIV_EXPR
:
1119 case TRUNC_MOD_EXPR
:
1121 case EXACT_DIV_EXPR
:
1134 case TRUTH_AND_EXPR
:
1136 case TRUTH_XOR_EXPR
:
1137 case UNORDERED_EXPR
:
1144 /* Binary operations evaluating both arguments (increment and
1145 decrement are binary internally in GCC). */
1146 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1147 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1148 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1149 maybe_const_itself
);
1150 STRIP_TYPE_NOPS (op0
);
1151 if (code
!= MODIFY_EXPR
1152 && code
!= PREDECREMENT_EXPR
1153 && code
!= PREINCREMENT_EXPR
1154 && code
!= POSTDECREMENT_EXPR
1155 && code
!= POSTINCREMENT_EXPR
)
1156 op0
= decl_constant_value_for_optimization (op0
);
1157 /* The RHS of a MODIFY_EXPR was fully folded when building that
1158 expression for the sake of conversion warnings. */
1159 if (code
!= MODIFY_EXPR
)
1160 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1161 maybe_const_itself
);
1162 STRIP_TYPE_NOPS (op1
);
1163 op1
= decl_constant_value_for_optimization (op1
);
1164 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1166 ? fold_build2_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
)
1167 : fold_build2_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
);
1170 if (TREE_OVERFLOW_P (ret
)
1171 && !TREE_OVERFLOW_P (op0
)
1172 && !TREE_OVERFLOW_P (op1
))
1173 overflow_warning (EXPR_LOCATION (expr
), ret
);
1177 case FIX_TRUNC_EXPR
:
1180 case NON_LVALUE_EXPR
:
1183 case TRUTH_NOT_EXPR
:
1188 /* Unary operations. */
1189 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1190 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1191 maybe_const_itself
);
1192 STRIP_TYPE_NOPS (op0
);
1193 if (code
!= ADDR_EXPR
&& code
!= REALPART_EXPR
&& code
!= IMAGPART_EXPR
)
1194 op0
= decl_constant_value_for_optimization (op0
);
1195 if (op0
!= orig_op0
|| in_init
)
1197 ? fold_build1_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
)
1198 : fold_build1_loc (loc
, code
, TREE_TYPE (expr
), op0
);
1201 if (code
== INDIRECT_REF
1203 && TREE_CODE (ret
) == INDIRECT_REF
)
1205 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1206 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1207 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1211 case FIX_TRUNC_EXPR
:
1214 /* Don't warn about explicit conversions. We will already
1215 have warned about suspect implicit conversions. */
1219 if (TREE_OVERFLOW_P (ret
) && !TREE_OVERFLOW_P (op0
))
1220 overflow_warning (EXPR_LOCATION (expr
), ret
);
1225 case TRUTH_ANDIF_EXPR
:
1226 case TRUTH_ORIF_EXPR
:
1227 /* Binary operations not necessarily evaluating both
1229 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1230 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1231 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1232 STRIP_TYPE_NOPS (op0
);
1234 unused_p
= (op0
== (code
== TRUTH_ANDIF_EXPR
1235 ? truthvalue_false_node
1236 : truthvalue_true_node
));
1237 c_inhibit_evaluation_warnings
+= unused_p
;
1238 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1239 STRIP_TYPE_NOPS (op1
);
1240 c_inhibit_evaluation_warnings
-= unused_p
;
1242 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1244 ? fold_build2_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
)
1245 : fold_build2_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
);
1248 *maybe_const_operands
&= op0_const
;
1249 *maybe_const_itself
&= op0_const_self
;
1253 && (code
== TRUTH_ANDIF_EXPR
1254 ? op0
== truthvalue_false_node
1255 : op0
== truthvalue_true_node
)))
1256 *maybe_const_operands
&= op1_const
;
1259 && (code
== TRUTH_ANDIF_EXPR
1260 ? op0
== truthvalue_false_node
1261 : op0
== truthvalue_true_node
)))
1262 *maybe_const_itself
&= op1_const_self
;
1266 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1267 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1268 orig_op2
= op2
= TREE_OPERAND (expr
, 2);
1269 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1271 STRIP_TYPE_NOPS (op0
);
1272 c_inhibit_evaluation_warnings
+= (op0
== truthvalue_false_node
);
1273 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1274 STRIP_TYPE_NOPS (op1
);
1275 c_inhibit_evaluation_warnings
-= (op0
== truthvalue_false_node
);
1277 c_inhibit_evaluation_warnings
+= (op0
== truthvalue_true_node
);
1278 op2
= c_fully_fold_internal (op2
, in_init
, &op2_const
, &op2_const_self
);
1279 STRIP_TYPE_NOPS (op2
);
1280 c_inhibit_evaluation_warnings
-= (op0
== truthvalue_true_node
);
1282 if (op0
!= orig_op0
|| op1
!= orig_op1
|| op2
!= orig_op2
)
1283 ret
= fold_build3_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
, op2
);
1286 *maybe_const_operands
&= op0_const
;
1287 *maybe_const_itself
&= op0_const_self
;
1291 && op0
== truthvalue_false_node
))
1292 *maybe_const_operands
&= op1_const
;
1295 && op0
== truthvalue_false_node
))
1296 *maybe_const_itself
&= op1_const_self
;
1300 && op0
== truthvalue_true_node
))
1301 *maybe_const_operands
&= op2_const
;
1304 && op0
== truthvalue_true_node
))
1305 *maybe_const_itself
&= op2_const_self
;
1308 case EXCESS_PRECISION_EXPR
:
1309 /* Each case where an operand with excess precision may be
1310 encountered must remove the EXCESS_PRECISION_EXPR around
1311 inner operands and possibly put one around the whole
1312 expression or possibly convert to the semantic type (which
1313 c_fully_fold does); we cannot tell at this stage which is
1314 appropriate in any particular case. */
1318 /* Various codes may appear through folding built-in functions
1319 and their arguments. */
1324 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1325 have been done by this point, so remove them again. */
1326 nowarning
|= TREE_NO_WARNING (ret
);
1327 STRIP_TYPE_NOPS (ret
);
1328 if (nowarning
&& !TREE_NO_WARNING (ret
))
1330 if (!CAN_HAVE_LOCATION_P (ret
))
1331 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
1332 TREE_NO_WARNING (ret
) = 1;
1335 protected_set_expr_location (ret
, loc
);
1339 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1340 return EXP. Otherwise, return either EXP or its known constant
1341 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1342 Is the BLKmode test appropriate? */
1345 decl_constant_value_for_optimization (tree exp
)
1349 /* This function is only used by C, for c_fully_fold and other
1350 optimization, and may not be correct for C++. */
1351 if (c_dialect_cxx ())
1355 || TREE_CODE (exp
) != VAR_DECL
1356 || TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1357 || DECL_MODE (exp
) == BLKmode
)
1360 ret
= decl_constant_value (exp
);
1361 /* Avoid unwanted tree sharing between the initializer and current
1362 function's body where the tree can be modified e.g. by the
1364 if (ret
!= exp
&& TREE_STATIC (exp
))
1365 ret
= unshare_expr (ret
);
1369 /* Print a warning if a constant expression had overflow in folding.
1370 Invoke this function on every expression that the language
1371 requires to be a constant expression.
1372 Note the ANSI C standard says it is erroneous for a
1373 constant expression to overflow. */
1376 constant_expression_warning (tree value
)
1378 if (warn_overflow
&& pedantic
1379 && (TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1380 || TREE_CODE (value
) == FIXED_CST
1381 || TREE_CODE (value
) == VECTOR_CST
1382 || TREE_CODE (value
) == COMPLEX_CST
)
1383 && TREE_OVERFLOW (value
))
1384 pedwarn (input_location
, OPT_Woverflow
, "overflow in constant expression");
1387 /* The same as above but print an unconditional error. */
1389 constant_expression_error (tree value
)
1391 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1392 || TREE_CODE (value
) == FIXED_CST
1393 || TREE_CODE (value
) == VECTOR_CST
1394 || TREE_CODE (value
) == COMPLEX_CST
)
1395 && TREE_OVERFLOW (value
))
1396 error ("overflow in constant expression");
1399 /* Print a warning if an expression had overflow in folding and its
1402 Invoke this function on every expression that
1403 (1) appears in the source code, and
1404 (2) is a constant expression that overflowed, and
1405 (3) is not already checked by convert_and_check;
1406 however, do not invoke this function on operands of explicit casts
1407 or when the expression is the result of an operator and any operand
1408 already overflowed. */
1411 overflow_warning (location_t loc
, tree value
)
1413 if (c_inhibit_evaluation_warnings
!= 0)
1416 switch (TREE_CODE (value
))
1419 warning_at (loc
, OPT_Woverflow
, "integer overflow in expression");
1423 warning_at (loc
, OPT_Woverflow
,
1424 "floating point overflow in expression");
1428 warning_at (loc
, OPT_Woverflow
, "fixed-point overflow in expression");
1432 warning_at (loc
, OPT_Woverflow
, "vector overflow in expression");
1436 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
1437 warning_at (loc
, OPT_Woverflow
,
1438 "complex integer overflow in expression");
1439 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
1440 warning_at (loc
, OPT_Woverflow
,
1441 "complex floating point overflow in expression");
1449 /* Warn about uses of logical || / && operator in a context where it
1450 is likely that the bitwise equivalent was intended by the
1451 programmer. We have seen an expression in which CODE is a binary
1452 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1453 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1455 warn_logical_operator (location_t location
, enum tree_code code
, tree type
,
1456 enum tree_code code_left
, tree op_left
,
1457 enum tree_code
ARG_UNUSED (code_right
), tree op_right
)
1459 int or_op
= (code
== TRUTH_ORIF_EXPR
|| code
== TRUTH_OR_EXPR
);
1460 int in0_p
, in1_p
, in_p
;
1461 tree low0
, low1
, low
, high0
, high1
, high
, lhs
, rhs
, tem
;
1462 bool strict_overflow_p
= false;
1464 if (code
!= TRUTH_ANDIF_EXPR
1465 && code
!= TRUTH_AND_EXPR
1466 && code
!= TRUTH_ORIF_EXPR
1467 && code
!= TRUTH_OR_EXPR
)
1470 /* Warn if &&/|| are being used in a context where it is
1471 likely that the bitwise equivalent was intended by the
1472 programmer. That is, an expression such as op && MASK
1473 where op should not be any boolean expression, nor a
1474 constant, and mask seems to be a non-boolean integer constant. */
1475 if (!truth_value_p (code_left
)
1476 && INTEGRAL_TYPE_P (TREE_TYPE (op_left
))
1477 && !CONSTANT_CLASS_P (op_left
)
1478 && !TREE_NO_WARNING (op_left
)
1479 && TREE_CODE (op_right
) == INTEGER_CST
1480 && !integer_zerop (op_right
)
1481 && !integer_onep (op_right
))
1484 warning_at (location
, OPT_Wlogical_op
, "logical %<or%>"
1485 " applied to non-boolean constant");
1487 warning_at (location
, OPT_Wlogical_op
, "logical %<and%>"
1488 " applied to non-boolean constant");
1489 TREE_NO_WARNING (op_left
) = true;
1493 /* We do not warn for constants because they are typical of macro
1494 expansions that test for features. */
1495 if (CONSTANT_CLASS_P (op_left
) || CONSTANT_CLASS_P (op_right
))
1498 /* This warning only makes sense with logical operands. */
1499 if (!(truth_value_p (TREE_CODE (op_left
))
1500 || INTEGRAL_TYPE_P (TREE_TYPE (op_left
)))
1501 || !(truth_value_p (TREE_CODE (op_right
))
1502 || INTEGRAL_TYPE_P (TREE_TYPE (op_right
))))
1505 lhs
= make_range (op_left
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
1506 rhs
= make_range (op_right
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
1508 if (lhs
&& TREE_CODE (lhs
) == C_MAYBE_CONST_EXPR
)
1509 lhs
= C_MAYBE_CONST_EXPR_EXPR (lhs
);
1511 if (rhs
&& TREE_CODE (rhs
) == C_MAYBE_CONST_EXPR
)
1512 rhs
= C_MAYBE_CONST_EXPR_EXPR (rhs
);
1514 /* If this is an OR operation, invert both sides; we will invert
1515 again at the end. */
1517 in0_p
= !in0_p
, in1_p
= !in1_p
;
1519 /* If both expressions are the same, if we can merge the ranges, and we
1520 can build the range test, return it or it inverted. */
1521 if (lhs
&& rhs
&& operand_equal_p (lhs
, rhs
, 0)
1522 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
1524 && 0 != (tem
= build_range_check (UNKNOWN_LOCATION
,
1525 type
, lhs
, in_p
, low
, high
)))
1527 if (TREE_CODE (tem
) != INTEGER_CST
)
1531 warning_at (location
, OPT_Wlogical_op
,
1533 "of collectively exhaustive tests is always true");
1535 warning_at (location
, OPT_Wlogical_op
,
1537 "of mutually exclusive tests is always false");
1542 /* Print a warning about casts that might indicate violation
1543 of strict aliasing rules if -Wstrict-aliasing is used and
1544 strict aliasing mode is in effect. OTYPE is the original
1545 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1548 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
1550 /* Strip pointer conversion chains and get to the correct original type. */
1552 otype
= TREE_TYPE (expr
);
1554 if (!(flag_strict_aliasing
1555 && POINTER_TYPE_P (type
)
1556 && POINTER_TYPE_P (otype
)
1557 && !VOID_TYPE_P (TREE_TYPE (type
)))
1558 /* If the type we are casting to is a ref-all pointer
1559 dereferencing it is always valid. */
1560 || TYPE_REF_CAN_ALIAS_ALL (type
))
1563 if ((warn_strict_aliasing
> 1) && TREE_CODE (expr
) == ADDR_EXPR
1564 && (DECL_P (TREE_OPERAND (expr
, 0))
1565 || handled_component_p (TREE_OPERAND (expr
, 0))))
1567 /* Casting the address of an object to non void pointer. Warn
1568 if the cast breaks type based aliasing. */
1569 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)) && warn_strict_aliasing
== 2)
1571 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
1572 "might break strict-aliasing rules");
1577 /* warn_strict_aliasing >= 3. This includes the default (3).
1578 Only warn if the cast is dereferenced immediately. */
1579 alias_set_type set1
=
1580 get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1581 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1583 if (set1
!= set2
&& set2
!= 0
1584 && (set1
== 0 || !alias_sets_conflict_p (set1
, set2
)))
1586 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1587 "pointer will break strict-aliasing rules");
1590 else if (warn_strict_aliasing
== 2
1591 && !alias_sets_must_conflict_p (set1
, set2
))
1593 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1594 "pointer might break strict-aliasing rules");
1600 if ((warn_strict_aliasing
== 1) && !VOID_TYPE_P (TREE_TYPE (otype
)))
1602 /* At this level, warn for any conversions, even if an address is
1603 not taken in the same statement. This will likely produce many
1604 false positives, but could be useful to pinpoint problems that
1605 are not revealed at higher levels. */
1606 alias_set_type set1
= get_alias_set (TREE_TYPE (otype
));
1607 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1608 if (!COMPLETE_TYPE_P (type
)
1609 || !alias_sets_must_conflict_p (set1
, set2
))
1611 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1612 "pointer might break strict-aliasing rules");
1620 /* Warn for unlikely, improbable, or stupid DECL declarations
1624 check_main_parameter_types (tree decl
)
1629 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); args
;
1630 args
= TREE_CHAIN (args
))
1632 tree type
= args
? TREE_VALUE (args
) : 0;
1634 if (type
== void_type_node
|| type
== error_mark_node
)
1641 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
1642 pedwarn (input_location
, OPT_Wmain
, "first argument of %q+D should be %<int%>",
1647 if (TREE_CODE (type
) != POINTER_TYPE
1648 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1649 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1651 pedwarn (input_location
, OPT_Wmain
, "second argument of %q+D should be %<char **%>",
1656 if (TREE_CODE (type
) != POINTER_TYPE
1657 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1658 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1660 pedwarn (input_location
, OPT_Wmain
, "third argument of %q+D should probably be "
1661 "%<char **%>", decl
);
1666 /* It is intentional that this message does not mention the third
1667 argument because it's only mentioned in an appendix of the
1669 if (argct
> 0 && (argct
< 2 || argct
> 3))
1670 pedwarn (input_location
, OPT_Wmain
, "%q+D takes only zero or two arguments", decl
);
1673 /* True if pointers to distinct types T1 and T2 can be converted to
1674 each other without an explicit cast. Only returns true for opaque
1677 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
1679 if (TREE_CODE (t1
) == VECTOR_TYPE
&& TREE_CODE (t2
) == VECTOR_TYPE
1680 && (TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
1681 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1687 /* True if vector types T1 and T2 can be converted to each other
1688 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1689 can only be converted with -flax-vector-conversions yet that is not
1690 in effect, emit a note telling the user about that option if such
1691 a note has not previously been emitted. */
1693 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
1695 static bool emitted_lax_note
= false;
1696 bool convertible_lax
;
1698 if ((TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
1699 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1703 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1704 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
1705 TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
1706 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1707 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
1709 if (!convertible_lax
|| flag_lax_vector_conversions
)
1710 return convertible_lax
;
1712 if (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
1713 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1716 if (emit_lax_note
&& !emitted_lax_note
)
1718 emitted_lax_note
= true;
1719 inform (input_location
, "use -flax-vector-conversions to permit "
1720 "conversions between vectors with differing "
1721 "element types or numbers of subparts");
1727 /* This is a helper function of build_binary_op.
1729 For certain operations if both args were extended from the same
1730 smaller type, do the arithmetic in that type and then extend.
1732 BITWISE indicates a bitwise operation.
1733 For them, this optimization is safe only if
1734 both args are zero-extended or both are sign-extended.
1735 Otherwise, we might change the result.
1736 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1737 but calculated in (unsigned short) it would be (unsigned short)-1.
1739 tree
shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
1741 int unsigned0
, unsigned1
;
1746 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1747 excessive narrowing when we call get_narrower below. For
1748 example, suppose that OP0 is of unsigned int extended
1749 from signed char and that RESULT_TYPE is long long int.
1750 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1753 (long long int) (unsigned int) signed_char
1755 which get_narrower would narrow down to
1757 (unsigned int) signed char
1759 If we do not cast OP0 first, get_narrower would return
1760 signed_char, which is inconsistent with the case of the
1762 op0
= convert (result_type
, op0
);
1763 op1
= convert (result_type
, op1
);
1765 arg0
= get_narrower (op0
, &unsigned0
);
1766 arg1
= get_narrower (op1
, &unsigned1
);
1768 /* UNS is 1 if the operation to be done is an unsigned one. */
1769 uns
= TYPE_UNSIGNED (result_type
);
1771 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1772 but it *requires* conversion to FINAL_TYPE. */
1774 if ((TYPE_PRECISION (TREE_TYPE (op0
))
1775 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1776 && TREE_TYPE (op0
) != result_type
)
1777 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1778 if ((TYPE_PRECISION (TREE_TYPE (op1
))
1779 == TYPE_PRECISION (TREE_TYPE (arg1
)))
1780 && TREE_TYPE (op1
) != result_type
)
1781 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1783 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1785 /* For bitwise operations, signedness of nominal type
1786 does not matter. Consider only how operands were extended. */
1790 /* Note that in all three cases below we refrain from optimizing
1791 an unsigned operation on sign-extended args.
1792 That would not be valid. */
1794 /* Both args variable: if both extended in same way
1795 from same width, do it in that width.
1796 Do it unsigned if args were zero-extended. */
1797 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
1798 < TYPE_PRECISION (result_type
))
1799 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1800 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1801 && unsigned0
== unsigned1
1802 && (unsigned0
|| !uns
))
1803 return c_common_signed_or_unsigned_type
1804 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
1806 else if (TREE_CODE (arg0
) == INTEGER_CST
1807 && (unsigned1
|| !uns
)
1808 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1809 < TYPE_PRECISION (result_type
))
1811 = c_common_signed_or_unsigned_type (unsigned1
,
1813 && !POINTER_TYPE_P (type
)
1814 && int_fits_type_p (arg0
, type
))
1817 else if (TREE_CODE (arg1
) == INTEGER_CST
1818 && (unsigned0
|| !uns
)
1819 && (TYPE_PRECISION (TREE_TYPE (arg0
))
1820 < TYPE_PRECISION (result_type
))
1822 = c_common_signed_or_unsigned_type (unsigned0
,
1824 && !POINTER_TYPE_P (type
)
1825 && int_fits_type_p (arg1
, type
))
1831 /* Warns if the conversion of EXPR to TYPE may alter a value.
1832 This is a helper function for warnings_for_convert_and_check. */
1835 conversion_warning (tree type
, tree expr
)
1837 bool give_warning
= false;
1840 const int expr_num_operands
= TREE_OPERAND_LENGTH (expr
);
1841 tree expr_type
= TREE_TYPE (expr
);
1842 location_t loc
= EXPR_HAS_LOCATION (expr
)
1843 ? EXPR_LOCATION (expr
) : input_location
;
1845 if (!warn_conversion
&& !warn_sign_conversion
)
1848 /* If any operand is artificial, then this expression was generated
1849 by the compiler and we do not warn. */
1850 for (i
= 0; i
< expr_num_operands
; i
++)
1852 tree op
= TREE_OPERAND (expr
, i
);
1853 if (op
&& DECL_P (op
) && DECL_ARTIFICIAL (op
))
1857 switch (TREE_CODE (expr
))
1865 case TRUTH_ANDIF_EXPR
:
1866 case TRUTH_ORIF_EXPR
:
1867 case TRUTH_AND_EXPR
:
1869 case TRUTH_XOR_EXPR
:
1870 case TRUTH_NOT_EXPR
:
1871 /* Conversion from boolean to a signed:1 bit-field (which only
1872 can hold the values 0 and -1) doesn't lose information - but
1873 it does change the value. */
1874 if (TYPE_PRECISION (type
) == 1 && !TYPE_UNSIGNED (type
))
1875 warning_at (loc
, OPT_Wconversion
,
1876 "conversion to %qT from boolean expression", type
);
1882 /* Warn for real constant that is not an exact integer converted
1884 if (TREE_CODE (expr_type
) == REAL_TYPE
1885 && TREE_CODE (type
) == INTEGER_TYPE
)
1887 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (expr_type
)))
1888 give_warning
= true;
1890 /* Warn for an integer constant that does not fit into integer type. */
1891 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1892 && TREE_CODE (type
) == INTEGER_TYPE
1893 && !int_fits_type_p (expr
, type
))
1895 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)
1896 && tree_int_cst_sgn (expr
) < 0)
1897 warning_at (loc
, OPT_Wsign_conversion
, "negative integer"
1898 " implicitly converted to unsigned type");
1899 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (expr_type
))
1900 warning_at (loc
, OPT_Wsign_conversion
, "conversion of unsigned"
1901 " constant value to negative integer");
1903 give_warning
= true;
1905 else if (TREE_CODE (type
) == REAL_TYPE
)
1907 /* Warn for an integer constant that does not fit into real type. */
1908 if (TREE_CODE (expr_type
) == INTEGER_TYPE
)
1910 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
1911 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1912 give_warning
= true;
1914 /* Warn for a real constant that does not fit into a smaller
1916 else if (TREE_CODE (expr_type
) == REAL_TYPE
1917 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1919 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
1920 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1921 give_warning
= true;
1926 warning_at (loc
, OPT_Wconversion
,
1927 "conversion to %qT alters %qT constant value",
1934 /* In case of COND_EXPR, if both operands are constants or
1935 COND_EXPR, then we do not care about the type of COND_EXPR,
1936 only about the conversion of each operand. */
1937 tree op1
= TREE_OPERAND (expr
, 1);
1938 tree op2
= TREE_OPERAND (expr
, 2);
1940 if ((TREE_CODE (op1
) == REAL_CST
|| TREE_CODE (op1
) == INTEGER_CST
1941 || TREE_CODE (op1
) == COND_EXPR
)
1942 && (TREE_CODE (op2
) == REAL_CST
|| TREE_CODE (op2
) == INTEGER_CST
1943 || TREE_CODE (op2
) == COND_EXPR
))
1945 conversion_warning (type
, op1
);
1946 conversion_warning (type
, op2
);
1952 default: /* 'expr' is not a constant. */
1954 /* Warn for real types converted to integer types. */
1955 if (TREE_CODE (expr_type
) == REAL_TYPE
1956 && TREE_CODE (type
) == INTEGER_TYPE
)
1957 give_warning
= true;
1959 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1960 && TREE_CODE (type
) == INTEGER_TYPE
)
1962 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1963 expr
= get_unwidened (expr
, 0);
1964 expr_type
= TREE_TYPE (expr
);
1966 /* Don't warn for short y; short x = ((int)y & 0xff); */
1967 if (TREE_CODE (expr
) == BIT_AND_EXPR
1968 || TREE_CODE (expr
) == BIT_IOR_EXPR
1969 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
1971 /* If both args were extended from a shortest type,
1972 use that type if that is safe. */
1973 expr_type
= shorten_binary_op (expr_type
,
1974 TREE_OPERAND (expr
, 0),
1975 TREE_OPERAND (expr
, 1),
1978 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
1980 tree op0
= TREE_OPERAND (expr
, 0);
1981 tree op1
= TREE_OPERAND (expr
, 1);
1982 bool unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1983 bool unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1985 /* If one of the operands is a non-negative constant
1986 that fits in the target type, then the type of the
1987 other operand does not matter. */
1988 if ((TREE_CODE (op0
) == INTEGER_CST
1989 && int_fits_type_p (op0
, c_common_signed_type (type
))
1990 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
1991 || (TREE_CODE (op1
) == INTEGER_CST
1992 && int_fits_type_p (op1
, c_common_signed_type (type
))
1993 && int_fits_type_p (op1
,
1994 c_common_unsigned_type (type
))))
1996 /* If constant is unsigned and fits in the target
1997 type, then the result will also fit. */
1998 else if ((TREE_CODE (op0
) == INTEGER_CST
2000 && int_fits_type_p (op0
, type
))
2001 || (TREE_CODE (op1
) == INTEGER_CST
2003 && int_fits_type_p (op1
, type
)))
2007 /* Warn for integer types converted to smaller integer types. */
2008 if (TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2009 give_warning
= true;
2011 /* When they are the same width but different signedness,
2012 then the value may change. */
2013 else if ((TYPE_PRECISION (type
) == TYPE_PRECISION (expr_type
)
2014 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
2015 /* Even when converted to a bigger type, if the type is
2016 unsigned but expr is signed, then negative values
2018 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
2019 warning_at (loc
, OPT_Wsign_conversion
, "conversion to %qT from %qT "
2020 "may change the sign of the result",
2024 /* Warn for integer types converted to real types if and only if
2025 all the range of values of the integer type cannot be
2026 represented by the real type. */
2027 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2028 && TREE_CODE (type
) == REAL_TYPE
)
2030 tree type_low_bound
, type_high_bound
;
2031 REAL_VALUE_TYPE real_low_bound
, real_high_bound
;
2033 /* Don't warn about char y = 0xff; float x = (int) y; */
2034 expr
= get_unwidened (expr
, 0);
2035 expr_type
= TREE_TYPE (expr
);
2037 type_low_bound
= TYPE_MIN_VALUE (expr_type
);
2038 type_high_bound
= TYPE_MAX_VALUE (expr_type
);
2039 real_low_bound
= real_value_from_int_cst (0, type_low_bound
);
2040 real_high_bound
= real_value_from_int_cst (0, type_high_bound
);
2042 if (!exact_real_truncate (TYPE_MODE (type
), &real_low_bound
)
2043 || !exact_real_truncate (TYPE_MODE (type
), &real_high_bound
))
2044 give_warning
= true;
2047 /* Warn for real types converted to smaller real types. */
2048 else if (TREE_CODE (expr_type
) == REAL_TYPE
2049 && TREE_CODE (type
) == REAL_TYPE
2050 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2051 give_warning
= true;
2055 warning_at (loc
, OPT_Wconversion
,
2056 "conversion to %qT from %qT may alter its value",
2061 /* Produce warnings after a conversion. RESULT is the result of
2062 converting EXPR to TYPE. This is a helper function for
2063 convert_and_check and cp_convert_and_check. */
2066 warnings_for_convert_and_check (tree type
, tree expr
, tree result
)
2068 if (TREE_CODE (expr
) == INTEGER_CST
2069 && (TREE_CODE (type
) == INTEGER_TYPE
2070 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2071 && !int_fits_type_p (expr
, type
))
2073 /* Do not diagnose overflow in a constant expression merely
2074 because a conversion overflowed. */
2075 if (TREE_OVERFLOW (result
))
2076 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
2078 if (TYPE_UNSIGNED (type
))
2080 /* This detects cases like converting -129 or 256 to
2082 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
2083 warning (OPT_Woverflow
,
2084 "large integer implicitly truncated to unsigned type");
2086 conversion_warning (type
, expr
);
2088 else if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
2089 warning (OPT_Woverflow
,
2090 "overflow in implicit constant conversion");
2091 /* No warning for converting 0x80000000 to int. */
2093 && (TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
2094 || TYPE_PRECISION (TREE_TYPE (expr
))
2095 != TYPE_PRECISION (type
)))
2096 warning (OPT_Woverflow
,
2097 "overflow in implicit constant conversion");
2100 conversion_warning (type
, expr
);
2102 else if ((TREE_CODE (result
) == INTEGER_CST
2103 || TREE_CODE (result
) == FIXED_CST
) && TREE_OVERFLOW (result
))
2104 warning (OPT_Woverflow
,
2105 "overflow in implicit constant conversion");
2107 conversion_warning (type
, expr
);
2111 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2112 Invoke this function on every expression that is converted implicitly,
2113 i.e. because of language rules and not because of an explicit cast. */
2116 convert_and_check (tree type
, tree expr
)
2119 tree expr_for_warning
;
2121 /* Convert from a value with possible excess precision rather than
2122 via the semantic type, but do not warn about values not fitting
2123 exactly in the semantic type. */
2124 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
2126 tree orig_type
= TREE_TYPE (expr
);
2127 expr
= TREE_OPERAND (expr
, 0);
2128 expr_for_warning
= convert (orig_type
, expr
);
2129 if (orig_type
== type
)
2130 return expr_for_warning
;
2133 expr_for_warning
= expr
;
2135 if (TREE_TYPE (expr
) == type
)
2138 result
= convert (type
, expr
);
2140 if (c_inhibit_evaluation_warnings
== 0
2141 && !TREE_OVERFLOW_P (expr
)
2142 && result
!= error_mark_node
)
2143 warnings_for_convert_and_check (type
, expr_for_warning
, result
);
2148 /* A node in a list that describes references to variables (EXPR), which are
2149 either read accesses if WRITER is zero, or write accesses, in which case
2150 WRITER is the parent of EXPR. */
2157 /* Used to implement a cache the results of a call to verify_tree. We only
2158 use this for SAVE_EXPRs. */
2161 struct tlist_cache
*next
;
2162 struct tlist
*cache_before_sp
;
2163 struct tlist
*cache_after_sp
;
2167 /* Obstack to use when allocating tlist structures, and corresponding
2169 static struct obstack tlist_obstack
;
2170 static char *tlist_firstobj
= 0;
2172 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2174 static struct tlist
*warned_ids
;
2175 /* SAVE_EXPRs need special treatment. We process them only once and then
2176 cache the results. */
2177 static struct tlist_cache
*save_expr_cache
;
2179 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
2180 static void merge_tlist (struct tlist
**, struct tlist
*, int);
2181 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
2182 static int warning_candidate_p (tree
);
2183 static bool candidate_equal_p (const_tree
, const_tree
);
2184 static void warn_for_collisions (struct tlist
*);
2185 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
2186 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
2188 /* Create a new struct tlist and fill in its fields. */
2189 static struct tlist
*
2190 new_tlist (struct tlist
*next
, tree t
, tree writer
)
2193 l
= XOBNEW (&tlist_obstack
, struct tlist
);
2200 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2201 is nonnull, we ignore any node we find which has a writer equal to it. */
2204 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
2208 struct tlist
*next
= add
->next
;
2211 if (!exclude_writer
|| !candidate_equal_p (add
->writer
, exclude_writer
))
2212 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
2217 /* Merge the nodes of ADD into TO. This merging process is done so that for
2218 each variable that already exists in TO, no new node is added; however if
2219 there is a write access recorded in ADD, and an occurrence on TO is only
2220 a read access, then the occurrence in TO will be modified to record the
2224 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
2226 struct tlist
**end
= to
;
2229 end
= &(*end
)->next
;
2235 struct tlist
*next
= add
->next
;
2237 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
2238 if (candidate_equal_p (tmp2
->expr
, add
->expr
))
2242 tmp2
->writer
= add
->writer
;
2246 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
2247 end
= &(*end
)->next
;
2254 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2255 references in list LIST conflict with it, excluding reads if ONLY writers
2259 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
2264 /* Avoid duplicate warnings. */
2265 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
2266 if (candidate_equal_p (tmp
->expr
, written
))
2271 if (candidate_equal_p (list
->expr
, written
)
2272 && !candidate_equal_p (list
->writer
, writer
)
2273 && (!only_writes
|| list
->writer
))
2275 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
2276 warning_at (EXPR_HAS_LOCATION (writer
)
2277 ? EXPR_LOCATION (writer
) : input_location
,
2278 OPT_Wsequence_point
, "operation on %qE may be undefined",
2285 /* Given a list LIST of references to variables, find whether any of these
2286 can cause conflicts due to missing sequence points. */
2289 warn_for_collisions (struct tlist
*list
)
2293 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
2296 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
2300 /* Return nonzero if X is a tree that can be verified by the sequence point
2303 warning_candidate_p (tree x
)
2305 /* !VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2306 (lvalue_p) crash on TRY/CATCH. */
2307 return !(DECL_P (x
) && DECL_ARTIFICIAL (x
))
2308 && TREE_TYPE (x
) && !VOID_TYPE_P (TREE_TYPE (x
)) && lvalue_p (x
);
2311 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2313 candidate_equal_p (const_tree x
, const_tree y
)
2315 return (x
== y
) || (x
&& y
&& operand_equal_p (x
, y
, 0));
2318 /* Walk the tree X, and record accesses to variables. If X is written by the
2319 parent tree, WRITER is the parent.
2320 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2321 expression or its only operand forces a sequence point, then everything up
2322 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2324 Once we return, we will have emitted warnings if any subexpression before
2325 such a sequence point could be undefined. On a higher level, however, the
2326 sequence point may not be relevant, and we'll merge the two lists.
2328 Example: (b++, a) + b;
2329 The call that processes the COMPOUND_EXPR will store the increment of B
2330 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2331 processes the PLUS_EXPR will need to merge the two lists so that
2332 eventually, all accesses end up on the same list (and we'll warn about the
2333 unordered subexpressions b++ and b.
2335 A note on merging. If we modify the former example so that our expression
2338 care must be taken not simply to add all three expressions into the final
2339 PNO_SP list. The function merge_tlist takes care of that by merging the
2340 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2341 way, so that no more than one access to B is recorded. */
2344 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
2347 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
2348 enum tree_code code
;
2349 enum tree_code_class cl
;
2351 /* X may be NULL if it is the operand of an empty statement expression
2357 code
= TREE_CODE (x
);
2358 cl
= TREE_CODE_CLASS (code
);
2360 if (warning_candidate_p (x
))
2361 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
2369 case TRUTH_ANDIF_EXPR
:
2370 case TRUTH_ORIF_EXPR
:
2371 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2372 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2373 warn_for_collisions (tmp_nosp
);
2374 merge_tlist (pbefore_sp
, tmp_before
, 0);
2375 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
2376 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
2377 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2381 tmp_before
= tmp_list2
= 0;
2382 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
2383 warn_for_collisions (tmp_list2
);
2384 merge_tlist (pbefore_sp
, tmp_before
, 0);
2385 merge_tlist (pbefore_sp
, tmp_list2
, 1);
2387 tmp_list3
= tmp_nosp
= 0;
2388 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
2389 warn_for_collisions (tmp_nosp
);
2390 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2392 tmp_list3
= tmp_list2
= 0;
2393 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
2394 warn_for_collisions (tmp_list2
);
2395 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2396 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2397 two first, to avoid warning for (a ? b++ : b++). */
2398 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
2399 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2402 case PREDECREMENT_EXPR
:
2403 case PREINCREMENT_EXPR
:
2404 case POSTDECREMENT_EXPR
:
2405 case POSTINCREMENT_EXPR
:
2406 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
2410 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2411 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2412 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
2413 /* Expressions inside the LHS are not ordered wrt. the sequence points
2414 in the RHS. Example:
2416 Despite the fact that the modification of "a" is in the before_sp
2417 list (tmp_before), it conflicts with the use of "a" in the LHS.
2418 We can handle this by adding the contents of tmp_list3
2419 to those of tmp_before, and redoing the collision warnings for that
2421 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
2422 warn_for_collisions (tmp_before
);
2423 /* Exclude the LHS itself here; we first have to merge it into the
2424 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2425 didn't exclude the LHS, we'd get it twice, once as a read and once
2427 add_tlist (pno_sp
, tmp_list3
, x
, 0);
2428 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
2430 merge_tlist (pbefore_sp
, tmp_before
, 0);
2431 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
2432 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
2433 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
2437 /* We need to warn about conflicts among arguments and conflicts between
2438 args and the function address. Side effects of the function address,
2439 however, are not ordered by the sequence point of the call. */
2441 call_expr_arg_iterator iter
;
2443 tmp_before
= tmp_nosp
= 0;
2444 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2445 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
2447 tmp_list2
= tmp_list3
= 0;
2448 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
2449 merge_tlist (&tmp_list3
, tmp_list2
, 0);
2450 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
2452 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
2453 warn_for_collisions (tmp_before
);
2454 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
2459 /* Scan all the list, e.g. indices of multi dimensional array. */
2462 tmp_before
= tmp_nosp
= 0;
2463 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2464 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2465 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2472 struct tlist_cache
*t
;
2473 for (t
= save_expr_cache
; t
; t
= t
->next
)
2474 if (candidate_equal_p (t
->expr
, x
))
2479 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
2480 t
->next
= save_expr_cache
;
2482 save_expr_cache
= t
;
2484 tmp_before
= tmp_nosp
= 0;
2485 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2486 warn_for_collisions (tmp_nosp
);
2491 struct tlist
*t
= tmp_nosp
;
2493 merge_tlist (&tmp_list3
, t
, 0);
2495 t
->cache_before_sp
= tmp_before
;
2496 t
->cache_after_sp
= tmp_list3
;
2498 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
2499 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
2504 x
= TREE_OPERAND (x
, 0);
2511 /* For other expressions, simply recurse on their operands.
2512 Manual tail recursion for unary expressions.
2513 Other non-expressions need not be processed. */
2514 if (cl
== tcc_unary
)
2516 x
= TREE_OPERAND (x
, 0);
2520 else if (IS_EXPR_CODE_CLASS (cl
))
2523 int max
= TREE_OPERAND_LENGTH (x
);
2524 for (lp
= 0; lp
< max
; lp
++)
2526 tmp_before
= tmp_nosp
= 0;
2527 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
2528 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2529 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2536 /* Try to warn for undefined behavior in EXPR due to missing sequence
2540 verify_sequence_points (tree expr
)
2542 struct tlist
*before_sp
= 0, *after_sp
= 0;
2545 save_expr_cache
= 0;
2546 if (tlist_firstobj
== 0)
2548 gcc_obstack_init (&tlist_obstack
);
2549 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
2552 verify_tree (expr
, &before_sp
, &after_sp
, 0);
2553 warn_for_collisions (after_sp
);
2554 obstack_free (&tlist_obstack
, tlist_firstobj
);
2557 /* Validate the expression after `case' and apply default promotions. */
2560 check_case_value (tree value
)
2562 if (value
== NULL_TREE
)
2565 /* ??? Can we ever get nops here for a valid case value? We
2567 STRIP_TYPE_NOPS (value
);
2568 /* In C++, the following is allowed:
2571 switch (...) { case i: ... }
2573 So, we try to reduce the VALUE to a constant that way. */
2574 if (c_dialect_cxx ())
2576 value
= decl_constant_value (value
);
2577 STRIP_TYPE_NOPS (value
);
2578 value
= fold (value
);
2581 if (TREE_CODE (value
) == INTEGER_CST
)
2582 /* Promote char or short to int. */
2583 value
= perform_integral_promotions (value
);
2584 else if (value
!= error_mark_node
)
2586 error ("case label does not reduce to an integer constant");
2587 value
= error_mark_node
;
2590 constant_expression_warning (value
);
2595 /* See if the case values LOW and HIGH are in the range of the original
2596 type (i.e. before the default conversion to int) of the switch testing
2598 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2599 the type before promoting it. CASE_LOW_P is a pointer to the lower
2600 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2601 if the case is not a case range.
2602 The caller has to make sure that we are not called with NULL for
2603 CASE_LOW_P (i.e. the default case).
2604 Returns true if the case label is in range of ORIG_TYPE (saturated or
2605 untouched) or false if the label is out of range. */
2608 check_case_bounds (tree type
, tree orig_type
,
2609 tree
*case_low_p
, tree
*case_high_p
)
2611 tree min_value
, max_value
;
2612 tree case_low
= *case_low_p
;
2613 tree case_high
= case_high_p
? *case_high_p
: case_low
;
2615 /* If there was a problem with the original type, do nothing. */
2616 if (orig_type
== error_mark_node
)
2619 min_value
= TYPE_MIN_VALUE (orig_type
);
2620 max_value
= TYPE_MAX_VALUE (orig_type
);
2622 /* Case label is less than minimum for type. */
2623 if (tree_int_cst_compare (case_low
, min_value
) < 0
2624 && tree_int_cst_compare (case_high
, min_value
) < 0)
2626 warning (0, "case label value is less than minimum value for type");
2630 /* Case value is greater than maximum for type. */
2631 if (tree_int_cst_compare (case_low
, max_value
) > 0
2632 && tree_int_cst_compare (case_high
, max_value
) > 0)
2634 warning (0, "case label value exceeds maximum value for type");
2638 /* Saturate lower case label value to minimum. */
2639 if (tree_int_cst_compare (case_high
, min_value
) >= 0
2640 && tree_int_cst_compare (case_low
, min_value
) < 0)
2642 warning (0, "lower value in case label range"
2643 " less than minimum value for type");
2644 case_low
= min_value
;
2647 /* Saturate upper case label value to maximum. */
2648 if (tree_int_cst_compare (case_low
, max_value
) <= 0
2649 && tree_int_cst_compare (case_high
, max_value
) > 0)
2651 warning (0, "upper value in case label range"
2652 " exceeds maximum value for type");
2653 case_high
= max_value
;
2656 if (*case_low_p
!= case_low
)
2657 *case_low_p
= convert (type
, case_low
);
2658 if (case_high_p
&& *case_high_p
!= case_high
)
2659 *case_high_p
= convert (type
, case_high
);
2664 /* Return an integer type with BITS bits of precision,
2665 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2668 c_common_type_for_size (unsigned int bits
, int unsignedp
)
2670 if (bits
== TYPE_PRECISION (integer_type_node
))
2671 return unsignedp
? unsigned_type_node
: integer_type_node
;
2673 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2674 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2676 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2677 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2679 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2680 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2682 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2683 return (unsignedp
? long_long_unsigned_type_node
2684 : long_long_integer_type_node
);
2686 if (int128_integer_type_node
2687 && bits
== TYPE_PRECISION (int128_integer_type_node
))
2688 return (unsignedp
? int128_unsigned_type_node
2689 : int128_integer_type_node
);
2691 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2692 return (unsignedp
? widest_unsigned_literal_type_node
2693 : widest_integer_literal_type_node
);
2695 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2696 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2698 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2699 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2701 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2702 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2704 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2705 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2710 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2711 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2712 and saturating if SATP is nonzero, otherwise not saturating. */
2715 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
2716 int unsignedp
, int satp
)
2718 enum machine_mode mode
;
2720 mode
= unsignedp
? UQQmode
: QQmode
;
2722 mode
= unsignedp
? UHAmode
: HAmode
;
2724 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
2725 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2728 if (mode
== VOIDmode
|| !targetm
.scalar_mode_supported_p (mode
))
2730 sorry ("GCC cannot support operators with integer types and "
2731 "fixed-point types that have too many integral and "
2732 "fractional bits together");
2736 return c_common_type_for_mode (mode
, satp
);
2739 /* Used for communication between c_common_type_for_mode and
2740 c_register_builtin_type. */
2741 static GTY(()) tree registered_builtin_types
;
2743 /* Return a data type that has machine mode MODE.
2744 If the mode is an integer,
2745 then UNSIGNEDP selects between signed and unsigned types.
2746 If the mode is a fixed-point mode,
2747 then UNSIGNEDP selects between saturating and nonsaturating types. */
2750 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
2754 if (mode
== TYPE_MODE (integer_type_node
))
2755 return unsignedp
? unsigned_type_node
: integer_type_node
;
2757 if (mode
== TYPE_MODE (signed_char_type_node
))
2758 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2760 if (mode
== TYPE_MODE (short_integer_type_node
))
2761 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2763 if (mode
== TYPE_MODE (long_integer_type_node
))
2764 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2766 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2767 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2769 if (int128_integer_type_node
2770 && mode
== TYPE_MODE (int128_integer_type_node
))
2771 return unsignedp
? int128_unsigned_type_node
: int128_integer_type_node
;
2773 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2774 return unsignedp
? widest_unsigned_literal_type_node
2775 : widest_integer_literal_type_node
;
2778 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2781 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2784 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2787 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2789 #if HOST_BITS_PER_WIDE_INT >= 64
2790 if (mode
== TYPE_MODE (intTI_type_node
))
2791 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2794 if (mode
== TYPE_MODE (float_type_node
))
2795 return float_type_node
;
2797 if (mode
== TYPE_MODE (double_type_node
))
2798 return double_type_node
;
2800 if (mode
== TYPE_MODE (long_double_type_node
))
2801 return long_double_type_node
;
2803 if (mode
== TYPE_MODE (void_type_node
))
2804 return void_type_node
;
2806 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2808 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2809 : make_signed_type (GET_MODE_PRECISION (mode
)));
2811 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2813 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2814 : make_signed_type (GET_MODE_PRECISION (mode
)));
2816 if (COMPLEX_MODE_P (mode
))
2818 enum machine_mode inner_mode
;
2821 if (mode
== TYPE_MODE (complex_float_type_node
))
2822 return complex_float_type_node
;
2823 if (mode
== TYPE_MODE (complex_double_type_node
))
2824 return complex_double_type_node
;
2825 if (mode
== TYPE_MODE (complex_long_double_type_node
))
2826 return complex_long_double_type_node
;
2828 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
2829 return complex_integer_type_node
;
2831 inner_mode
= GET_MODE_INNER (mode
);
2832 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2833 if (inner_type
!= NULL_TREE
)
2834 return build_complex_type (inner_type
);
2836 else if (VECTOR_MODE_P (mode
))
2838 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
2839 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2840 if (inner_type
!= NULL_TREE
)
2841 return build_vector_type_for_mode (inner_type
, mode
);
2844 if (mode
== TYPE_MODE (dfloat32_type_node
))
2845 return dfloat32_type_node
;
2846 if (mode
== TYPE_MODE (dfloat64_type_node
))
2847 return dfloat64_type_node
;
2848 if (mode
== TYPE_MODE (dfloat128_type_node
))
2849 return dfloat128_type_node
;
2851 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
2853 if (mode
== TYPE_MODE (short_fract_type_node
))
2854 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
2855 if (mode
== TYPE_MODE (fract_type_node
))
2856 return unsignedp
? sat_fract_type_node
: fract_type_node
;
2857 if (mode
== TYPE_MODE (long_fract_type_node
))
2858 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
2859 if (mode
== TYPE_MODE (long_long_fract_type_node
))
2860 return unsignedp
? sat_long_long_fract_type_node
2861 : long_long_fract_type_node
;
2863 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
2864 return unsignedp
? sat_unsigned_short_fract_type_node
2865 : unsigned_short_fract_type_node
;
2866 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
2867 return unsignedp
? sat_unsigned_fract_type_node
2868 : unsigned_fract_type_node
;
2869 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
2870 return unsignedp
? sat_unsigned_long_fract_type_node
2871 : unsigned_long_fract_type_node
;
2872 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
2873 return unsignedp
? sat_unsigned_long_long_fract_type_node
2874 : unsigned_long_long_fract_type_node
;
2876 if (mode
== TYPE_MODE (short_accum_type_node
))
2877 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
2878 if (mode
== TYPE_MODE (accum_type_node
))
2879 return unsignedp
? sat_accum_type_node
: accum_type_node
;
2880 if (mode
== TYPE_MODE (long_accum_type_node
))
2881 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
2882 if (mode
== TYPE_MODE (long_long_accum_type_node
))
2883 return unsignedp
? sat_long_long_accum_type_node
2884 : long_long_accum_type_node
;
2886 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
2887 return unsignedp
? sat_unsigned_short_accum_type_node
2888 : unsigned_short_accum_type_node
;
2889 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
2890 return unsignedp
? sat_unsigned_accum_type_node
2891 : unsigned_accum_type_node
;
2892 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
2893 return unsignedp
? sat_unsigned_long_accum_type_node
2894 : unsigned_long_accum_type_node
;
2895 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
2896 return unsignedp
? sat_unsigned_long_long_accum_type_node
2897 : unsigned_long_long_accum_type_node
;
2900 return unsignedp
? sat_qq_type_node
: qq_type_node
;
2902 return unsignedp
? sat_hq_type_node
: hq_type_node
;
2904 return unsignedp
? sat_sq_type_node
: sq_type_node
;
2906 return unsignedp
? sat_dq_type_node
: dq_type_node
;
2908 return unsignedp
? sat_tq_type_node
: tq_type_node
;
2910 if (mode
== UQQmode
)
2911 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
2912 if (mode
== UHQmode
)
2913 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
2914 if (mode
== USQmode
)
2915 return unsignedp
? sat_usq_type_node
: usq_type_node
;
2916 if (mode
== UDQmode
)
2917 return unsignedp
? sat_udq_type_node
: udq_type_node
;
2918 if (mode
== UTQmode
)
2919 return unsignedp
? sat_utq_type_node
: utq_type_node
;
2922 return unsignedp
? sat_ha_type_node
: ha_type_node
;
2924 return unsignedp
? sat_sa_type_node
: sa_type_node
;
2926 return unsignedp
? sat_da_type_node
: da_type_node
;
2928 return unsignedp
? sat_ta_type_node
: ta_type_node
;
2930 if (mode
== UHAmode
)
2931 return unsignedp
? sat_uha_type_node
: uha_type_node
;
2932 if (mode
== USAmode
)
2933 return unsignedp
? sat_usa_type_node
: usa_type_node
;
2934 if (mode
== UDAmode
)
2935 return unsignedp
? sat_uda_type_node
: uda_type_node
;
2936 if (mode
== UTAmode
)
2937 return unsignedp
? sat_uta_type_node
: uta_type_node
;
2940 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
2941 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
2942 return TREE_VALUE (t
);
2948 c_common_unsigned_type (tree type
)
2950 return c_common_signed_or_unsigned_type (1, type
);
2953 /* Return a signed type the same as TYPE in other respects. */
2956 c_common_signed_type (tree type
)
2958 return c_common_signed_or_unsigned_type (0, type
);
2961 /* Return a type the same as TYPE except unsigned or
2962 signed according to UNSIGNEDP. */
2965 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
2969 /* This block of code emulates the behavior of the old
2970 c_common_unsigned_type. In particular, it returns
2971 long_unsigned_type_node if passed a long, even when a int would
2972 have the same size. This is necessary for warnings to work
2973 correctly in archs where sizeof(int) == sizeof(long) */
2975 type1
= TYPE_MAIN_VARIANT (type
);
2976 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
2977 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2978 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2979 return unsignedp
? unsigned_type_node
: integer_type_node
;
2980 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2981 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2982 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2983 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2984 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
2985 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2986 if (int128_integer_type_node
2987 && (type1
== int128_integer_type_node
2988 || type1
== int128_unsigned_type_node
))
2989 return unsignedp
? int128_unsigned_type_node
: int128_integer_type_node
;
2990 if (type1
== widest_integer_literal_type_node
|| type1
== widest_unsigned_literal_type_node
)
2991 return unsignedp
? widest_unsigned_literal_type_node
: widest_integer_literal_type_node
;
2992 #if HOST_BITS_PER_WIDE_INT >= 64
2993 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2994 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2996 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2997 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2998 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2999 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3000 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
3001 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3002 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
3003 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3005 #define C_COMMON_FIXED_TYPES(NAME) \
3006 if (type1 == short_ ## NAME ## _type_node \
3007 || type1 == unsigned_short_ ## NAME ## _type_node) \
3008 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3009 : short_ ## NAME ## _type_node; \
3010 if (type1 == NAME ## _type_node \
3011 || type1 == unsigned_ ## NAME ## _type_node) \
3012 return unsignedp ? unsigned_ ## NAME ## _type_node \
3013 : NAME ## _type_node; \
3014 if (type1 == long_ ## NAME ## _type_node \
3015 || type1 == unsigned_long_ ## NAME ## _type_node) \
3016 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3017 : long_ ## NAME ## _type_node; \
3018 if (type1 == long_long_ ## NAME ## _type_node \
3019 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3020 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3021 : long_long_ ## NAME ## _type_node;
3023 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3024 if (type1 == NAME ## _type_node \
3025 || type1 == u ## NAME ## _type_node) \
3026 return unsignedp ? u ## NAME ## _type_node \
3027 : NAME ## _type_node;
3029 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3030 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3031 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3032 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3033 : sat_ ## short_ ## NAME ## _type_node; \
3034 if (type1 == sat_ ## NAME ## _type_node \
3035 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3036 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3037 : sat_ ## NAME ## _type_node; \
3038 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3039 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3040 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3041 : sat_ ## long_ ## NAME ## _type_node; \
3042 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3043 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3044 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3045 : sat_ ## long_long_ ## NAME ## _type_node;
3047 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3048 if (type1 == sat_ ## NAME ## _type_node \
3049 || type1 == sat_ ## u ## NAME ## _type_node) \
3050 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3051 : sat_ ## NAME ## _type_node;
3053 C_COMMON_FIXED_TYPES (fract
);
3054 C_COMMON_FIXED_TYPES_SAT (fract
);
3055 C_COMMON_FIXED_TYPES (accum
);
3056 C_COMMON_FIXED_TYPES_SAT (accum
);
3058 C_COMMON_FIXED_MODE_TYPES (qq
);
3059 C_COMMON_FIXED_MODE_TYPES (hq
);
3060 C_COMMON_FIXED_MODE_TYPES (sq
);
3061 C_COMMON_FIXED_MODE_TYPES (dq
);
3062 C_COMMON_FIXED_MODE_TYPES (tq
);
3063 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
3064 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
3065 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
3066 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
3067 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
3068 C_COMMON_FIXED_MODE_TYPES (ha
);
3069 C_COMMON_FIXED_MODE_TYPES (sa
);
3070 C_COMMON_FIXED_MODE_TYPES (da
);
3071 C_COMMON_FIXED_MODE_TYPES (ta
);
3072 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
3073 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
3074 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
3075 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
3077 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3078 the precision; they have precision set to match their range, but
3079 may use a wider mode to match an ABI. If we change modes, we may
3080 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3081 the precision as well, so as to yield correct results for
3082 bit-field types. C++ does not have these separate bit-field
3083 types, and producing a signed or unsigned variant of an
3084 ENUMERAL_TYPE may cause other problems as well. */
3086 if (!INTEGRAL_TYPE_P (type
)
3087 || TYPE_UNSIGNED (type
) == unsignedp
)
3090 #define TYPE_OK(node) \
3091 (TYPE_MODE (type) == TYPE_MODE (node) \
3092 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3093 if (TYPE_OK (signed_char_type_node
))
3094 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3095 if (TYPE_OK (integer_type_node
))
3096 return unsignedp
? unsigned_type_node
: integer_type_node
;
3097 if (TYPE_OK (short_integer_type_node
))
3098 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3099 if (TYPE_OK (long_integer_type_node
))
3100 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3101 if (TYPE_OK (long_long_integer_type_node
))
3102 return (unsignedp
? long_long_unsigned_type_node
3103 : long_long_integer_type_node
);
3104 if (int128_integer_type_node
&& TYPE_OK (int128_integer_type_node
))
3105 return (unsignedp
? int128_unsigned_type_node
3106 : int128_integer_type_node
);
3107 if (TYPE_OK (widest_integer_literal_type_node
))
3108 return (unsignedp
? widest_unsigned_literal_type_node
3109 : widest_integer_literal_type_node
);
3111 #if HOST_BITS_PER_WIDE_INT >= 64
3112 if (TYPE_OK (intTI_type_node
))
3113 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3115 if (TYPE_OK (intDI_type_node
))
3116 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3117 if (TYPE_OK (intSI_type_node
))
3118 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3119 if (TYPE_OK (intHI_type_node
))
3120 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3121 if (TYPE_OK (intQI_type_node
))
3122 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3125 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
3128 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3131 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
3133 /* Extended integer types of the same width as a standard type have
3134 lesser rank, so those of the same width as int promote to int or
3135 unsigned int and are valid for printf formats expecting int or
3136 unsigned int. To avoid such special cases, avoid creating
3137 extended integer types for bit-fields if a standard integer type
3139 if (width
== TYPE_PRECISION (integer_type_node
))
3140 return unsignedp
? unsigned_type_node
: integer_type_node
;
3141 if (width
== TYPE_PRECISION (signed_char_type_node
))
3142 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3143 if (width
== TYPE_PRECISION (short_integer_type_node
))
3144 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3145 if (width
== TYPE_PRECISION (long_integer_type_node
))
3146 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3147 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
3148 return (unsignedp
? long_long_unsigned_type_node
3149 : long_long_integer_type_node
);
3150 if (int128_integer_type_node
3151 && width
== TYPE_PRECISION (int128_integer_type_node
))
3152 return (unsignedp
? int128_unsigned_type_node
3153 : int128_integer_type_node
);
3154 return build_nonstandard_integer_type (width
, unsignedp
);
3157 /* The C version of the register_builtin_type langhook. */
3160 c_register_builtin_type (tree type
, const char* name
)
3164 decl
= build_decl (UNKNOWN_LOCATION
,
3165 TYPE_DECL
, get_identifier (name
), type
);
3166 DECL_ARTIFICIAL (decl
) = 1;
3167 if (!TYPE_NAME (type
))
3168 TYPE_NAME (type
) = decl
;
3171 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
3174 /* Print an error message for invalid operands to arith operation
3175 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3176 LOCATION is the location of the message. */
3179 binary_op_error (location_t location
, enum tree_code code
,
3180 tree type0
, tree type1
)
3187 opname
= "+"; break;
3189 opname
= "-"; break;
3191 opname
= "*"; break;
3193 opname
= "max"; break;
3195 opname
= "min"; break;
3197 opname
= "=="; break;
3199 opname
= "!="; break;
3201 opname
= "<="; break;
3203 opname
= ">="; break;
3205 opname
= "<"; break;
3207 opname
= ">"; break;
3209 opname
= "<<"; break;
3211 opname
= ">>"; break;
3212 case TRUNC_MOD_EXPR
:
3213 case FLOOR_MOD_EXPR
:
3214 opname
= "%"; break;
3215 case TRUNC_DIV_EXPR
:
3216 case FLOOR_DIV_EXPR
:
3217 opname
= "/"; break;
3219 opname
= "&"; break;
3221 opname
= "|"; break;
3222 case TRUTH_ANDIF_EXPR
:
3223 opname
= "&&"; break;
3224 case TRUTH_ORIF_EXPR
:
3225 opname
= "||"; break;
3227 opname
= "^"; break;
3232 "invalid operands to binary %s (have %qT and %qT)", opname
,
3236 /* Subroutine of build_binary_op, used for comparison operations.
3237 See if the operands have both been converted from subword integer types
3238 and, if so, perhaps change them both back to their original type.
3239 This function is also responsible for converting the two operands
3240 to the proper common type for comparison.
3242 The arguments of this function are all pointers to local variables
3243 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3244 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3246 If this function returns nonzero, it means that the comparison has
3247 a constant value. What this function returns is an expression for
3251 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
3252 enum tree_code
*rescode_ptr
)
3255 tree op0
= *op0_ptr
;
3256 tree op1
= *op1_ptr
;
3257 int unsignedp0
, unsignedp1
;
3259 tree primop0
, primop1
;
3260 enum tree_code code
= *rescode_ptr
;
3262 /* Throw away any conversions to wider types
3263 already present in the operands. */
3265 primop0
= get_narrower (op0
, &unsignedp0
);
3266 primop1
= get_narrower (op1
, &unsignedp1
);
3268 /* Handle the case that OP0 does not *contain* a conversion
3269 but it *requires* conversion to FINAL_TYPE. */
3271 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
3272 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
3273 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
3274 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
3276 /* If one of the operands must be floated, we cannot optimize. */
3277 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
3278 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
3280 /* If first arg is constant, swap the args (changing operation
3281 so value is preserved), for canonicalization. Don't do this if
3282 the second arg is 0. */
3284 if (TREE_CONSTANT (primop0
)
3285 && !integer_zerop (primop1
) && !real_zerop (primop1
)
3286 && !fixed_zerop (primop1
))
3289 int temi
= unsignedp0
;
3297 unsignedp0
= unsignedp1
;
3320 *rescode_ptr
= code
;
3323 /* If comparing an integer against a constant more bits wide,
3324 maybe we can deduce a value of 1 or 0 independent of the data.
3325 Or else truncate the constant now
3326 rather than extend the variable at run time.
3328 This is only interesting if the constant is the wider arg.
3329 Also, it is not safe if the constant is unsigned and the
3330 variable arg is signed, since in this case the variable
3331 would be sign-extended and then regarded as unsigned.
3332 Our technique fails in this case because the lowest/highest
3333 possible unsigned results don't follow naturally from the
3334 lowest/highest possible values of the variable operand.
3335 For just EQ_EXPR and NE_EXPR there is another technique that
3336 could be used: see if the constant can be faithfully represented
3337 in the other operand's type, by truncating it and reextending it
3338 and see if that preserves the constant's value. */
3340 if (!real1
&& !real2
3341 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
3342 && TREE_CODE (primop1
) == INTEGER_CST
3343 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
3345 int min_gt
, max_gt
, min_lt
, max_lt
;
3346 tree maxval
, minval
;
3347 /* 1 if comparison is nominally unsigned. */
3348 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
3351 type
= c_common_signed_or_unsigned_type (unsignedp0
,
3352 TREE_TYPE (primop0
));
3354 maxval
= TYPE_MAX_VALUE (type
);
3355 minval
= TYPE_MIN_VALUE (type
);
3357 if (unsignedp
&& !unsignedp0
)
3358 *restype_ptr
= c_common_signed_type (*restype_ptr
);
3360 if (TREE_TYPE (primop1
) != *restype_ptr
)
3362 /* Convert primop1 to target type, but do not introduce
3363 additional overflow. We know primop1 is an int_cst. */
3364 primop1
= force_fit_type_double (*restype_ptr
,
3365 tree_to_double_int (primop1
),
3366 0, TREE_OVERFLOW (primop1
));
3368 if (type
!= *restype_ptr
)
3370 minval
= convert (*restype_ptr
, minval
);
3371 maxval
= convert (*restype_ptr
, maxval
);
3374 if (unsignedp
&& unsignedp0
)
3376 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
3377 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
3378 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
3379 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
3383 min_gt
= INT_CST_LT (primop1
, minval
);
3384 max_gt
= INT_CST_LT (primop1
, maxval
);
3385 min_lt
= INT_CST_LT (minval
, primop1
);
3386 max_lt
= INT_CST_LT (maxval
, primop1
);
3390 /* This used to be a switch, but Genix compiler can't handle that. */
3391 if (code
== NE_EXPR
)
3393 if (max_lt
|| min_gt
)
3394 val
= truthvalue_true_node
;
3396 else if (code
== EQ_EXPR
)
3398 if (max_lt
|| min_gt
)
3399 val
= truthvalue_false_node
;
3401 else if (code
== LT_EXPR
)
3404 val
= truthvalue_true_node
;
3406 val
= truthvalue_false_node
;
3408 else if (code
== GT_EXPR
)
3411 val
= truthvalue_true_node
;
3413 val
= truthvalue_false_node
;
3415 else if (code
== LE_EXPR
)
3418 val
= truthvalue_true_node
;
3420 val
= truthvalue_false_node
;
3422 else if (code
== GE_EXPR
)
3425 val
= truthvalue_true_node
;
3427 val
= truthvalue_false_node
;
3430 /* If primop0 was sign-extended and unsigned comparison specd,
3431 we did a signed comparison above using the signed type bounds.
3432 But the comparison we output must be unsigned.
3434 Also, for inequalities, VAL is no good; but if the signed
3435 comparison had *any* fixed result, it follows that the
3436 unsigned comparison just tests the sign in reverse
3437 (positive values are LE, negative ones GE).
3438 So we can generate an unsigned comparison
3439 against an extreme value of the signed type. */
3441 if (unsignedp
&& !unsignedp0
)
3448 primop1
= TYPE_MIN_VALUE (type
);
3454 primop1
= TYPE_MAX_VALUE (type
);
3461 type
= c_common_unsigned_type (type
);
3464 if (TREE_CODE (primop0
) != INTEGER_CST
)
3466 if (val
== truthvalue_false_node
)
3467 warning (OPT_Wtype_limits
, "comparison is always false due to limited range of data type");
3468 if (val
== truthvalue_true_node
)
3469 warning (OPT_Wtype_limits
, "comparison is always true due to limited range of data type");
3474 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3475 if (TREE_SIDE_EFFECTS (primop0
))
3476 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
3480 /* Value is not predetermined, but do the comparison
3481 in the type of the operand that is not constant.
3482 TYPE is already properly set. */
3485 /* If either arg is decimal float and the other is float, find the
3486 proper common type to use for comparison. */
3487 else if (real1
&& real2
3488 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3489 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
3490 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3492 else if (real1
&& real2
3493 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3494 == TYPE_PRECISION (TREE_TYPE (primop1
))))
3495 type
= TREE_TYPE (primop0
);
3497 /* If args' natural types are both narrower than nominal type
3498 and both extend in the same manner, compare them
3499 in the type of the wider arg.
3500 Otherwise must actually extend both to the nominal
3501 common type lest different ways of extending
3503 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3505 else if (unsignedp0
== unsignedp1
&& real1
== real2
3506 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
3507 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
3509 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3510 type
= c_common_signed_or_unsigned_type (unsignedp0
3511 || TYPE_UNSIGNED (*restype_ptr
),
3513 /* Make sure shorter operand is extended the right way
3514 to match the longer operand. */
3516 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
3517 TREE_TYPE (primop0
)),
3520 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
3521 TREE_TYPE (primop1
)),
3526 /* Here we must do the comparison on the nominal type
3527 using the args exactly as we received them. */
3528 type
= *restype_ptr
;
3532 if (!real1
&& !real2
&& integer_zerop (primop1
)
3533 && TYPE_UNSIGNED (*restype_ptr
))
3539 /* All unsigned values are >= 0, so we warn. However,
3540 if OP0 is a constant that is >= 0, the signedness of
3541 the comparison isn't an issue, so suppress the
3543 if (warn_type_limits
&& !in_system_header
3544 && !(TREE_CODE (primop0
) == INTEGER_CST
3545 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3547 warning (OPT_Wtype_limits
,
3548 "comparison of unsigned expression >= 0 is always true");
3549 value
= truthvalue_true_node
;
3553 if (warn_type_limits
&& !in_system_header
3554 && !(TREE_CODE (primop0
) == INTEGER_CST
3555 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3557 warning (OPT_Wtype_limits
,
3558 "comparison of unsigned expression < 0 is always false");
3559 value
= truthvalue_false_node
;
3568 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3569 if (TREE_SIDE_EFFECTS (primop0
))
3570 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3577 *op0_ptr
= convert (type
, primop0
);
3578 *op1_ptr
= convert (type
, primop1
);
3580 *restype_ptr
= truthvalue_type_node
;
3585 /* Return a tree for the sum or difference (RESULTCODE says which)
3586 of pointer PTROP and integer INTOP. */
3589 pointer_int_sum (location_t loc
, enum tree_code resultcode
,
3590 tree ptrop
, tree intop
)
3594 /* The result is a pointer of the same type that is being added. */
3595 tree result_type
= TREE_TYPE (ptrop
);
3597 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3599 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3600 "pointer of type %<void *%> used in arithmetic");
3601 size_exp
= integer_one_node
;
3603 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3605 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3606 "pointer to a function used in arithmetic");
3607 size_exp
= integer_one_node
;
3609 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3611 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3612 "pointer to member function used in arithmetic");
3613 size_exp
= integer_one_node
;
3616 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3618 /* We are manipulating pointer values, so we don't need to warn
3619 about relying on undefined signed overflow. We disable the
3620 warning here because we use integer types so fold won't know that
3621 they are really pointers. */
3622 fold_defer_overflow_warnings ();
3624 /* If what we are about to multiply by the size of the elements
3625 contains a constant term, apply distributive law
3626 and multiply that constant term separately.
3627 This helps produce common subexpressions. */
3628 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3629 && !TREE_CONSTANT (intop
)
3630 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3631 && TREE_CONSTANT (size_exp
)
3632 /* If the constant comes from pointer subtraction,
3633 skip this optimization--it would cause an error. */
3634 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
3635 /* If the constant is unsigned, and smaller than the pointer size,
3636 then we must skip this optimization. This is because it could cause
3637 an overflow error if the constant is negative but INTOP is not. */
3638 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
3639 || (TYPE_PRECISION (TREE_TYPE (intop
))
3640 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
3642 enum tree_code subcode
= resultcode
;
3643 tree int_type
= TREE_TYPE (intop
);
3644 if (TREE_CODE (intop
) == MINUS_EXPR
)
3645 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3646 /* Convert both subexpression types to the type of intop,
3647 because weird cases involving pointer arithmetic
3648 can result in a sum or difference with different type args. */
3649 ptrop
= build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop
, 1)),
3651 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
3652 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
3655 /* Convert the integer argument to a type the same size as sizetype
3656 so the multiply won't overflow spuriously. */
3657 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
3658 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
3659 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
3660 TYPE_UNSIGNED (sizetype
)), intop
);
3662 /* Replace the integer argument with a suitable product by the object size.
3663 Do this multiplication as signed, then convert to the appropriate type
3664 for the pointer operation and disregard an overflow that occured only
3665 because of the sign-extension change in the latter conversion. */
3667 tree t
= build_binary_op (loc
,
3669 convert (TREE_TYPE (intop
), size_exp
), 1);
3670 intop
= convert (sizetype
, t
);
3671 if (TREE_OVERFLOW_P (intop
) && !TREE_OVERFLOW (t
))
3672 intop
= build_int_cst_wide (TREE_TYPE (intop
), TREE_INT_CST_LOW (intop
),
3673 TREE_INT_CST_HIGH (intop
));
3676 /* Create the sum or difference. */
3677 if (resultcode
== MINUS_EXPR
)
3678 intop
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, intop
);
3680 ret
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, result_type
, ptrop
, intop
);
3682 fold_undefer_and_ignore_overflow_warnings ();
3687 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3688 and if NON_CONST is known not to be permitted in an evaluated part
3689 of a constant expression. */
3692 c_wrap_maybe_const (tree expr
, bool non_const
)
3694 bool nowarning
= TREE_NO_WARNING (expr
);
3695 location_t loc
= EXPR_LOCATION (expr
);
3697 /* This should never be called for C++. */
3698 if (c_dialect_cxx ())
3701 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3702 STRIP_TYPE_NOPS (expr
);
3703 expr
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL
, expr
);
3704 C_MAYBE_CONST_EXPR_NON_CONST (expr
) = non_const
;
3706 TREE_NO_WARNING (expr
) = 1;
3707 protected_set_expr_location (expr
, loc
);
3712 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3713 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3714 around the SAVE_EXPR if needed so that c_fully_fold does not need
3715 to look inside SAVE_EXPRs. */
3718 c_save_expr (tree expr
)
3720 bool maybe_const
= true;
3721 if (c_dialect_cxx ())
3722 return save_expr (expr
);
3723 expr
= c_fully_fold (expr
, false, &maybe_const
);
3724 expr
= save_expr (expr
);
3726 expr
= c_wrap_maybe_const (expr
, true);
3730 /* Return whether EXPR is a declaration whose address can never be
3734 decl_with_nonnull_addr_p (const_tree expr
)
3736 return (DECL_P (expr
)
3737 && (TREE_CODE (expr
) == PARM_DECL
3738 || TREE_CODE (expr
) == LABEL_DECL
3739 || !DECL_WEAK (expr
)));
3742 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3743 or for an `if' or `while' statement or ?..: exp. It should already
3744 have been validated to be of suitable type; otherwise, a bad
3745 diagnostic may result.
3747 The EXPR is located at LOCATION.
3749 This preparation consists of taking the ordinary
3750 representation of an expression expr and producing a valid tree
3751 boolean expression describing whether expr is nonzero. We could
3752 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3753 but we optimize comparisons, &&, ||, and !.
3755 The resulting type should always be `truthvalue_type_node'. */
3758 c_common_truthvalue_conversion (location_t location
, tree expr
)
3760 switch (TREE_CODE (expr
))
3762 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
3763 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3764 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
3765 case ORDERED_EXPR
: case UNORDERED_EXPR
:
3766 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3768 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3769 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
3772 case TRUTH_ANDIF_EXPR
:
3773 case TRUTH_ORIF_EXPR
:
3774 case TRUTH_AND_EXPR
:
3776 case TRUTH_XOR_EXPR
:
3777 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3779 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3780 c_common_truthvalue_conversion (location
,
3781 TREE_OPERAND (expr
, 0)),
3782 c_common_truthvalue_conversion (location
,
3783 TREE_OPERAND (expr
, 1)));
3786 case TRUTH_NOT_EXPR
:
3787 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3789 expr
= build1 (TREE_CODE (expr
), truthvalue_type_node
,
3790 c_common_truthvalue_conversion (location
,
3791 TREE_OPERAND (expr
, 0)));
3798 return integer_zerop (expr
) ? truthvalue_false_node
3799 : truthvalue_true_node
;
3802 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3803 ? truthvalue_true_node
3804 : truthvalue_false_node
;
3807 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3808 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3809 ? truthvalue_true_node
3810 : truthvalue_false_node
;
3813 expr
= build_unary_op (location
, ADDR_EXPR
, expr
, 0);
3818 tree inner
= TREE_OPERAND (expr
, 0);
3819 if (decl_with_nonnull_addr_p (inner
))
3821 /* Common Ada/Pascal programmer's mistake. */
3822 warning_at (location
,
3824 "the address of %qD will always evaluate as %<true%>",
3826 return truthvalue_true_node
;
3832 expr
= build_binary_op (EXPR_LOCATION (expr
),
3833 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3834 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3835 c_common_truthvalue_conversion (location
,
3836 TREE_OPERAND (expr
, 0)),
3837 c_common_truthvalue_conversion (location
,
3838 TREE_OPERAND (expr
, 1)),
3845 case EXCESS_PRECISION_EXPR
:
3846 /* These don't change whether an object is nonzero or zero. */
3847 return c_common_truthvalue_conversion (location
, TREE_OPERAND (expr
, 0));
3851 /* These don't change whether an object is zero or nonzero, but
3852 we can't ignore them if their second arg has side-effects. */
3853 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3855 expr
= build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3856 TREE_OPERAND (expr
, 1),
3857 c_common_truthvalue_conversion
3858 (location
, TREE_OPERAND (expr
, 0)));
3862 return c_common_truthvalue_conversion (location
,
3863 TREE_OPERAND (expr
, 0));
3866 /* Distribute the conversion into the arms of a COND_EXPR. */
3867 if (c_dialect_cxx ())
3869 expr
= fold_build3_loc (location
, COND_EXPR
, truthvalue_type_node
,
3870 TREE_OPERAND (expr
, 0),
3871 c_common_truthvalue_conversion (location
,
3874 c_common_truthvalue_conversion (location
,
3881 /* Folding will happen later for C. */
3882 expr
= build3 (COND_EXPR
, truthvalue_type_node
,
3883 TREE_OPERAND (expr
, 0),
3884 c_common_truthvalue_conversion (location
,
3885 TREE_OPERAND (expr
, 1)),
3886 c_common_truthvalue_conversion (location
,
3887 TREE_OPERAND (expr
, 2)));
3892 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3893 since that affects how `default_conversion' will behave. */
3894 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
3895 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
3897 /* If this is widening the argument, we can ignore it. */
3898 if (TYPE_PRECISION (TREE_TYPE (expr
))
3899 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
3900 return c_common_truthvalue_conversion (location
,
3901 TREE_OPERAND (expr
, 0));
3905 if (!TREE_NO_WARNING (expr
)
3906 && warn_parentheses
)
3908 warning (OPT_Wparentheses
,
3909 "suggest parentheses around assignment used as truth value");
3910 TREE_NO_WARNING (expr
) = 1;
3918 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
3920 tree t
= c_save_expr (expr
);
3921 expr
= (build_binary_op
3922 (EXPR_LOCATION (expr
),
3923 (TREE_SIDE_EFFECTS (expr
)
3924 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3925 c_common_truthvalue_conversion
3927 build_unary_op (location
, REALPART_EXPR
, t
, 0)),
3928 c_common_truthvalue_conversion
3930 build_unary_op (location
, IMAGPART_EXPR
, t
, 0)),
3935 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
3937 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
3939 (TREE_TYPE (expr
))));
3940 return build_binary_op (location
, NE_EXPR
, expr
, fixed_zero_node
, 1);
3943 return build_binary_op (location
, NE_EXPR
, expr
, integer_zero_node
, 1);
3946 protected_set_expr_location (expr
, location
);
3950 static void def_builtin_1 (enum built_in_function fncode
,
3952 enum built_in_class fnclass
,
3953 tree fntype
, tree libtype
,
3954 bool both_p
, bool fallback_p
, bool nonansi_p
,
3955 tree fnattrs
, bool implicit_p
);
3958 /* Apply the TYPE_QUALS to the new DECL. */
3961 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
3963 tree type
= TREE_TYPE (decl
);
3965 if (type
== error_mark_node
)
3968 if (((type_quals
& TYPE_QUAL_CONST
)
3969 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
3970 /* An object declared 'const' is only readonly after it is
3971 initialized. We don't have any way of expressing this currently,
3972 so we need to be conservative and unset TREE_READONLY for types
3973 with constructors. Otherwise aliasing code will ignore stores in
3974 an inline constructor. */
3975 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
3976 TREE_READONLY (decl
) = 1;
3977 if (type_quals
& TYPE_QUAL_VOLATILE
)
3979 TREE_SIDE_EFFECTS (decl
) = 1;
3980 TREE_THIS_VOLATILE (decl
) = 1;
3982 if (type_quals
& TYPE_QUAL_RESTRICT
)
3984 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
3985 /* Allow 'restrict' on arrays of pointers.
3986 FIXME currently we just ignore it. */
3987 type
= TREE_TYPE (type
);
3989 || !POINTER_TYPE_P (type
)
3990 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
3991 error ("invalid use of %<restrict%>");
3995 /* Hash function for the problem of multiple type definitions in
3996 different files. This must hash all types that will compare
3997 equal via comptypes to the same value. In practice it hashes
3998 on some of the simple stuff and leaves the details to comptypes. */
4001 c_type_hash (const void *p
)
4005 const_tree
const t
= (const_tree
) p
;
4007 switch (TREE_CODE (t
))
4009 /* For pointers, hash on pointee type plus some swizzling. */
4011 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
4012 /* Hash on number of elements and total size. */
4015 t2
= TYPE_VALUES (t
);
4019 t2
= TYPE_FIELDS (t
);
4021 case QUAL_UNION_TYPE
:
4023 t2
= TYPE_FIELDS (t
);
4027 t2
= TYPE_FIELDS (t
);
4032 for (; t2
; t2
= DECL_CHAIN (t2
))
4034 /* We might have a VLA here. */
4035 if (TREE_CODE (TYPE_SIZE (t
)) != INTEGER_CST
)
4038 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
4039 return ((size
<< 24) | (i
<< shift
));
4042 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
4044 /* Return the typed-based alias set for T, which may be an expression
4045 or a type. Return -1 if we don't do anything special. */
4048 c_common_get_alias_set (tree t
)
4053 /* For VLAs, use the alias set of the element type rather than the
4054 default of alias set 0 for types compared structurally. */
4055 if (TYPE_P (t
) && TYPE_STRUCTURAL_EQUALITY_P (t
))
4057 if (TREE_CODE (t
) == ARRAY_TYPE
)
4058 return get_alias_set (TREE_TYPE (t
));
4062 /* Permit type-punning when accessing a union, provided the access
4063 is directly through the union. For example, this code does not
4064 permit taking the address of a union member and then storing
4065 through it. Even the type-punning allowed here is a GCC
4066 extension, albeit a common and useful one; the C standard says
4067 that such accesses have implementation-defined behavior. */
4069 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
4070 u
= TREE_OPERAND (u
, 0))
4071 if (TREE_CODE (u
) == COMPONENT_REF
4072 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
4075 /* That's all the expressions we handle specially. */
4079 /* The C standard guarantees that any object may be accessed via an
4080 lvalue that has character type. */
4081 if (t
== char_type_node
4082 || t
== signed_char_type_node
4083 || t
== unsigned_char_type_node
)
4086 /* The C standard specifically allows aliasing between signed and
4087 unsigned variants of the same type. We treat the signed
4088 variant as canonical. */
4089 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
4091 tree t1
= c_common_signed_type (t
);
4093 /* t1 == t can happen for boolean nodes which are always unsigned. */
4095 return get_alias_set (t1
);
4098 /* Handle the case of multiple type nodes referring to "the same" type,
4099 which occurs with IMA. These share an alias set. FIXME: Currently only
4100 C90 is handled. (In C99 type compatibility is not transitive, which
4101 complicates things mightily. The alias set splay trees can theoretically
4102 represent this, but insertion is tricky when you consider all the
4103 different orders things might arrive in.) */
4105 if (c_language
!= clk_c
|| flag_isoc99
)
4108 /* Save time if there's only one input file. */
4109 if (num_in_fnames
== 1)
4112 /* Pointers need special handling if they point to any type that
4113 needs special handling (below). */
4114 if (TREE_CODE (t
) == POINTER_TYPE
)
4117 /* Find bottom type under any nested POINTERs. */
4118 for (t2
= TREE_TYPE (t
);
4119 TREE_CODE (t2
) == POINTER_TYPE
;
4120 t2
= TREE_TYPE (t2
))
4122 if (TREE_CODE (t2
) != RECORD_TYPE
4123 && TREE_CODE (t2
) != ENUMERAL_TYPE
4124 && TREE_CODE (t2
) != QUAL_UNION_TYPE
4125 && TREE_CODE (t2
) != UNION_TYPE
)
4127 if (TYPE_SIZE (t2
) == 0)
4130 /* These are the only cases that need special handling. */
4131 if (TREE_CODE (t
) != RECORD_TYPE
4132 && TREE_CODE (t
) != ENUMERAL_TYPE
4133 && TREE_CODE (t
) != QUAL_UNION_TYPE
4134 && TREE_CODE (t
) != UNION_TYPE
4135 && TREE_CODE (t
) != POINTER_TYPE
)
4138 if (TYPE_SIZE (t
) == 0)
4141 /* Look up t in hash table. Only one of the compatible types within each
4142 alias set is recorded in the table. */
4143 if (!type_hash_table
)
4144 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
4145 (htab_eq
) lang_hooks
.types_compatible_p
,
4147 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
4150 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
4151 return TYPE_ALIAS_SET ((tree
)*slot
);
4154 /* Our caller will assign and record (in t) a new alias set; all we need
4155 to do is remember t in the hash table. */
4161 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4162 the second parameter indicates which OPERATOR is being applied.
4163 The COMPLAIN flag controls whether we should diagnose possibly
4164 ill-formed constructs or not. LOC is the location of the SIZEOF or
4168 c_sizeof_or_alignof_type (location_t loc
,
4169 tree type
, bool is_sizeof
, int complain
)
4171 const char *op_name
;
4173 enum tree_code type_code
= TREE_CODE (type
);
4175 op_name
= is_sizeof
? "sizeof" : "__alignof__";
4177 if (type_code
== FUNCTION_TYPE
)
4181 if (complain
&& (pedantic
|| warn_pointer_arith
))
4182 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4183 "invalid application of %<sizeof%> to a function type");
4185 return error_mark_node
;
4186 value
= size_one_node
;
4189 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
4191 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
4193 if (type_code
== VOID_TYPE
4194 && complain
&& (pedantic
|| warn_pointer_arith
))
4195 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4196 "invalid application of %qs to a void type", op_name
);
4198 return error_mark_node
;
4199 value
= size_one_node
;
4201 else if (!COMPLETE_TYPE_P (type
))
4204 error_at (loc
, "invalid application of %qs to incomplete type %qT ",
4206 return error_mark_node
;
4211 /* Convert in case a char is more than one unit. */
4212 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
4213 size_int (TYPE_PRECISION (char_type_node
)
4216 value
= size_int (TYPE_ALIGN_UNIT (type
));
4219 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4220 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4221 never happen. However, this node should really have type
4222 `size_t', which is just a typedef for an ordinary integer type. */
4223 value
= fold_convert_loc (loc
, size_type_node
, value
);
4224 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)));
4229 /* Implement the __alignof keyword: Return the minimum required
4230 alignment of EXPR, measured in bytes. For VAR_DECLs,
4231 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4232 from an "aligned" __attribute__ specification). LOC is the
4233 location of the ALIGNOF operator. */
4236 c_alignof_expr (location_t loc
, tree expr
)
4240 if (VAR_OR_FUNCTION_DECL_P (expr
))
4241 t
= size_int (DECL_ALIGN_UNIT (expr
));
4243 else if (TREE_CODE (expr
) == COMPONENT_REF
4244 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
4246 error_at (loc
, "%<__alignof%> applied to a bit-field");
4249 else if (TREE_CODE (expr
) == COMPONENT_REF
4250 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
4251 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
4253 else if (TREE_CODE (expr
) == INDIRECT_REF
)
4255 tree t
= TREE_OPERAND (expr
, 0);
4257 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4259 while (CONVERT_EXPR_P (t
)
4260 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
4264 t
= TREE_OPERAND (t
, 0);
4265 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4266 if (thisalign
> bestalign
)
4267 best
= t
, bestalign
= thisalign
;
4269 return c_alignof (loc
, TREE_TYPE (TREE_TYPE (best
)));
4272 return c_alignof (loc
, TREE_TYPE (expr
));
4274 return fold_convert_loc (loc
, size_type_node
, t
);
4277 /* Handle C and C++ default attributes. */
4279 enum built_in_attribute
4281 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4282 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4283 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4284 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4285 #include "builtin-attrs.def"
4286 #undef DEF_ATTR_NULL_TREE
4288 #undef DEF_ATTR_IDENT
4289 #undef DEF_ATTR_TREE_LIST
4293 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
4295 static void c_init_attributes (void);
4299 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4300 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4301 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4302 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4303 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4304 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4305 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4306 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4307 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4308 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4309 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4310 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4311 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4312 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4313 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4315 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4316 #include "builtin-types.def"
4317 #undef DEF_PRIMITIVE_TYPE
4318 #undef DEF_FUNCTION_TYPE_0
4319 #undef DEF_FUNCTION_TYPE_1
4320 #undef DEF_FUNCTION_TYPE_2
4321 #undef DEF_FUNCTION_TYPE_3
4322 #undef DEF_FUNCTION_TYPE_4
4323 #undef DEF_FUNCTION_TYPE_5
4324 #undef DEF_FUNCTION_TYPE_6
4325 #undef DEF_FUNCTION_TYPE_7
4326 #undef DEF_FUNCTION_TYPE_VAR_0
4327 #undef DEF_FUNCTION_TYPE_VAR_1
4328 #undef DEF_FUNCTION_TYPE_VAR_2
4329 #undef DEF_FUNCTION_TYPE_VAR_3
4330 #undef DEF_FUNCTION_TYPE_VAR_4
4331 #undef DEF_FUNCTION_TYPE_VAR_5
4332 #undef DEF_POINTER_TYPE
4336 typedef enum c_builtin_type builtin_type
;
4338 /* A temporary array for c_common_nodes_and_builtins. Used in
4339 communication with def_fn_type. */
4340 static tree builtin_types
[(int) BT_LAST
+ 1];
4342 /* A helper function for c_common_nodes_and_builtins. Build function type
4343 for DEF with return type RET and N arguments. If VAR is true, then the
4344 function should be variadic after those N arguments.
4346 Takes special care not to ICE if any of the types involved are
4347 error_mark_node, which indicates that said type is not in fact available
4348 (see builtin_type_for_size). In which case the function type as a whole
4349 should be error_mark_node. */
4352 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
4354 tree args
= NULL
, t
;
4359 for (i
= 0; i
< n
; ++i
)
4361 builtin_type a
= (builtin_type
) va_arg (list
, int);
4362 t
= builtin_types
[a
];
4363 if (t
== error_mark_node
)
4365 args
= tree_cons (NULL_TREE
, t
, args
);
4369 args
= nreverse (args
);
4371 args
= chainon (args
, void_list_node
);
4373 t
= builtin_types
[ret
];
4374 if (t
== error_mark_node
)
4376 t
= build_function_type (t
, args
);
4379 builtin_types
[def
] = t
;
4382 /* Build builtin functions common to both C and C++ language
4386 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
4388 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4389 builtin_types[ENUM] = VALUE;
4390 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4391 def_fn_type (ENUM, RETURN, 0, 0);
4392 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4393 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4394 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4395 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4396 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4397 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4398 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4399 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4400 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4401 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4402 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4404 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4405 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4407 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4408 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4409 def_fn_type (ENUM, RETURN, 1, 0);
4410 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4411 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4412 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4413 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4414 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4415 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4416 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4417 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4418 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4419 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4420 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4421 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4423 #include "builtin-types.def"
4425 #undef DEF_PRIMITIVE_TYPE
4426 #undef DEF_FUNCTION_TYPE_1
4427 #undef DEF_FUNCTION_TYPE_2
4428 #undef DEF_FUNCTION_TYPE_3
4429 #undef DEF_FUNCTION_TYPE_4
4430 #undef DEF_FUNCTION_TYPE_5
4431 #undef DEF_FUNCTION_TYPE_6
4432 #undef DEF_FUNCTION_TYPE_VAR_0
4433 #undef DEF_FUNCTION_TYPE_VAR_1
4434 #undef DEF_FUNCTION_TYPE_VAR_2
4435 #undef DEF_FUNCTION_TYPE_VAR_3
4436 #undef DEF_FUNCTION_TYPE_VAR_4
4437 #undef DEF_FUNCTION_TYPE_VAR_5
4438 #undef DEF_POINTER_TYPE
4439 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
4441 c_init_attributes ();
4443 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4444 NONANSI_P, ATTRS, IMPLICIT, COND) \
4446 def_builtin_1 (ENUM, NAME, CLASS, \
4447 builtin_types[(int) TYPE], \
4448 builtin_types[(int) LIBTYPE], \
4449 BOTH_P, FALLBACK_P, NONANSI_P, \
4450 built_in_attributes[(int) ATTRS], IMPLICIT);
4451 #include "builtins.def"
4454 targetm
.init_builtins ();
4456 build_common_builtin_nodes ();
4462 /* Like get_identifier, but avoid warnings about null arguments when
4463 the argument may be NULL for targets where GCC lacks stdint.h type
4467 c_get_ident (const char *id
)
4469 return get_identifier (id
);
4472 /* Build tree nodes and builtin functions common to both C and C++ language
4476 c_common_nodes_and_builtins (void)
4478 int char16_type_size
;
4479 int char32_type_size
;
4480 int wchar_type_size
;
4481 tree array_domain_type
;
4482 tree va_list_ref_type_node
;
4483 tree va_list_arg_type_node
;
4485 /* Define `int' and `char' first so that dbx will output them first. */
4486 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
4487 record_builtin_type (RID_CHAR
, "char", char_type_node
);
4489 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4490 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4491 but not C. Are the conditionals here needed? */
4492 if (c_dialect_cxx ())
4493 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
4494 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
4495 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
4496 record_builtin_type (RID_MAX
, "long unsigned int",
4497 long_unsigned_type_node
);
4498 if (int128_integer_type_node
!= NULL_TREE
)
4500 record_builtin_type (RID_INT128
, "__int128",
4501 int128_integer_type_node
);
4502 record_builtin_type (RID_MAX
, "__int128 unsigned",
4503 int128_unsigned_type_node
);
4505 if (c_dialect_cxx ())
4506 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
4507 record_builtin_type (RID_MAX
, "long long int",
4508 long_long_integer_type_node
);
4509 record_builtin_type (RID_MAX
, "long long unsigned int",
4510 long_long_unsigned_type_node
);
4511 if (c_dialect_cxx ())
4512 record_builtin_type (RID_MAX
, "long long unsigned",
4513 long_long_unsigned_type_node
);
4514 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
4515 record_builtin_type (RID_MAX
, "short unsigned int",
4516 short_unsigned_type_node
);
4517 if (c_dialect_cxx ())
4518 record_builtin_type (RID_MAX
, "unsigned short",
4519 short_unsigned_type_node
);
4521 /* Define both `signed char' and `unsigned char'. */
4522 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
4523 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
4525 /* These are types that c_common_type_for_size and
4526 c_common_type_for_mode use. */
4527 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4528 TYPE_DECL
, NULL_TREE
,
4530 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4531 TYPE_DECL
, NULL_TREE
,
4533 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4534 TYPE_DECL
, NULL_TREE
,
4536 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4537 TYPE_DECL
, NULL_TREE
,
4539 #if HOST_BITS_PER_WIDE_INT >= 64
4540 if (targetm
.scalar_mode_supported_p (TImode
))
4541 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4543 get_identifier ("__int128_t"),
4546 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4547 TYPE_DECL
, NULL_TREE
,
4548 unsigned_intQI_type_node
));
4549 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4550 TYPE_DECL
, NULL_TREE
,
4551 unsigned_intHI_type_node
));
4552 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4553 TYPE_DECL
, NULL_TREE
,
4554 unsigned_intSI_type_node
));
4555 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4556 TYPE_DECL
, NULL_TREE
,
4557 unsigned_intDI_type_node
));
4558 #if HOST_BITS_PER_WIDE_INT >= 64
4559 if (targetm
.scalar_mode_supported_p (TImode
))
4560 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4562 get_identifier ("__uint128_t"),
4563 unsigned_intTI_type_node
));
4566 /* Create the widest literal types. */
4567 widest_integer_literal_type_node
4568 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
4569 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4570 TYPE_DECL
, NULL_TREE
,
4571 widest_integer_literal_type_node
));
4573 widest_unsigned_literal_type_node
4574 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
4575 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4576 TYPE_DECL
, NULL_TREE
,
4577 widest_unsigned_literal_type_node
));
4579 /* `unsigned long' is the standard type for sizeof.
4580 Note that stddef.h uses `unsigned long',
4581 and this must agree, even if long and int are the same size. */
4583 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
4584 signed_size_type_node
= c_common_signed_type (size_type_node
);
4585 set_sizetype (size_type_node
);
4588 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
4590 build_common_tree_nodes_2 (flag_short_double
);
4592 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
4593 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
4594 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
4596 /* Only supported decimal floating point extension if the target
4597 actually supports underlying modes. */
4598 if (targetm
.scalar_mode_supported_p (SDmode
)
4599 && targetm
.scalar_mode_supported_p (DDmode
)
4600 && targetm
.scalar_mode_supported_p (TDmode
))
4602 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
4603 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
4604 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
4607 if (targetm
.fixed_point_supported_p ())
4609 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
4610 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
4611 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
4612 record_builtin_type (RID_MAX
, "long long _Fract",
4613 long_long_fract_type_node
);
4614 record_builtin_type (RID_MAX
, "unsigned short _Fract",
4615 unsigned_short_fract_type_node
);
4616 record_builtin_type (RID_MAX
, "unsigned _Fract",
4617 unsigned_fract_type_node
);
4618 record_builtin_type (RID_MAX
, "unsigned long _Fract",
4619 unsigned_long_fract_type_node
);
4620 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
4621 unsigned_long_long_fract_type_node
);
4622 record_builtin_type (RID_MAX
, "_Sat short _Fract",
4623 sat_short_fract_type_node
);
4624 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
4625 record_builtin_type (RID_MAX
, "_Sat long _Fract",
4626 sat_long_fract_type_node
);
4627 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
4628 sat_long_long_fract_type_node
);
4629 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
4630 sat_unsigned_short_fract_type_node
);
4631 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
4632 sat_unsigned_fract_type_node
);
4633 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
4634 sat_unsigned_long_fract_type_node
);
4635 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
4636 sat_unsigned_long_long_fract_type_node
);
4637 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
4638 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
4639 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
4640 record_builtin_type (RID_MAX
, "long long _Accum",
4641 long_long_accum_type_node
);
4642 record_builtin_type (RID_MAX
, "unsigned short _Accum",
4643 unsigned_short_accum_type_node
);
4644 record_builtin_type (RID_MAX
, "unsigned _Accum",
4645 unsigned_accum_type_node
);
4646 record_builtin_type (RID_MAX
, "unsigned long _Accum",
4647 unsigned_long_accum_type_node
);
4648 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
4649 unsigned_long_long_accum_type_node
);
4650 record_builtin_type (RID_MAX
, "_Sat short _Accum",
4651 sat_short_accum_type_node
);
4652 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
4653 record_builtin_type (RID_MAX
, "_Sat long _Accum",
4654 sat_long_accum_type_node
);
4655 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
4656 sat_long_long_accum_type_node
);
4657 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
4658 sat_unsigned_short_accum_type_node
);
4659 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
4660 sat_unsigned_accum_type_node
);
4661 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
4662 sat_unsigned_long_accum_type_node
);
4663 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
4664 sat_unsigned_long_long_accum_type_node
);
4668 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4670 get_identifier ("complex int"),
4671 complex_integer_type_node
));
4672 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4674 get_identifier ("complex float"),
4675 complex_float_type_node
));
4676 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4678 get_identifier ("complex double"),
4679 complex_double_type_node
));
4680 lang_hooks
.decls
.pushdecl
4681 (build_decl (UNKNOWN_LOCATION
,
4682 TYPE_DECL
, get_identifier ("complex long double"),
4683 complex_long_double_type_node
));
4685 if (c_dialect_cxx ())
4686 /* For C++, make fileptr_type_node a distinct void * type until
4687 FILE type is defined. */
4688 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
4690 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
4692 /* Set the TYPE_NAME for any variants that were built before
4693 record_builtin_type gave names to the built-in types. */
4695 tree void_name
= TYPE_NAME (void_type_node
);
4696 TYPE_NAME (void_type_node
) = NULL_TREE
;
4697 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
4699 TYPE_NAME (void_type_node
) = void_name
;
4702 /* This node must not be shared. */
4703 void_zero_node
= make_node (INTEGER_CST
);
4704 TREE_TYPE (void_zero_node
) = void_type_node
;
4706 void_list_node
= build_void_list_node ();
4708 /* Make a type to be the domain of a few array types
4709 whose domains don't really matter.
4710 200 is small enough that it always fits in size_t
4711 and large enough that it can hold most function names for the
4712 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4713 array_domain_type
= build_index_type (size_int (200));
4715 /* Make a type for arrays of characters.
4716 With luck nothing will ever really depend on the length of this
4718 char_array_type_node
4719 = build_array_type (char_type_node
, array_domain_type
);
4721 /* Likewise for arrays of ints. */
4723 = build_array_type (integer_type_node
, array_domain_type
);
4725 string_type_node
= build_pointer_type (char_type_node
);
4726 const_string_type_node
4727 = build_pointer_type (build_qualified_type
4728 (char_type_node
, TYPE_QUAL_CONST
));
4730 /* This is special for C++ so functions can be overloaded. */
4731 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
4732 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
4733 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
4734 underlying_wchar_type_node
= wchar_type_node
;
4735 if (c_dialect_cxx ())
4737 if (TYPE_UNSIGNED (wchar_type_node
))
4738 wchar_type_node
= make_unsigned_type (wchar_type_size
);
4740 wchar_type_node
= make_signed_type (wchar_type_size
);
4741 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
4744 /* This is for wide string constants. */
4745 wchar_array_type_node
4746 = build_array_type (wchar_type_node
, array_domain_type
);
4748 /* Define 'char16_t'. */
4749 char16_type_node
= get_identifier (CHAR16_TYPE
);
4750 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
4751 char16_type_size
= TYPE_PRECISION (char16_type_node
);
4752 if (c_dialect_cxx ())
4754 char16_type_node
= make_unsigned_type (char16_type_size
);
4756 if (cxx_dialect
== cxx0x
)
4757 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
4760 /* This is for UTF-16 string constants. */
4761 char16_array_type_node
4762 = build_array_type (char16_type_node
, array_domain_type
);
4764 /* Define 'char32_t'. */
4765 char32_type_node
= get_identifier (CHAR32_TYPE
);
4766 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
4767 char32_type_size
= TYPE_PRECISION (char32_type_node
);
4768 if (c_dialect_cxx ())
4770 char32_type_node
= make_unsigned_type (char32_type_size
);
4772 if (cxx_dialect
== cxx0x
)
4773 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
4776 /* This is for UTF-32 string constants. */
4777 char32_array_type_node
4778 = build_array_type (char32_type_node
, array_domain_type
);
4781 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
4784 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
4786 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
4788 if (SIG_ATOMIC_TYPE
)
4789 sig_atomic_type_node
=
4790 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE
)));
4793 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE
)));
4796 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE
)));
4799 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE
)));
4802 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE
)));
4805 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE
)));
4808 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE
)));
4810 c_uint32_type_node
=
4811 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE
)));
4813 c_uint64_type_node
=
4814 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE
)));
4815 if (INT_LEAST8_TYPE
)
4816 int_least8_type_node
=
4817 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE
)));
4818 if (INT_LEAST16_TYPE
)
4819 int_least16_type_node
=
4820 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE
)));
4821 if (INT_LEAST32_TYPE
)
4822 int_least32_type_node
=
4823 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE
)));
4824 if (INT_LEAST64_TYPE
)
4825 int_least64_type_node
=
4826 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE
)));
4827 if (UINT_LEAST8_TYPE
)
4828 uint_least8_type_node
=
4829 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE
)));
4830 if (UINT_LEAST16_TYPE
)
4831 uint_least16_type_node
=
4832 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE
)));
4833 if (UINT_LEAST32_TYPE
)
4834 uint_least32_type_node
=
4835 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE
)));
4836 if (UINT_LEAST64_TYPE
)
4837 uint_least64_type_node
=
4838 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE
)));
4840 int_fast8_type_node
=
4841 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE
)));
4842 if (INT_FAST16_TYPE
)
4843 int_fast16_type_node
=
4844 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE
)));
4845 if (INT_FAST32_TYPE
)
4846 int_fast32_type_node
=
4847 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE
)));
4848 if (INT_FAST64_TYPE
)
4849 int_fast64_type_node
=
4850 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE
)));
4851 if (UINT_FAST8_TYPE
)
4852 uint_fast8_type_node
=
4853 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE
)));
4854 if (UINT_FAST16_TYPE
)
4855 uint_fast16_type_node
=
4856 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE
)));
4857 if (UINT_FAST32_TYPE
)
4858 uint_fast32_type_node
=
4859 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE
)));
4860 if (UINT_FAST64_TYPE
)
4861 uint_fast64_type_node
=
4862 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE
)));
4865 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE
)));
4868 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE
)));
4870 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
4872 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
4873 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
4875 lang_hooks
.decls
.pushdecl
4876 (build_decl (UNKNOWN_LOCATION
,
4877 TYPE_DECL
, get_identifier ("__builtin_va_list"),
4878 va_list_type_node
));
4879 if (targetm
.enum_va_list_p
)
4885 for (l
= 0; targetm
.enum_va_list_p (l
, &pname
, &ptype
); ++l
)
4887 lang_hooks
.decls
.pushdecl
4888 (build_decl (UNKNOWN_LOCATION
,
4889 TYPE_DECL
, get_identifier (pname
),
4895 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4897 va_list_arg_type_node
= va_list_ref_type_node
=
4898 build_pointer_type (TREE_TYPE (va_list_type_node
));
4902 va_list_arg_type_node
= va_list_type_node
;
4903 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
4906 if (!flag_preprocess_only
)
4907 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
4909 main_identifier_node
= get_identifier ("main");
4911 /* Create the built-in __null node. It is important that this is
4913 null_node
= make_node (INTEGER_CST
);
4914 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
4916 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4917 memset (builtin_types
, 0, sizeof (builtin_types
));
4920 /* The number of named compound-literals generated thus far. */
4921 static GTY(()) int compound_literal_number
;
4923 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4926 set_compound_literal_name (tree decl
)
4929 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
4930 compound_literal_number
);
4931 compound_literal_number
++;
4932 DECL_NAME (decl
) = get_identifier (name
);
4936 build_va_arg (location_t loc
, tree expr
, tree type
)
4938 expr
= build1 (VA_ARG_EXPR
, type
, expr
);
4939 SET_EXPR_LOCATION (expr
, loc
);
4944 /* Linked list of disabled built-in functions. */
4946 typedef struct disabled_builtin
4949 struct disabled_builtin
*next
;
4951 static disabled_builtin
*disabled_builtins
= NULL
;
4953 static bool builtin_function_disabled_p (const char *);
4955 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4956 begins with "__builtin_", give an error. */
4959 disable_builtin_function (const char *name
)
4961 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
4962 error ("cannot disable built-in function %qs", name
);
4965 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
4966 new_disabled_builtin
->name
= name
;
4967 new_disabled_builtin
->next
= disabled_builtins
;
4968 disabled_builtins
= new_disabled_builtin
;
4973 /* Return true if the built-in function NAME has been disabled, false
4977 builtin_function_disabled_p (const char *name
)
4979 disabled_builtin
*p
;
4980 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
4982 if (strcmp (name
, p
->name
) == 0)
4989 /* Worker for DEF_BUILTIN.
4990 Possibly define a builtin function with one or two names.
4991 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4992 nonansi_p and flag_no_nonansi_builtin. */
4995 def_builtin_1 (enum built_in_function fncode
,
4997 enum built_in_class fnclass
,
4998 tree fntype
, tree libtype
,
4999 bool both_p
, bool fallback_p
, bool nonansi_p
,
5000 tree fnattrs
, bool implicit_p
)
5003 const char *libname
;
5005 if (fntype
== error_mark_node
)
5008 gcc_assert ((!both_p
&& !fallback_p
)
5009 || !strncmp (name
, "__builtin_",
5010 strlen ("__builtin_")));
5012 libname
= name
+ strlen ("__builtin_");
5013 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
5014 (fallback_p
? libname
: NULL
),
5017 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
5018 && !(nonansi_p
&& flag_no_nonansi_builtin
))
5019 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
5022 built_in_decls
[(int) fncode
] = decl
;
5024 implicit_built_in_decls
[(int) fncode
] = decl
;
5027 /* Nonzero if the type T promotes to int. This is (nearly) the
5028 integral promotions defined in ISO C99 6.3.1.1/2. */
5031 c_promoting_integer_type_p (const_tree t
)
5033 switch (TREE_CODE (t
))
5036 return (TYPE_MAIN_VARIANT (t
) == char_type_node
5037 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
5038 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
5039 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
5040 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
5041 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
5044 /* ??? Technically all enumerations not larger than an int
5045 promote to an int. But this is used along code paths
5046 that only want to notice a size change. */
5047 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
5057 /* Return 1 if PARMS specifies a fixed number of parameters
5058 and none of their types is affected by default promotions. */
5061 self_promoting_args_p (const_tree parms
)
5064 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
5066 tree type
= TREE_VALUE (t
);
5068 if (type
== error_mark_node
)
5071 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
5077 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
5080 if (c_promoting_integer_type_p (type
))
5086 /* Recursively remove any '*' or '&' operator from TYPE. */
5088 strip_pointer_operator (tree t
)
5090 while (POINTER_TYPE_P (t
))
5095 /* Recursively remove pointer or array type from TYPE. */
5097 strip_pointer_or_array_types (tree t
)
5099 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
5104 /* Used to compare case labels. K1 and K2 are actually tree nodes
5105 representing case labels, or NULL_TREE for a `default' label.
5106 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5107 K2, and 0 if K1 and K2 are equal. */
5110 case_compare (splay_tree_key k1
, splay_tree_key k2
)
5112 /* Consider a NULL key (such as arises with a `default' label) to be
5113 smaller than anything else. */
5119 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5122 /* Process a case label, located at LOC, for the range LOW_VALUE
5123 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5124 then this case label is actually a `default' label. If only
5125 HIGH_VALUE is NULL_TREE, then case label was declared using the
5126 usual C/C++ syntax, rather than the GNU case range extension.
5127 CASES is a tree containing all the case ranges processed so far;
5128 COND is the condition for the switch-statement itself. Returns the
5129 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5133 c_add_case_label (location_t loc
, splay_tree cases
, tree cond
, tree orig_type
,
5134 tree low_value
, tree high_value
)
5139 splay_tree_node node
;
5141 /* Create the LABEL_DECL itself. */
5142 label
= create_artificial_label (loc
);
5144 /* If there was an error processing the switch condition, bail now
5145 before we get more confused. */
5146 if (!cond
|| cond
== error_mark_node
)
5149 if ((low_value
&& TREE_TYPE (low_value
)
5150 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
5151 || (high_value
&& TREE_TYPE (high_value
)
5152 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
5154 error_at (loc
, "pointers are not permitted as case values");
5158 /* Case ranges are a GNU extension. */
5160 pedwarn (loc
, OPT_pedantic
,
5161 "range expressions in switch statements are non-standard");
5163 type
= TREE_TYPE (cond
);
5166 low_value
= check_case_value (low_value
);
5167 low_value
= convert_and_check (type
, low_value
);
5168 if (low_value
== error_mark_node
)
5173 high_value
= check_case_value (high_value
);
5174 high_value
= convert_and_check (type
, high_value
);
5175 if (high_value
== error_mark_node
)
5179 if (low_value
&& high_value
)
5181 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5182 really a case range, even though it was written that way.
5183 Remove the HIGH_VALUE to simplify later processing. */
5184 if (tree_int_cst_equal (low_value
, high_value
))
5185 high_value
= NULL_TREE
;
5186 else if (!tree_int_cst_lt (low_value
, high_value
))
5187 warning_at (loc
, 0, "empty range specified");
5190 /* See if the case is in range of the type of the original testing
5191 expression. If both low_value and high_value are out of range,
5192 don't insert the case label and return NULL_TREE. */
5194 && !check_case_bounds (type
, orig_type
,
5195 &low_value
, high_value
? &high_value
: NULL
))
5198 /* Look up the LOW_VALUE in the table of case labels we already
5200 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
5201 /* If there was not an exact match, check for overlapping ranges.
5202 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5203 that's a `default' label and the only overlap is an exact match. */
5204 if (!node
&& (low_value
|| high_value
))
5206 splay_tree_node low_bound
;
5207 splay_tree_node high_bound
;
5209 /* Even though there wasn't an exact match, there might be an
5210 overlap between this case range and another case range.
5211 Since we've (inductively) not allowed any overlapping case
5212 ranges, we simply need to find the greatest low case label
5213 that is smaller that LOW_VALUE, and the smallest low case
5214 label that is greater than LOW_VALUE. If there is an overlap
5215 it will occur in one of these two ranges. */
5216 low_bound
= splay_tree_predecessor (cases
,
5217 (splay_tree_key
) low_value
);
5218 high_bound
= splay_tree_successor (cases
,
5219 (splay_tree_key
) low_value
);
5221 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5222 the LOW_VALUE, so there is no need to check unless the
5223 LOW_BOUND is in fact itself a case range. */
5225 && CASE_HIGH ((tree
) low_bound
->value
)
5226 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
5229 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5230 range is bigger than the low end of the current range, so we
5231 are only interested if the current range is a real range, and
5232 not an ordinary case label. */
5235 && (tree_int_cst_compare ((tree
) high_bound
->key
,
5240 /* If there was an overlap, issue an error. */
5243 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
5247 error_at (loc
, "duplicate (or overlapping) case value");
5248 error_at (DECL_SOURCE_LOCATION (duplicate
),
5249 "this is the first entry overlapping that value");
5253 error_at (loc
, "duplicate case value") ;
5254 error_at (DECL_SOURCE_LOCATION (duplicate
), "previously used here");
5258 error_at (loc
, "multiple default labels in one switch");
5259 error_at (DECL_SOURCE_LOCATION (duplicate
),
5260 "this is the first default label");
5265 /* Add a CASE_LABEL to the statement-tree. */
5266 case_label
= add_stmt (build_case_label (loc
, low_value
, high_value
, label
));
5267 /* Register this case label in the splay tree. */
5268 splay_tree_insert (cases
,
5269 (splay_tree_key
) low_value
,
5270 (splay_tree_value
) case_label
);
5275 /* Add a label so that the back-end doesn't think that the beginning of
5276 the switch is unreachable. Note that we do not add a case label, as
5277 that just leads to duplicates and thence to failure later on. */
5280 tree t
= create_artificial_label (loc
);
5281 add_stmt (build_stmt (loc
, LABEL_EXPR
, t
));
5283 return error_mark_node
;
5286 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5287 Used to verify that case values match up with enumerator values. */
5290 match_case_to_enum_1 (tree key
, tree type
, tree label
)
5292 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
5294 /* ??? Not working too hard to print the double-word value.
5295 Should perhaps be done with %lwd in the diagnostic routines? */
5296 if (TREE_INT_CST_HIGH (key
) == 0)
5297 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
5298 TREE_INT_CST_LOW (key
));
5299 else if (!TYPE_UNSIGNED (type
)
5300 && TREE_INT_CST_HIGH (key
) == -1
5301 && TREE_INT_CST_LOW (key
) != 0)
5302 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
5303 -TREE_INT_CST_LOW (key
));
5305 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
5306 (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (key
),
5307 (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (key
));
5309 if (TYPE_NAME (type
) == 0)
5310 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
5311 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5312 "case value %qs not in enumerated type",
5315 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
5316 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5317 "case value %qs not in enumerated type %qT",
5321 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5322 Used to verify that case values match up with enumerator values. */
5325 match_case_to_enum (splay_tree_node node
, void *data
)
5327 tree label
= (tree
) node
->value
;
5328 tree type
= (tree
) data
;
5330 /* Skip default case. */
5331 if (!CASE_LOW (label
))
5334 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5335 when we did our enum->case scan. Reset our scratch bit after. */
5336 if (!CASE_LOW_SEEN (label
))
5337 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
5339 CASE_LOW_SEEN (label
) = 0;
5341 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5342 not set, that means that CASE_HIGH did not appear when we did our
5343 enum->case scan. Reset our scratch bit after. */
5344 if (CASE_HIGH (label
))
5346 if (!CASE_HIGH_SEEN (label
))
5347 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
5349 CASE_HIGH_SEEN (label
) = 0;
5355 /* Handle -Wswitch*. Called from the front end after parsing the
5356 switch construct. */
5357 /* ??? Should probably be somewhere generic, since other languages
5358 besides C and C++ would want this. At the moment, however, C/C++
5359 are the only tree-ssa languages that support enumerations at all,
5360 so the point is moot. */
5363 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
5364 tree type
, tree cond
)
5366 splay_tree_node default_node
;
5367 splay_tree_node node
;
5370 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
5373 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
5375 warning_at (switch_location
, OPT_Wswitch_default
,
5376 "switch missing default case");
5378 /* From here on, we only care about about enumerated types. */
5379 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
5382 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
5383 if (!warn_switch_enum
&& !warn_switch
)
5386 /* Check the cases. Warn about case values which are not members of
5387 the enumerated type. For -Wswitch-enum, or for -Wswitch when
5388 there is no default case, check that exactly all enumeration
5389 literals are covered by the cases. */
5391 /* Clearing COND if it is not an integer constant simplifies
5392 the tests inside the loop below. */
5393 if (TREE_CODE (cond
) != INTEGER_CST
)
5396 /* The time complexity here is O(N*lg(N)) worst case, but for the
5397 common case of monotonically increasing enumerators, it is
5398 O(N), since the nature of the splay tree will keep the next
5399 element adjacent to the root at all times. */
5401 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
5403 tree value
= TREE_VALUE (chain
);
5404 if (TREE_CODE (value
) == CONST_DECL
)
5405 value
= DECL_INITIAL (value
);
5406 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
5409 /* Mark the CASE_LOW part of the case entry as seen. */
5410 tree label
= (tree
) node
->value
;
5411 CASE_LOW_SEEN (label
) = 1;
5415 /* Even though there wasn't an exact match, there might be a
5416 case range which includes the enumerator's value. */
5417 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
5418 if (node
&& CASE_HIGH ((tree
) node
->value
))
5420 tree label
= (tree
) node
->value
;
5421 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
5424 /* If we match the upper bound exactly, mark the CASE_HIGH
5425 part of the case entry as seen. */
5427 CASE_HIGH_SEEN (label
) = 1;
5432 /* We've now determined that this enumerated literal isn't
5433 handled by the case labels of the switch statement. */
5435 /* If the switch expression is a constant, we only really care
5436 about whether that constant is handled by the switch. */
5437 if (cond
&& tree_int_cst_compare (cond
, value
))
5440 /* If there is a default_node, the only relevant option is
5441 Wswitch-enum. Otherwise, if both are enabled then we prefer
5442 to warn using -Wswitch because -Wswitch is enabled by -Wall
5443 while -Wswitch-enum is explicit. */
5444 warning_at (switch_location
,
5445 (default_node
|| !warn_switch
5448 "enumeration value %qE not handled in switch",
5449 TREE_PURPOSE (chain
));
5452 /* Warn if there are case expressions that don't correspond to
5453 enumerators. This can occur since C and C++ don't enforce
5454 type-checking of assignments to enumeration variables.
5456 The time complexity here is now always O(N) worst case, since
5457 we should have marked both the lower bound and upper bound of
5458 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5459 above. This scan also resets those fields. */
5461 splay_tree_foreach (cases
, match_case_to_enum
, type
);
5464 /* Finish an expression taking the address of LABEL (an
5465 IDENTIFIER_NODE). Returns an expression for the address.
5467 LOC is the location for the expression returned. */
5470 finish_label_address_expr (tree label
, location_t loc
)
5474 pedwarn (input_location
, OPT_pedantic
, "taking the address of a label is non-standard");
5476 if (label
== error_mark_node
)
5477 return error_mark_node
;
5479 label
= lookup_label (label
);
5480 if (label
== NULL_TREE
)
5481 result
= null_pointer_node
;
5484 TREE_USED (label
) = 1;
5485 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
5486 /* The current function is not necessarily uninlinable.
5487 Computed gotos are incompatible with inlining, but the value
5488 here could be used only in a diagnostic, for example. */
5489 protected_set_expr_location (result
, loc
);
5496 /* Given a boolean expression ARG, return a tree representing an increment
5497 or decrement (as indicated by CODE) of ARG. The front end must check for
5498 invalid cases (e.g., decrement in C++). */
5500 boolean_increment (enum tree_code code
, tree arg
)
5503 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
5505 arg
= stabilize_reference (arg
);
5508 case PREINCREMENT_EXPR
:
5509 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5511 case POSTINCREMENT_EXPR
:
5512 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5513 arg
= save_expr (arg
);
5514 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5515 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5517 case PREDECREMENT_EXPR
:
5518 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5519 invert_truthvalue_loc (input_location
, arg
));
5521 case POSTDECREMENT_EXPR
:
5522 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5523 invert_truthvalue_loc (input_location
, arg
));
5524 arg
= save_expr (arg
);
5525 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5526 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5531 TREE_SIDE_EFFECTS (val
) = 1;
5535 /* Built-in macros for stddef.h and stdint.h, that require macros
5536 defined in this file. */
5538 c_stddef_cpp_builtins(void)
5540 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
5541 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
5542 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
5543 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
5544 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
5545 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
5546 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
5547 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
5548 if (SIG_ATOMIC_TYPE
)
5549 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE
, 0);
5551 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE
, 0);
5553 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE
, 0);
5555 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE
, 0);
5557 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE
, 0);
5559 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE
, 0);
5561 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE
, 0);
5563 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE
, 0);
5565 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE
, 0);
5566 if (INT_LEAST8_TYPE
)
5567 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE
, 0);
5568 if (INT_LEAST16_TYPE
)
5569 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE
, 0);
5570 if (INT_LEAST32_TYPE
)
5571 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE
, 0);
5572 if (INT_LEAST64_TYPE
)
5573 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE
, 0);
5574 if (UINT_LEAST8_TYPE
)
5575 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE
, 0);
5576 if (UINT_LEAST16_TYPE
)
5577 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE
, 0);
5578 if (UINT_LEAST32_TYPE
)
5579 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE
, 0);
5580 if (UINT_LEAST64_TYPE
)
5581 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE
, 0);
5583 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE
, 0);
5584 if (INT_FAST16_TYPE
)
5585 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE
, 0);
5586 if (INT_FAST32_TYPE
)
5587 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE
, 0);
5588 if (INT_FAST64_TYPE
)
5589 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE
, 0);
5590 if (UINT_FAST8_TYPE
)
5591 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE
, 0);
5592 if (UINT_FAST16_TYPE
)
5593 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE
, 0);
5594 if (UINT_FAST32_TYPE
)
5595 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE
, 0);
5596 if (UINT_FAST64_TYPE
)
5597 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE
, 0);
5599 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE
, 0);
5601 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE
, 0);
5605 c_init_attributes (void)
5607 /* Fill in the built_in_attributes array. */
5608 #define DEF_ATTR_NULL_TREE(ENUM) \
5609 built_in_attributes[(int) ENUM] = NULL_TREE;
5610 #define DEF_ATTR_INT(ENUM, VALUE) \
5611 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5612 #define DEF_ATTR_IDENT(ENUM, STRING) \
5613 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5614 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5615 built_in_attributes[(int) ENUM] \
5616 = tree_cons (built_in_attributes[(int) PURPOSE], \
5617 built_in_attributes[(int) VALUE], \
5618 built_in_attributes[(int) CHAIN]);
5619 #include "builtin-attrs.def"
5620 #undef DEF_ATTR_NULL_TREE
5622 #undef DEF_ATTR_IDENT
5623 #undef DEF_ATTR_TREE_LIST
5626 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
5627 identifier as an argument, so the front end shouldn't look it up. */
5630 attribute_takes_identifier_p (const_tree attr_id
)
5632 if (is_attribute_p ("mode", attr_id
)
5633 || is_attribute_p ("format", attr_id
)
5634 || is_attribute_p ("cleanup", attr_id
))
5637 return targetm
.attribute_takes_identifier_p (attr_id
);
5640 /* Attribute handlers common to C front ends. */
5642 /* Handle a "packed" attribute; arguments as in
5643 struct attribute_spec.handler. */
5646 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5647 int flags
, bool *no_add_attrs
)
5651 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5652 *node
= build_variant_type_copy (*node
);
5653 TYPE_PACKED (*node
) = 1;
5655 else if (TREE_CODE (*node
) == FIELD_DECL
)
5657 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
5658 /* Still pack bitfields. */
5659 && ! DECL_INITIAL (*node
))
5660 warning (OPT_Wattributes
,
5661 "%qE attribute ignored for field of type %qT",
5662 name
, TREE_TYPE (*node
));
5664 DECL_PACKED (*node
) = 1;
5666 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5667 used for DECL_REGISTER. It wouldn't mean anything anyway.
5668 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5669 that changes what the typedef is typing. */
5672 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5673 *no_add_attrs
= true;
5679 /* Handle a "nocommon" attribute; arguments as in
5680 struct attribute_spec.handler. */
5683 handle_nocommon_attribute (tree
*node
, tree name
,
5684 tree
ARG_UNUSED (args
),
5685 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5687 if (TREE_CODE (*node
) == VAR_DECL
)
5688 DECL_COMMON (*node
) = 0;
5691 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5692 *no_add_attrs
= true;
5698 /* Handle a "common" attribute; arguments as in
5699 struct attribute_spec.handler. */
5702 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5703 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5705 if (TREE_CODE (*node
) == VAR_DECL
)
5706 DECL_COMMON (*node
) = 1;
5709 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5710 *no_add_attrs
= true;
5716 /* Handle a "noreturn" attribute; arguments as in
5717 struct attribute_spec.handler. */
5720 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5721 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5723 tree type
= TREE_TYPE (*node
);
5725 /* See FIXME comment in c_common_attribute_table. */
5726 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5727 TREE_THIS_VOLATILE (*node
) = 1;
5728 else if (TREE_CODE (type
) == POINTER_TYPE
5729 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5731 = build_pointer_type
5732 (build_type_variant (TREE_TYPE (type
),
5733 TYPE_READONLY (TREE_TYPE (type
)), 1));
5736 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5737 *no_add_attrs
= true;
5743 /* Handle a "hot" and attribute; arguments as in
5744 struct attribute_spec.handler. */
5747 handle_hot_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5748 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5750 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5752 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node
)) != NULL
)
5754 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5756 *no_add_attrs
= true;
5758 /* Most of the rest of the hot processing is done later with
5759 lookup_attribute. */
5763 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5764 *no_add_attrs
= true;
5769 /* Handle a "cold" and attribute; arguments as in
5770 struct attribute_spec.handler. */
5773 handle_cold_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5774 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5776 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5778 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node
)) != NULL
)
5780 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5782 *no_add_attrs
= true;
5784 /* Most of the rest of the cold processing is done later with
5785 lookup_attribute. */
5789 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5790 *no_add_attrs
= true;
5796 /* Handle a "noinline" attribute; arguments as in
5797 struct attribute_spec.handler. */
5800 handle_noinline_attribute (tree
*node
, tree name
,
5801 tree
ARG_UNUSED (args
),
5802 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5804 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5805 DECL_UNINLINABLE (*node
) = 1;
5808 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5809 *no_add_attrs
= true;
5815 /* Handle a "noclone" attribute; arguments as in
5816 struct attribute_spec.handler. */
5819 handle_noclone_attribute (tree
*node
, tree name
,
5820 tree
ARG_UNUSED (args
),
5821 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5823 if (TREE_CODE (*node
) != FUNCTION_DECL
)
5825 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5826 *no_add_attrs
= true;
5832 /* Handle a "always_inline" attribute; arguments as in
5833 struct attribute_spec.handler. */
5836 handle_always_inline_attribute (tree
*node
, tree name
,
5837 tree
ARG_UNUSED (args
),
5838 int ARG_UNUSED (flags
),
5841 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5843 /* Set the attribute and mark it for disregarding inline
5845 DECL_DISREGARD_INLINE_LIMITS (*node
) = 1;
5849 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5850 *no_add_attrs
= true;
5856 /* Handle a "gnu_inline" attribute; arguments as in
5857 struct attribute_spec.handler. */
5860 handle_gnu_inline_attribute (tree
*node
, tree name
,
5861 tree
ARG_UNUSED (args
),
5862 int ARG_UNUSED (flags
),
5865 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
5867 /* Do nothing else, just set the attribute. We'll get at
5868 it later with lookup_attribute. */
5872 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5873 *no_add_attrs
= true;
5879 /* Handle an "artificial" attribute; arguments as in
5880 struct attribute_spec.handler. */
5883 handle_artificial_attribute (tree
*node
, tree name
,
5884 tree
ARG_UNUSED (args
),
5885 int ARG_UNUSED (flags
),
5888 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
5890 /* Do nothing else, just set the attribute. We'll get at
5891 it later with lookup_attribute. */
5895 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5896 *no_add_attrs
= true;
5902 /* Handle a "flatten" attribute; arguments as in
5903 struct attribute_spec.handler. */
5906 handle_flatten_attribute (tree
*node
, tree name
,
5907 tree args ATTRIBUTE_UNUSED
,
5908 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5910 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5911 /* Do nothing else, just set the attribute. We'll get at
5912 it later with lookup_attribute. */
5916 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5917 *no_add_attrs
= true;
5923 /* Handle a "warning" or "error" attribute; arguments as in
5924 struct attribute_spec.handler. */
5927 handle_error_attribute (tree
*node
, tree name
, tree args
,
5928 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5930 if (TREE_CODE (*node
) == FUNCTION_DECL
5931 || TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5932 /* Do nothing else, just set the attribute. We'll get at
5933 it later with lookup_attribute. */
5937 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5938 *no_add_attrs
= true;
5944 /* Handle a "used" attribute; arguments as in
5945 struct attribute_spec.handler. */
5948 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
5949 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5953 if (TREE_CODE (node
) == FUNCTION_DECL
5954 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
5956 TREE_USED (node
) = 1;
5957 DECL_PRESERVE_P (node
) = 1;
5958 if (TREE_CODE (node
) == VAR_DECL
)
5959 DECL_READ_P (node
) = 1;
5963 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5964 *no_add_attrs
= true;
5970 /* Handle a "unused" attribute; arguments as in
5971 struct attribute_spec.handler. */
5974 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5975 int flags
, bool *no_add_attrs
)
5981 if (TREE_CODE (decl
) == PARM_DECL
5982 || TREE_CODE (decl
) == VAR_DECL
5983 || TREE_CODE (decl
) == FUNCTION_DECL
5984 || TREE_CODE (decl
) == LABEL_DECL
5985 || TREE_CODE (decl
) == TYPE_DECL
)
5987 TREE_USED (decl
) = 1;
5988 if (TREE_CODE (decl
) == VAR_DECL
5989 || TREE_CODE (decl
) == PARM_DECL
)
5990 DECL_READ_P (decl
) = 1;
5994 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5995 *no_add_attrs
= true;
6000 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6001 *node
= build_variant_type_copy (*node
);
6002 TREE_USED (*node
) = 1;
6008 /* Handle a "externally_visible" attribute; arguments as in
6009 struct attribute_spec.handler. */
6012 handle_externally_visible_attribute (tree
*pnode
, tree name
,
6013 tree
ARG_UNUSED (args
),
6014 int ARG_UNUSED (flags
),
6019 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
6021 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
6022 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
6024 warning (OPT_Wattributes
,
6025 "%qE attribute have effect only on public objects", name
);
6026 *no_add_attrs
= true;
6031 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6032 *no_add_attrs
= true;
6038 /* Handle a "const" attribute; arguments as in
6039 struct attribute_spec.handler. */
6042 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6043 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6045 tree type
= TREE_TYPE (*node
);
6047 /* See FIXME comment on noreturn in c_common_attribute_table. */
6048 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6049 TREE_READONLY (*node
) = 1;
6050 else if (TREE_CODE (type
) == POINTER_TYPE
6051 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
6053 = build_pointer_type
6054 (build_type_variant (TREE_TYPE (type
), 1,
6055 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
6058 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6059 *no_add_attrs
= true;
6065 /* Handle a "transparent_union" attribute; arguments as in
6066 struct attribute_spec.handler. */
6069 handle_transparent_union_attribute (tree
*node
, tree name
,
6070 tree
ARG_UNUSED (args
), int flags
,
6075 *no_add_attrs
= true;
6077 if (TREE_CODE (*node
) == TYPE_DECL
)
6078 node
= &TREE_TYPE (*node
);
6081 if (TREE_CODE (type
) == UNION_TYPE
)
6083 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6084 the code in finish_struct. */
6085 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6087 if (TYPE_FIELDS (type
) == NULL_TREE
6088 || TYPE_MODE (type
) != DECL_MODE (TYPE_FIELDS (type
)))
6091 /* A type variant isn't good enough, since we don't a cast
6092 to such a type removed as a no-op. */
6093 *node
= type
= build_duplicate_type (type
);
6096 TYPE_TRANSPARENT_AGGR (type
) = 1;
6101 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6105 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6106 get the requested priority for a constructor or destructor,
6107 possibly issuing diagnostics for invalid or reserved
6110 static priority_type
6111 get_priority (tree args
, bool is_destructor
)
6117 return DEFAULT_INIT_PRIORITY
;
6119 if (!SUPPORTS_INIT_PRIORITY
)
6122 error ("destructor priorities are not supported");
6124 error ("constructor priorities are not supported");
6125 return DEFAULT_INIT_PRIORITY
;
6128 arg
= TREE_VALUE (args
);
6129 if (!host_integerp (arg
, /*pos=*/0)
6130 || !INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
6133 pri
= tree_low_cst (TREE_VALUE (args
), /*pos=*/0);
6134 if (pri
< 0 || pri
> MAX_INIT_PRIORITY
)
6137 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
6141 "destructor priorities from 0 to %d are reserved "
6142 "for the implementation",
6143 MAX_RESERVED_INIT_PRIORITY
);
6146 "constructor priorities from 0 to %d are reserved "
6147 "for the implementation",
6148 MAX_RESERVED_INIT_PRIORITY
);
6154 error ("destructor priorities must be integers from 0 to %d inclusive",
6157 error ("constructor priorities must be integers from 0 to %d inclusive",
6159 return DEFAULT_INIT_PRIORITY
;
6162 /* Handle a "constructor" attribute; arguments as in
6163 struct attribute_spec.handler. */
6166 handle_constructor_attribute (tree
*node
, tree name
, tree args
,
6167 int ARG_UNUSED (flags
),
6171 tree type
= TREE_TYPE (decl
);
6173 if (TREE_CODE (decl
) == FUNCTION_DECL
6174 && TREE_CODE (type
) == FUNCTION_TYPE
6175 && decl_function_context (decl
) == 0)
6177 priority_type priority
;
6178 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
6179 priority
= get_priority (args
, /*is_destructor=*/false);
6180 SET_DECL_INIT_PRIORITY (decl
, priority
);
6181 TREE_USED (decl
) = 1;
6185 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6186 *no_add_attrs
= true;
6192 /* Handle a "destructor" attribute; arguments as in
6193 struct attribute_spec.handler. */
6196 handle_destructor_attribute (tree
*node
, tree name
, tree args
,
6197 int ARG_UNUSED (flags
),
6201 tree type
= TREE_TYPE (decl
);
6203 if (TREE_CODE (decl
) == FUNCTION_DECL
6204 && TREE_CODE (type
) == FUNCTION_TYPE
6205 && decl_function_context (decl
) == 0)
6207 priority_type priority
;
6208 DECL_STATIC_DESTRUCTOR (decl
) = 1;
6209 priority
= get_priority (args
, /*is_destructor=*/true);
6210 SET_DECL_FINI_PRIORITY (decl
, priority
);
6211 TREE_USED (decl
) = 1;
6215 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6216 *no_add_attrs
= true;
6222 /* Nonzero if the mode is a valid vector mode for this architecture.
6223 This returns nonzero even if there is no hardware support for the
6224 vector mode, but we can emulate with narrower modes. */
6227 vector_mode_valid_p (enum machine_mode mode
)
6229 enum mode_class mclass
= GET_MODE_CLASS (mode
);
6230 enum machine_mode innermode
;
6232 /* Doh! What's going on? */
6233 if (mclass
!= MODE_VECTOR_INT
6234 && mclass
!= MODE_VECTOR_FLOAT
6235 && mclass
!= MODE_VECTOR_FRACT
6236 && mclass
!= MODE_VECTOR_UFRACT
6237 && mclass
!= MODE_VECTOR_ACCUM
6238 && mclass
!= MODE_VECTOR_UACCUM
)
6241 /* Hardware support. Woo hoo! */
6242 if (targetm
.vector_mode_supported_p (mode
))
6245 innermode
= GET_MODE_INNER (mode
);
6247 /* We should probably return 1 if requesting V4DI and we have no DI,
6248 but we have V2DI, but this is probably very unlikely. */
6250 /* If we have support for the inner mode, we can safely emulate it.
6251 We may not have V2DI, but me can emulate with a pair of DIs. */
6252 return targetm
.scalar_mode_supported_p (innermode
);
6256 /* Handle a "mode" attribute; arguments as in
6257 struct attribute_spec.handler. */
6260 handle_mode_attribute (tree
*node
, tree name
, tree args
,
6261 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6264 tree ident
= TREE_VALUE (args
);
6266 *no_add_attrs
= true;
6268 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
6269 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6273 const char *p
= IDENTIFIER_POINTER (ident
);
6274 int len
= strlen (p
);
6275 enum machine_mode mode
= VOIDmode
;
6279 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
6280 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
6282 char *newp
= (char *) alloca (len
- 1);
6284 strcpy (newp
, &p
[2]);
6285 newp
[len
- 4] = '\0';
6289 /* Change this type to have a type with the specified mode.
6290 First check for the special modes. */
6291 if (!strcmp (p
, "byte"))
6293 else if (!strcmp (p
, "word"))
6295 else if (!strcmp (p
, "pointer"))
6297 else if (!strcmp (p
, "libgcc_cmp_return"))
6298 mode
= targetm
.libgcc_cmp_return_mode ();
6299 else if (!strcmp (p
, "libgcc_shift_count"))
6300 mode
= targetm
.libgcc_shift_count_mode ();
6301 else if (!strcmp (p
, "unwind_word"))
6302 mode
= targetm
.unwind_word_mode ();
6304 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
6305 if (!strcmp (p
, GET_MODE_NAME (j
)))
6307 mode
= (enum machine_mode
) j
;
6311 if (mode
== VOIDmode
)
6313 error ("unknown machine mode %qE", ident
);
6318 switch (GET_MODE_CLASS (mode
))
6321 case MODE_PARTIAL_INT
:
6323 case MODE_DECIMAL_FLOAT
:
6328 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
6331 case MODE_COMPLEX_INT
:
6332 case MODE_COMPLEX_FLOAT
:
6333 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
6336 case MODE_VECTOR_INT
:
6337 case MODE_VECTOR_FLOAT
:
6338 case MODE_VECTOR_FRACT
:
6339 case MODE_VECTOR_UFRACT
:
6340 case MODE_VECTOR_ACCUM
:
6341 case MODE_VECTOR_UACCUM
:
6342 warning (OPT_Wattributes
, "specifying vector types with "
6343 "__attribute__ ((mode)) is deprecated");
6344 warning (OPT_Wattributes
,
6345 "use __attribute__ ((vector_size)) instead");
6346 valid_mode
= vector_mode_valid_p (mode
);
6354 error ("unable to emulate %qs", p
);
6358 if (POINTER_TYPE_P (type
))
6360 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
6361 tree (*fn
)(tree
, enum machine_mode
, bool);
6363 if (!targetm
.addr_space
.valid_pointer_mode (mode
, as
))
6365 error ("invalid pointer mode %qs", p
);
6369 if (TREE_CODE (type
) == POINTER_TYPE
)
6370 fn
= build_pointer_type_for_mode
;
6372 fn
= build_reference_type_for_mode
;
6373 typefm
= fn (TREE_TYPE (type
), mode
, false);
6377 /* For fixed-point modes, we need to test if the signness of type
6378 and the machine mode are consistent. */
6379 if (ALL_FIXED_POINT_MODE_P (mode
)
6380 && TYPE_UNSIGNED (type
) != UNSIGNED_FIXED_POINT_MODE_P (mode
))
6382 error ("signness of type and machine mode %qs don't match", p
);
6385 /* For fixed-point modes, we need to pass saturating info. */
6386 typefm
= lang_hooks
.types
.type_for_mode (mode
,
6387 ALL_FIXED_POINT_MODE_P (mode
) ? TYPE_SATURATING (type
)
6388 : TYPE_UNSIGNED (type
));
6391 if (typefm
== NULL_TREE
)
6393 error ("no data type for mode %qs", p
);
6396 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
6398 /* For enumeral types, copy the precision from the integer
6399 type returned above. If not an INTEGER_TYPE, we can't use
6400 this mode for this type. */
6401 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
6403 error ("cannot use mode %qs for enumeral types", p
);
6407 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
6409 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
6414 /* We cannot build a type variant, as there's code that assumes
6415 that TYPE_MAIN_VARIANT has the same mode. This includes the
6416 debug generators. Instead, create a subrange type. This
6417 results in all of the enumeral values being emitted only once
6418 in the original, and the subtype gets them by reference. */
6419 if (TYPE_UNSIGNED (type
))
6420 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
6422 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
6423 TREE_TYPE (typefm
) = type
;
6426 else if (VECTOR_MODE_P (mode
)
6427 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
6428 : TREE_CODE (type
) != TREE_CODE (typefm
))
6430 error ("mode %qs applied to inappropriate type", p
);
6440 /* Handle a "section" attribute; arguments as in
6441 struct attribute_spec.handler. */
6444 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6445 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6449 if (targetm
.have_named_sections
)
6451 user_defined_section_attribute
= true;
6453 if ((TREE_CODE (decl
) == FUNCTION_DECL
6454 || TREE_CODE (decl
) == VAR_DECL
)
6455 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
6457 if (TREE_CODE (decl
) == VAR_DECL
6458 && current_function_decl
!= NULL_TREE
6459 && !TREE_STATIC (decl
))
6461 error_at (DECL_SOURCE_LOCATION (decl
),
6462 "section attribute cannot be specified for "
6464 *no_add_attrs
= true;
6467 /* The decl may have already been given a section attribute
6468 from a previous declaration. Ensure they match. */
6469 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
6470 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
6471 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
6473 error ("section of %q+D conflicts with previous declaration",
6475 *no_add_attrs
= true;
6477 else if (TREE_CODE (decl
) == VAR_DECL
6478 && !targetm
.have_tls
&& targetm
.emutls
.tmpl_section
6479 && DECL_THREAD_LOCAL_P (decl
))
6481 error ("section of %q+D cannot be overridden", *node
);
6482 *no_add_attrs
= true;
6485 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
6489 error ("section attribute not allowed for %q+D", *node
);
6490 *no_add_attrs
= true;
6495 error_at (DECL_SOURCE_LOCATION (*node
),
6496 "section attributes are not supported for this target");
6497 *no_add_attrs
= true;
6503 /* Handle a "aligned" attribute; arguments as in
6504 struct attribute_spec.handler. */
6507 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6508 int flags
, bool *no_add_attrs
)
6510 tree decl
= NULL_TREE
;
6513 tree align_expr
= (args
? TREE_VALUE (args
)
6514 : size_int (ATTRIBUTE_ALIGNED_VALUE
/ BITS_PER_UNIT
));
6520 type
= &TREE_TYPE (decl
);
6521 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
6523 else if (TYPE_P (*node
))
6524 type
= node
, is_type
= 1;
6526 if (TREE_CODE (align_expr
) != INTEGER_CST
)
6528 error ("requested alignment is not a constant");
6529 *no_add_attrs
= true;
6531 else if ((i
= tree_log2 (align_expr
)) == -1)
6533 error ("requested alignment is not a power of 2");
6534 *no_add_attrs
= true;
6536 else if (i
>= HOST_BITS_PER_INT
- BITS_PER_UNIT_LOG
)
6538 error ("requested alignment is too large");
6539 *no_add_attrs
= true;
6543 if ((flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6544 /* OK, modify the type in place. */;
6545 /* If we have a TYPE_DECL, then copy the type, so that we
6546 don't accidentally modify a builtin type. See pushdecl. */
6547 else if (decl
&& TREE_TYPE (decl
) != error_mark_node
6548 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
6550 tree tt
= TREE_TYPE (decl
);
6551 *type
= build_variant_type_copy (*type
);
6552 DECL_ORIGINAL_TYPE (decl
) = tt
;
6553 TYPE_NAME (*type
) = decl
;
6554 TREE_USED (*type
) = TREE_USED (decl
);
6555 TREE_TYPE (decl
) = *type
;
6558 *type
= build_variant_type_copy (*type
);
6560 TYPE_ALIGN (*type
) = (1U << i
) * BITS_PER_UNIT
;
6561 TYPE_USER_ALIGN (*type
) = 1;
6563 else if (! VAR_OR_FUNCTION_DECL_P (decl
)
6564 && TREE_CODE (decl
) != FIELD_DECL
)
6566 error ("alignment may not be specified for %q+D", decl
);
6567 *no_add_attrs
= true;
6569 else if (TREE_CODE (decl
) == FUNCTION_DECL
6570 && DECL_ALIGN (decl
) > (1U << i
) * BITS_PER_UNIT
)
6572 if (DECL_USER_ALIGN (decl
))
6573 error ("alignment for %q+D was previously specified as %d "
6574 "and may not be decreased", decl
,
6575 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6577 error ("alignment for %q+D must be at least %d", decl
,
6578 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6579 *no_add_attrs
= true;
6583 DECL_ALIGN (decl
) = (1U << i
) * BITS_PER_UNIT
;
6584 DECL_USER_ALIGN (decl
) = 1;
6590 /* Handle a "weak" attribute; arguments as in
6591 struct attribute_spec.handler. */
6594 handle_weak_attribute (tree
*node
, tree name
,
6595 tree
ARG_UNUSED (args
),
6596 int ARG_UNUSED (flags
),
6597 bool * ARG_UNUSED (no_add_attrs
))
6599 if (TREE_CODE (*node
) == FUNCTION_DECL
6600 && DECL_DECLARED_INLINE_P (*node
))
6602 error ("inline function %q+D cannot be declared weak", *node
);
6603 *no_add_attrs
= true;
6605 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node
)))
6607 error ("indirect function %q+D cannot be declared weak", *node
);
6608 *no_add_attrs
= true;
6611 else if (TREE_CODE (*node
) == FUNCTION_DECL
6612 || TREE_CODE (*node
) == VAR_DECL
)
6613 declare_weak (*node
);
6615 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6620 /* Handle an "alias" or "ifunc" attribute; arguments as in
6621 struct attribute_spec.handler, except that IS_ALIAS tells us
6622 whether this is an alias as opposed to ifunc attribute. */
6625 handle_alias_ifunc_attribute (bool is_alias
, tree
*node
, tree name
, tree args
,
6630 if (TREE_CODE (decl
) != FUNCTION_DECL
6631 && (!is_alias
|| TREE_CODE (decl
) != VAR_DECL
))
6633 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6634 *no_add_attrs
= true;
6636 else if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
6637 || (TREE_CODE (decl
) != FUNCTION_DECL
6638 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
6639 /* A static variable declaration is always a tentative definition,
6640 but the alias is a non-tentative definition which overrides. */
6641 || (TREE_CODE (decl
) != FUNCTION_DECL
6642 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
6644 error ("%q+D defined both normally and as %qE attribute", decl
, name
);
6645 *no_add_attrs
= true;
6649 && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl
))
6650 || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
))))
6652 error ("weak %q+D cannot be defined %qE", decl
, name
);
6653 *no_add_attrs
= true;
6657 /* Note that the very first time we process a nested declaration,
6658 decl_function_context will not be set. Indeed, *would* never
6659 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6660 we do below. After such frobbery, pushdecl would set the context.
6661 In any case, this is never what we want. */
6662 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
6666 id
= TREE_VALUE (args
);
6667 if (TREE_CODE (id
) != STRING_CST
)
6669 error ("attribute %qE argument not a string", name
);
6670 *no_add_attrs
= true;
6673 id
= get_identifier (TREE_STRING_POINTER (id
));
6674 /* This counts as a use of the object pointed to. */
6677 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6678 DECL_INITIAL (decl
) = error_mark_node
;
6681 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
6682 DECL_EXTERNAL (decl
) = 1;
6684 DECL_EXTERNAL (decl
) = 0;
6685 TREE_STATIC (decl
) = 1;
6689 /* ifuncs are also aliases, so set that attribute too. */
6690 DECL_ATTRIBUTES (decl
)
6691 = tree_cons (get_identifier ("alias"), args
, DECL_ATTRIBUTES (decl
));
6695 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6696 *no_add_attrs
= true;
6702 /* Handle an "alias" or "ifunc" attribute; arguments as in
6703 struct attribute_spec.handler. */
6706 handle_ifunc_attribute (tree
*node
, tree name
, tree args
,
6707 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6709 return handle_alias_ifunc_attribute (false, node
, name
, args
, no_add_attrs
);
6712 /* Handle an "alias" or "ifunc" attribute; arguments as in
6713 struct attribute_spec.handler. */
6716 handle_alias_attribute (tree
*node
, tree name
, tree args
,
6717 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6719 return handle_alias_ifunc_attribute (true, node
, name
, args
, no_add_attrs
);
6722 /* Handle a "weakref" attribute; arguments as in struct
6723 attribute_spec.handler. */
6726 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6727 int flags
, bool *no_add_attrs
)
6729 tree attr
= NULL_TREE
;
6731 /* We must ignore the attribute when it is associated with
6732 local-scoped decls, since attribute alias is ignored and many
6733 such symbols do not even have a DECL_WEAK field. */
6734 if (decl_function_context (*node
)
6735 || current_function_decl
6736 || (TREE_CODE (*node
) != VAR_DECL
&& TREE_CODE (*node
) != FUNCTION_DECL
))
6738 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6739 *no_add_attrs
= true;
6743 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node
)))
6745 error ("indirect function %q+D cannot be declared weakref", *node
);
6746 *no_add_attrs
= true;
6750 /* The idea here is that `weakref("name")' mutates into `weakref,
6751 alias("name")', and weakref without arguments, in turn,
6752 implicitly adds weak. */
6756 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
6757 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
6759 *no_add_attrs
= true;
6761 decl_attributes (node
, attr
, flags
);
6765 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
6766 error_at (DECL_SOURCE_LOCATION (*node
),
6767 "weakref attribute must appear before alias attribute");
6769 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6770 and that isn't supported; and because it wants to add it to
6771 the list of weak decls, which isn't helpful. */
6772 DECL_WEAK (*node
) = 1;
6778 /* Handle an "visibility" attribute; arguments as in
6779 struct attribute_spec.handler. */
6782 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
6783 int ARG_UNUSED (flags
),
6784 bool *ARG_UNUSED (no_add_attrs
))
6787 tree id
= TREE_VALUE (args
);
6788 enum symbol_visibility vis
;
6792 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
6794 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
6796 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
6800 else if (TYPE_FIELDS (*node
))
6802 error ("%qE attribute ignored because %qT is already defined",
6807 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
6809 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6813 if (TREE_CODE (id
) != STRING_CST
)
6815 error ("visibility argument not a string");
6819 /* If this is a type, set the visibility on the type decl. */
6822 decl
= TYPE_NAME (decl
);
6825 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6827 warning (OPT_Wattributes
, "%qE attribute ignored on types",
6833 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
6834 vis
= VISIBILITY_DEFAULT
;
6835 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
6836 vis
= VISIBILITY_INTERNAL
;
6837 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
6838 vis
= VISIBILITY_HIDDEN
;
6839 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
6840 vis
= VISIBILITY_PROTECTED
;
6843 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6844 vis
= VISIBILITY_DEFAULT
;
6847 if (DECL_VISIBILITY_SPECIFIED (decl
)
6848 && vis
!= DECL_VISIBILITY (decl
))
6850 tree attributes
= (TYPE_P (*node
)
6851 ? TYPE_ATTRIBUTES (*node
)
6852 : DECL_ATTRIBUTES (decl
));
6853 if (lookup_attribute ("visibility", attributes
))
6854 error ("%qD redeclared with different visibility", decl
);
6855 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6856 && lookup_attribute ("dllimport", attributes
))
6857 error ("%qD was declared %qs which implies default visibility",
6859 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6860 && lookup_attribute ("dllexport", attributes
))
6861 error ("%qD was declared %qs which implies default visibility",
6865 DECL_VISIBILITY (decl
) = vis
;
6866 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
6868 /* Go ahead and attach the attribute to the node as well. This is needed
6869 so we can determine whether we have VISIBILITY_DEFAULT because the
6870 visibility was not specified, or because it was explicitly overridden
6871 from the containing scope. */
6876 /* Determine the ELF symbol visibility for DECL, which is either a
6877 variable or a function. It is an error to use this function if a
6878 definition of DECL is not available in this translation unit.
6879 Returns true if the final visibility has been determined by this
6880 function; false if the caller is free to make additional
6884 c_determine_visibility (tree decl
)
6886 gcc_assert (TREE_CODE (decl
) == VAR_DECL
6887 || TREE_CODE (decl
) == FUNCTION_DECL
);
6889 /* If the user explicitly specified the visibility with an
6890 attribute, honor that. DECL_VISIBILITY will have been set during
6891 the processing of the attribute. We check for an explicit
6892 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6893 to distinguish the use of an attribute from the use of a "#pragma
6894 GCC visibility push(...)"; in the latter case we still want other
6895 considerations to be able to overrule the #pragma. */
6896 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
6897 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6898 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
6899 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
6902 /* Set default visibility to whatever the user supplied with
6903 visibility_specified depending on #pragma GCC visibility. */
6904 if (!DECL_VISIBILITY_SPECIFIED (decl
))
6906 if (visibility_options
.inpragma
6907 || DECL_VISIBILITY (decl
) != default_visibility
)
6909 DECL_VISIBILITY (decl
) = default_visibility
;
6910 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
6911 /* If visibility changed and DECL already has DECL_RTL, ensure
6912 symbol flags are updated. */
6913 if (((TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
6914 || TREE_CODE (decl
) == FUNCTION_DECL
)
6915 && DECL_RTL_SET_P (decl
))
6916 make_decl_rtl (decl
);
6922 /* Handle an "tls_model" attribute; arguments as in
6923 struct attribute_spec.handler. */
6926 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
6927 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6931 enum tls_model kind
;
6933 *no_add_attrs
= true;
6935 if (TREE_CODE (decl
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (decl
))
6937 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6941 kind
= DECL_TLS_MODEL (decl
);
6942 id
= TREE_VALUE (args
);
6943 if (TREE_CODE (id
) != STRING_CST
)
6945 error ("tls_model argument not a string");
6949 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
6950 kind
= TLS_MODEL_LOCAL_EXEC
;
6951 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
6952 kind
= TLS_MODEL_INITIAL_EXEC
;
6953 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
6954 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
6955 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
6956 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
6958 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6960 DECL_TLS_MODEL (decl
) = kind
;
6964 /* Handle a "no_instrument_function" attribute; arguments as in
6965 struct attribute_spec.handler. */
6968 handle_no_instrument_function_attribute (tree
*node
, tree name
,
6969 tree
ARG_UNUSED (args
),
6970 int ARG_UNUSED (flags
),
6975 if (TREE_CODE (decl
) != FUNCTION_DECL
)
6977 error_at (DECL_SOURCE_LOCATION (decl
),
6978 "%qE attribute applies only to functions", name
);
6979 *no_add_attrs
= true;
6981 else if (DECL_INITIAL (decl
))
6983 error_at (DECL_SOURCE_LOCATION (decl
),
6984 "can%'t set %qE attribute after definition", name
);
6985 *no_add_attrs
= true;
6988 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
6993 /* Handle a "malloc" attribute; arguments as in
6994 struct attribute_spec.handler. */
6997 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6998 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7000 if (TREE_CODE (*node
) == FUNCTION_DECL
7001 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
7002 DECL_IS_MALLOC (*node
) = 1;
7005 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7006 *no_add_attrs
= true;
7012 /* Handle a "alloc_size" attribute; arguments as in
7013 struct attribute_spec.handler. */
7016 handle_alloc_size_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
7017 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7019 unsigned arg_count
= type_num_arguments (*node
);
7020 for (; args
; args
= TREE_CHAIN (args
))
7022 tree position
= TREE_VALUE (args
);
7024 if (TREE_CODE (position
) != INTEGER_CST
7025 || TREE_INT_CST_HIGH (position
)
7026 || TREE_INT_CST_LOW (position
) < 1
7027 || TREE_INT_CST_LOW (position
) > arg_count
)
7029 warning (OPT_Wattributes
,
7030 "alloc_size parameter outside range");
7031 *no_add_attrs
= true;
7038 /* Handle a "fn spec" attribute; arguments as in
7039 struct attribute_spec.handler. */
7042 handle_fnspec_attribute (tree
*node ATTRIBUTE_UNUSED
, tree
ARG_UNUSED (name
),
7043 tree args
, int ARG_UNUSED (flags
),
7044 bool *no_add_attrs ATTRIBUTE_UNUSED
)
7047 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
7048 && !TREE_CHAIN (args
));
7052 /* Handle a "returns_twice" attribute; arguments as in
7053 struct attribute_spec.handler. */
7056 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7057 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7059 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7060 DECL_IS_RETURNS_TWICE (*node
) = 1;
7063 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7064 *no_add_attrs
= true;
7070 /* Handle a "no_limit_stack" attribute; arguments as in
7071 struct attribute_spec.handler. */
7074 handle_no_limit_stack_attribute (tree
*node
, tree name
,
7075 tree
ARG_UNUSED (args
),
7076 int ARG_UNUSED (flags
),
7081 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7083 error_at (DECL_SOURCE_LOCATION (decl
),
7084 "%qE attribute applies only to functions", name
);
7085 *no_add_attrs
= true;
7087 else if (DECL_INITIAL (decl
))
7089 error_at (DECL_SOURCE_LOCATION (decl
),
7090 "can%'t set %qE attribute after definition", name
);
7091 *no_add_attrs
= true;
7094 DECL_NO_LIMIT_STACK (decl
) = 1;
7099 /* Handle a "pure" attribute; arguments as in
7100 struct attribute_spec.handler. */
7103 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7104 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7106 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7107 DECL_PURE_P (*node
) = 1;
7108 /* ??? TODO: Support types. */
7111 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7112 *no_add_attrs
= true;
7118 /* Handle a "no vops" attribute; arguments as in
7119 struct attribute_spec.handler. */
7122 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7123 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
7124 bool *ARG_UNUSED (no_add_attrs
))
7126 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
7127 DECL_IS_NOVOPS (*node
) = 1;
7131 /* Handle a "deprecated" attribute; arguments as in
7132 struct attribute_spec.handler. */
7135 handle_deprecated_attribute (tree
*node
, tree name
,
7136 tree args
, int flags
,
7139 tree type
= NULL_TREE
;
7141 tree what
= NULL_TREE
;
7144 *no_add_attrs
= true;
7145 else if (TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
7147 error ("deprecated message is not a string");
7148 *no_add_attrs
= true;
7154 type
= TREE_TYPE (decl
);
7156 if (TREE_CODE (decl
) == TYPE_DECL
7157 || TREE_CODE (decl
) == PARM_DECL
7158 || TREE_CODE (decl
) == VAR_DECL
7159 || TREE_CODE (decl
) == FUNCTION_DECL
7160 || TREE_CODE (decl
) == FIELD_DECL
)
7161 TREE_DEPRECATED (decl
) = 1;
7165 else if (TYPE_P (*node
))
7167 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
7168 *node
= build_variant_type_copy (*node
);
7169 TREE_DEPRECATED (*node
) = 1;
7177 *no_add_attrs
= true;
7178 if (type
&& TYPE_NAME (type
))
7180 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
7181 what
= TYPE_NAME (*node
);
7182 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
7183 && DECL_NAME (TYPE_NAME (type
)))
7184 what
= DECL_NAME (TYPE_NAME (type
));
7187 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
7189 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7195 /* Handle a "vector_size" attribute; arguments as in
7196 struct attribute_spec.handler. */
7199 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
7200 int ARG_UNUSED (flags
),
7203 unsigned HOST_WIDE_INT vecsize
, nunits
;
7204 enum machine_mode orig_mode
;
7205 tree type
= *node
, new_type
, size
;
7207 *no_add_attrs
= true;
7209 size
= TREE_VALUE (args
);
7211 if (!host_integerp (size
, 1))
7213 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7217 /* Get the vector size (in bytes). */
7218 vecsize
= tree_low_cst (size
, 1);
7220 /* We need to provide for vector pointers, vector arrays, and
7221 functions returning vectors. For example:
7223 __attribute__((vector_size(16))) short *foo;
7225 In this case, the mode is SI, but the type being modified is
7226 HI, so we need to look further. */
7228 while (POINTER_TYPE_P (type
)
7229 || TREE_CODE (type
) == FUNCTION_TYPE
7230 || TREE_CODE (type
) == METHOD_TYPE
7231 || TREE_CODE (type
) == ARRAY_TYPE
7232 || TREE_CODE (type
) == OFFSET_TYPE
)
7233 type
= TREE_TYPE (type
);
7235 /* Get the mode of the type being modified. */
7236 orig_mode
= TYPE_MODE (type
);
7238 if ((!INTEGRAL_TYPE_P (type
)
7239 && !SCALAR_FLOAT_TYPE_P (type
)
7240 && !FIXED_POINT_TYPE_P (type
))
7241 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
7242 && GET_MODE_CLASS (orig_mode
) != MODE_INT
7243 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode
))
7244 || !host_integerp (TYPE_SIZE_UNIT (type
), 1)
7245 || TREE_CODE (type
) == BOOLEAN_TYPE
)
7247 error ("invalid vector type for attribute %qE", name
);
7251 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
7253 error ("vector size not an integral multiple of component size");
7259 error ("zero vector size");
7263 /* Calculate how many units fit in the vector. */
7264 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
7265 if (nunits
& (nunits
- 1))
7267 error ("number of components of the vector not a power of two");
7271 new_type
= build_vector_type (type
, nunits
);
7273 /* Build back pointers if needed. */
7274 *node
= lang_hooks
.types
.reconstruct_complex_type (*node
, new_type
);
7279 /* Handle the "nonnull" attribute. */
7281 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7282 tree args
, int ARG_UNUSED (flags
),
7286 unsigned HOST_WIDE_INT attr_arg_num
;
7288 /* If no arguments are specified, all pointer arguments should be
7289 non-null. Verify a full prototype is given so that the arguments
7290 will have the correct types when we actually check them later. */
7293 if (!TYPE_ARG_TYPES (type
))
7295 error ("nonnull attribute without arguments on a non-prototype");
7296 *no_add_attrs
= true;
7301 /* Argument list specified. Verify that each argument number references
7302 a pointer argument. */
7303 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
7306 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
7308 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
7310 error ("nonnull argument has invalid operand number (argument %lu)",
7311 (unsigned long) attr_arg_num
);
7312 *no_add_attrs
= true;
7316 argument
= TYPE_ARG_TYPES (type
);
7319 for (ck_num
= 1; ; ck_num
++)
7321 if (!argument
|| ck_num
== arg_num
)
7323 argument
= TREE_CHAIN (argument
);
7327 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
7329 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7330 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7331 *no_add_attrs
= true;
7335 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
7337 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7338 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7339 *no_add_attrs
= true;
7348 /* Check the argument list of a function call for null in argument slots
7349 that are marked as requiring a non-null pointer argument. The NARGS
7350 arguments are passed in the array ARGARRAY.
7354 check_function_nonnull (tree attrs
, int nargs
, tree
*argarray
)
7359 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
7361 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
7363 args
= TREE_VALUE (a
);
7365 /* Walk the argument list. If we encounter an argument number we
7366 should check for non-null, do it. If the attribute has no args,
7367 then every pointer argument is checked (in which case the check
7368 for pointer type is done in check_nonnull_arg). */
7369 for (i
= 0; i
< nargs
; i
++)
7371 if (!args
|| nonnull_check_p (args
, i
+ 1))
7372 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
7380 /* Check that the Nth argument of a function call (counting backwards
7381 from the end) is a (pointer)0. The NARGS arguments are passed in the
7385 check_function_sentinel (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7387 tree attr
= lookup_attribute ("sentinel", attrs
);
7395 /* Skip over the named arguments. */
7396 while (typelist
&& len
< nargs
)
7398 typelist
= TREE_CHAIN (typelist
);
7402 if (TREE_VALUE (attr
))
7404 tree p
= TREE_VALUE (TREE_VALUE (attr
));
7405 pos
= TREE_INT_CST_LOW (p
);
7408 /* The sentinel must be one of the varargs, i.e.
7409 in position >= the number of fixed arguments. */
7410 if ((nargs
- 1 - pos
) < len
)
7412 warning (OPT_Wformat
,
7413 "not enough variable arguments to fit a sentinel");
7417 /* Validate the sentinel. */
7418 sentinel
= argarray
[nargs
- 1 - pos
];
7419 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
7420 || !integer_zerop (sentinel
))
7421 /* Although __null (in C++) is only an integer we allow it
7422 nevertheless, as we are guaranteed that it's exactly
7423 as wide as a pointer, and we don't want to force
7424 users to cast the NULL they have written there.
7425 We warn with -Wstrict-null-sentinel, though. */
7426 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
7427 warning (OPT_Wformat
, "missing sentinel in function call");
7431 /* Helper for check_function_nonnull; given a list of operands which
7432 must be non-null in ARGS, determine if operand PARAM_NUM should be
7436 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
7438 unsigned HOST_WIDE_INT arg_num
= 0;
7440 for (; args
; args
= TREE_CHAIN (args
))
7442 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
7446 if (arg_num
== param_num
)
7452 /* Check that the function argument PARAM (which is operand number
7453 PARAM_NUM) is non-null. This is called by check_function_nonnull
7454 via check_function_arguments_recurse. */
7457 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
7458 unsigned HOST_WIDE_INT param_num
)
7460 /* Just skip checking the argument if it's not a pointer. This can
7461 happen if the "nonnull" attribute was given without an operand
7462 list (which means to check every pointer argument). */
7464 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
7467 if (integer_zerop (param
))
7468 warning (OPT_Wnonnull
, "null argument where non-null required "
7469 "(argument %lu)", (unsigned long) param_num
);
7472 /* Helper for nonnull attribute handling; fetch the operand number
7473 from the attribute argument list. */
7476 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
7478 /* Verify the arg number is a constant. */
7479 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
7480 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
7483 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
7487 /* Handle a "nothrow" attribute; arguments as in
7488 struct attribute_spec.handler. */
7491 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7492 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7494 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7495 TREE_NOTHROW (*node
) = 1;
7496 /* ??? TODO: Support types. */
7499 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7500 *no_add_attrs
= true;
7506 /* Handle a "cleanup" attribute; arguments as in
7507 struct attribute_spec.handler. */
7510 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
7511 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7514 tree cleanup_id
, cleanup_decl
;
7516 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7517 for global destructors in C++. This requires infrastructure that
7518 we don't have generically at the moment. It's also not a feature
7519 we'd be missing too much, since we do have attribute constructor. */
7520 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
7522 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7523 *no_add_attrs
= true;
7527 /* Verify that the argument is a function in scope. */
7528 /* ??? We could support pointers to functions here as well, if
7529 that was considered desirable. */
7530 cleanup_id
= TREE_VALUE (args
);
7531 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
7533 error ("cleanup argument not an identifier");
7534 *no_add_attrs
= true;
7537 cleanup_decl
= lookup_name (cleanup_id
);
7538 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
7540 error ("cleanup argument not a function");
7541 *no_add_attrs
= true;
7545 /* That the function has proper type is checked with the
7546 eventual call to build_function_call. */
7551 /* Handle a "warn_unused_result" attribute. No special handling. */
7554 handle_warn_unused_result_attribute (tree
*node
, tree name
,
7555 tree
ARG_UNUSED (args
),
7556 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7558 /* Ignore the attribute for functions not returning any value. */
7559 if (VOID_TYPE_P (TREE_TYPE (*node
)))
7561 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7562 *no_add_attrs
= true;
7568 /* Handle a "sentinel" attribute. */
7571 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
7572 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7574 tree params
= TYPE_ARG_TYPES (*node
);
7578 warning (OPT_Wattributes
,
7579 "%qE attribute requires prototypes with named arguments", name
);
7580 *no_add_attrs
= true;
7584 while (TREE_CHAIN (params
))
7585 params
= TREE_CHAIN (params
);
7587 if (VOID_TYPE_P (TREE_VALUE (params
)))
7589 warning (OPT_Wattributes
,
7590 "%qE attribute only applies to variadic functions", name
);
7591 *no_add_attrs
= true;
7597 tree position
= TREE_VALUE (args
);
7599 if (TREE_CODE (position
) != INTEGER_CST
)
7601 warning (OPT_Wattributes
,
7602 "requested position is not an integer constant");
7603 *no_add_attrs
= true;
7607 if (tree_int_cst_lt (position
, integer_zero_node
))
7609 warning (OPT_Wattributes
,
7610 "requested position is less than zero");
7611 *no_add_attrs
= true;
7619 /* Handle a "type_generic" attribute. */
7622 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7623 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
7624 bool * ARG_UNUSED (no_add_attrs
))
7628 /* Ensure we have a function type. */
7629 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
7631 params
= TYPE_ARG_TYPES (*node
);
7632 while (params
&& ! VOID_TYPE_P (TREE_VALUE (params
)))
7633 params
= TREE_CHAIN (params
);
7635 /* Ensure we have a variadic function. */
7636 gcc_assert (!params
);
7641 /* Handle a "target" attribute. */
7644 handle_target_attribute (tree
*node
, tree name
, tree args
, int flags
,
7647 /* Ensure we have a function type. */
7648 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7650 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7651 *no_add_attrs
= true;
7653 else if (! targetm
.target_option
.valid_attribute_p (*node
, name
, args
,
7655 *no_add_attrs
= true;
7660 /* Arguments being collected for optimization. */
7661 typedef const char *const_char_p
; /* For DEF_VEC_P. */
7662 DEF_VEC_P(const_char_p
);
7663 DEF_VEC_ALLOC_P(const_char_p
, gc
);
7664 static GTY(()) VEC(const_char_p
, gc
) *optimize_args
;
7667 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7668 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7669 false for #pragma GCC optimize. */
7672 parse_optimize_options (tree args
, bool attr_p
)
7677 int saved_flag_strict_aliasing
;
7678 const char **opt_argv
;
7679 struct cl_decoded_option
*decoded_options
;
7680 unsigned int decoded_options_count
;
7683 /* Build up argv vector. Just in case the string is stored away, use garbage
7684 collected strings. */
7685 VEC_truncate (const_char_p
, optimize_args
, 0);
7686 VEC_safe_push (const_char_p
, gc
, optimize_args
, NULL
);
7688 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
7690 tree value
= TREE_VALUE (ap
);
7692 if (TREE_CODE (value
) == INTEGER_CST
)
7695 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
7696 VEC_safe_push (const_char_p
, gc
, optimize_args
, ggc_strdup (buffer
));
7699 else if (TREE_CODE (value
) == STRING_CST
)
7701 /* Split string into multiple substrings. */
7702 size_t len
= TREE_STRING_LENGTH (value
);
7703 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
7704 char *end
= p
+ len
;
7708 while (next_p
!= NULL
)
7714 comma
= strchr (p
, ',');
7727 r
= q
= (char *) ggc_alloc_atomic (len2
+ 3);
7729 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7731 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
7735 warning (OPT_Wattributes
,
7736 "bad option %s to optimize attribute", p
);
7738 warning (OPT_Wpragmas
,
7739 "bad option %s to pragma attribute", p
);
7747 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7748 itself is -Os, and any other switch begins with a -f. */
7749 if ((*p
>= '0' && *p
<= '9')
7750 || (p
[0] == 's' && p
[1] == '\0'))
7756 memcpy (r
, p
, len2
);
7758 VEC_safe_push (const_char_p
, gc
, optimize_args
, q
);
7764 opt_argc
= VEC_length (const_char_p
, optimize_args
);
7765 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
7767 for (i
= 1; i
< opt_argc
; i
++)
7768 opt_argv
[i
] = VEC_index (const_char_p
, optimize_args
, i
);
7770 saved_flag_strict_aliasing
= flag_strict_aliasing
;
7772 /* Now parse the options. */
7773 decode_options (opt_argc
, opt_argv
, &decoded_options
,
7774 &decoded_options_count
);
7776 targetm
.override_options_after_change();
7778 /* Don't allow changing -fstrict-aliasing. */
7779 flag_strict_aliasing
= saved_flag_strict_aliasing
;
7781 VEC_truncate (const_char_p
, optimize_args
, 0);
7785 /* For handling "optimize" attribute. arguments as in
7786 struct attribute_spec.handler. */
7789 handle_optimize_attribute (tree
*node
, tree name
, tree args
,
7790 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7792 /* Ensure we have a function type. */
7793 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7795 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7796 *no_add_attrs
= true;
7800 struct cl_optimization cur_opts
;
7801 tree old_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
);
7803 /* Save current options. */
7804 cl_optimization_save (&cur_opts
);
7806 /* If we previously had some optimization options, use them as the
7809 cl_optimization_restore (TREE_OPTIMIZATION (old_opts
));
7811 /* Parse options, and update the vector. */
7812 parse_optimize_options (args
, true);
7813 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
)
7814 = build_optimization_node ();
7816 /* Restore current options. */
7817 cl_optimization_restore (&cur_opts
);
7823 /* Handle a "no_split_stack" attribute. */
7826 handle_no_split_stack_attribute (tree
*node
, tree name
,
7827 tree
ARG_UNUSED (args
),
7828 int ARG_UNUSED (flags
),
7833 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7835 error_at (DECL_SOURCE_LOCATION (decl
),
7836 "%qE attribute applies only to functions", name
);
7837 *no_add_attrs
= true;
7839 else if (DECL_INITIAL (decl
))
7841 error_at (DECL_SOURCE_LOCATION (decl
),
7842 "can%'t set %qE attribute after definition", name
);
7843 *no_add_attrs
= true;
7849 /* Check for valid arguments being passed to a function.
7850 ATTRS is a list of attributes. There are NARGS arguments in the array
7851 ARGARRAY. TYPELIST is the list of argument types for the function.
7854 check_function_arguments (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7856 /* Check for null being passed in a pointer argument that must be
7857 non-null. We also need to do this if format checking is enabled. */
7860 check_function_nonnull (attrs
, nargs
, argarray
);
7862 /* Check for errors in format strings. */
7864 if (warn_format
|| warn_missing_format_attribute
)
7865 check_function_format (attrs
, nargs
, argarray
);
7868 check_function_sentinel (attrs
, nargs
, argarray
, typelist
);
7871 /* Generic argument checking recursion routine. PARAM is the argument to
7872 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7873 once the argument is resolved. CTX is context for the callback. */
7875 check_function_arguments_recurse (void (*callback
)
7876 (void *, tree
, unsigned HOST_WIDE_INT
),
7877 void *ctx
, tree param
,
7878 unsigned HOST_WIDE_INT param_num
)
7880 if (CONVERT_EXPR_P (param
)
7881 && (TYPE_PRECISION (TREE_TYPE (param
))
7882 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
7884 /* Strip coercion. */
7885 check_function_arguments_recurse (callback
, ctx
,
7886 TREE_OPERAND (param
, 0), param_num
);
7890 if (TREE_CODE (param
) == CALL_EXPR
)
7892 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
7894 bool found_format_arg
= false;
7896 /* See if this is a call to a known internationalization function
7897 that modifies a format arg. Such a function may have multiple
7898 format_arg attributes (for example, ngettext). */
7900 for (attrs
= TYPE_ATTRIBUTES (type
);
7902 attrs
= TREE_CHAIN (attrs
))
7903 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
7906 tree format_num_expr
;
7909 call_expr_arg_iterator iter
;
7911 /* Extract the argument number, which was previously checked
7913 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
7915 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
7916 && !TREE_INT_CST_HIGH (format_num_expr
));
7918 format_num
= TREE_INT_CST_LOW (format_num_expr
);
7920 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
7922 inner_arg
= next_call_expr_arg (&iter
), i
++)
7923 if (i
== format_num
)
7925 check_function_arguments_recurse (callback
, ctx
,
7926 inner_arg
, param_num
);
7927 found_format_arg
= true;
7932 /* If we found a format_arg attribute and did a recursive check,
7933 we are done with checking this argument. Otherwise, we continue
7934 and this will be considered a non-literal. */
7935 if (found_format_arg
)
7939 if (TREE_CODE (param
) == COND_EXPR
)
7941 /* Check both halves of the conditional expression. */
7942 check_function_arguments_recurse (callback
, ctx
,
7943 TREE_OPERAND (param
, 1), param_num
);
7944 check_function_arguments_recurse (callback
, ctx
,
7945 TREE_OPERAND (param
, 2), param_num
);
7949 (*callback
) (ctx
, param
, param_num
);
7952 /* Checks for a builtin function FNDECL that the number of arguments
7953 NARGS against the required number REQUIRED and issues an error if
7954 there is a mismatch. Returns true if the number of arguments is
7955 correct, otherwise false. */
7958 builtin_function_validate_nargs (tree fndecl
, int nargs
, int required
)
7960 if (nargs
< required
)
7962 error_at (input_location
,
7963 "not enough arguments to function %qE", fndecl
);
7966 else if (nargs
> required
)
7968 error_at (input_location
,
7969 "too many arguments to function %qE", fndecl
);
7975 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7976 Returns false if there was an error, otherwise true. */
7979 check_builtin_function_arguments (tree fndecl
, int nargs
, tree
*args
)
7981 if (!DECL_BUILT_IN (fndecl
)
7982 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
7985 switch (DECL_FUNCTION_CODE (fndecl
))
7987 case BUILT_IN_CONSTANT_P
:
7988 return builtin_function_validate_nargs (fndecl
, nargs
, 1);
7990 case BUILT_IN_ISFINITE
:
7991 case BUILT_IN_ISINF
:
7992 case BUILT_IN_ISINF_SIGN
:
7993 case BUILT_IN_ISNAN
:
7994 case BUILT_IN_ISNORMAL
:
7995 if (builtin_function_validate_nargs (fndecl
, nargs
, 1))
7997 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
7999 error ("non-floating-point argument in call to "
8000 "function %qE", fndecl
);
8007 case BUILT_IN_ISGREATER
:
8008 case BUILT_IN_ISGREATEREQUAL
:
8009 case BUILT_IN_ISLESS
:
8010 case BUILT_IN_ISLESSEQUAL
:
8011 case BUILT_IN_ISLESSGREATER
:
8012 case BUILT_IN_ISUNORDERED
:
8013 if (builtin_function_validate_nargs (fndecl
, nargs
, 2))
8015 enum tree_code code0
, code1
;
8016 code0
= TREE_CODE (TREE_TYPE (args
[0]));
8017 code1
= TREE_CODE (TREE_TYPE (args
[1]));
8018 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
8019 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
8020 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
8022 error ("non-floating-point arguments in call to "
8023 "function %qE", fndecl
);
8030 case BUILT_IN_FPCLASSIFY
:
8031 if (builtin_function_validate_nargs (fndecl
, nargs
, 6))
8036 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
8038 error ("non-const integer argument %u in call to function %qE",
8043 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
8045 error ("non-floating-point argument in call to function %qE",
8058 /* Function to help qsort sort FIELD_DECLs by name order. */
8061 field_decl_cmp (const void *x_p
, const void *y_p
)
8063 const tree
*const x
= (const tree
*const) x_p
;
8064 const tree
*const y
= (const tree
*const) y_p
;
8066 if (DECL_NAME (*x
) == DECL_NAME (*y
))
8067 /* A nontype is "greater" than a type. */
8068 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
8069 if (DECL_NAME (*x
) == NULL_TREE
)
8071 if (DECL_NAME (*y
) == NULL_TREE
)
8073 if (DECL_NAME (*x
) < DECL_NAME (*y
))
8079 gt_pointer_operator new_value
;
8083 /* This routine compares two fields like field_decl_cmp but using the
8084 pointer operator in resort_data. */
8087 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
8089 const tree
*const x
= (const tree
*const) x_p
;
8090 const tree
*const y
= (const tree
*const) y_p
;
8092 if (DECL_NAME (*x
) == DECL_NAME (*y
))
8093 /* A nontype is "greater" than a type. */
8094 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
8095 if (DECL_NAME (*x
) == NULL_TREE
)
8097 if (DECL_NAME (*y
) == NULL_TREE
)
8100 tree d1
= DECL_NAME (*x
);
8101 tree d2
= DECL_NAME (*y
);
8102 resort_data
.new_value (&d1
, resort_data
.cookie
);
8103 resort_data
.new_value (&d2
, resort_data
.cookie
);
8110 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8113 resort_sorted_fields (void *obj
,
8114 void * ARG_UNUSED (orig_obj
),
8115 gt_pointer_operator new_value
,
8118 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
8119 resort_data
.new_value
= new_value
;
8120 resort_data
.cookie
= cookie
;
8121 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
8122 resort_field_decl_cmp
);
8125 /* Subroutine of c_parse_error.
8126 Return the result of concatenating LHS and RHS. RHS is really
8127 a string literal, its first character is indicated by RHS_START and
8128 RHS_SIZE is its length (including the terminating NUL character).
8130 The caller is responsible for deleting the returned pointer. */
8133 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
8135 const int lhs_size
= strlen (lhs
);
8136 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
8137 strncpy (result
, lhs
, lhs_size
);
8138 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
8142 /* Issue the error given by GMSGID, indicating that it occurred before
8143 TOKEN, which had the associated VALUE. */
8146 c_parse_error (const char *gmsgid
, enum cpp_ttype token_type
,
8147 tree value
, unsigned char token_flags
)
8149 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8151 char *message
= NULL
;
8153 if (token_type
== CPP_EOF
)
8154 message
= catenate_messages (gmsgid
, " at end of input");
8155 else if (token_type
== CPP_CHAR
8156 || token_type
== CPP_WCHAR
8157 || token_type
== CPP_CHAR16
8158 || token_type
== CPP_CHAR32
)
8160 unsigned int val
= TREE_INT_CST_LOW (value
);
8179 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
8180 message
= catenate_messages (gmsgid
, " before %s'%c'");
8182 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
8184 error (message
, prefix
, val
);
8188 else if (token_type
== CPP_STRING
8189 || token_type
== CPP_WSTRING
8190 || token_type
== CPP_STRING16
8191 || token_type
== CPP_STRING32
8192 || token_type
== CPP_UTF8STRING
)
8193 message
= catenate_messages (gmsgid
, " before string constant");
8194 else if (token_type
== CPP_NUMBER
)
8195 message
= catenate_messages (gmsgid
, " before numeric constant");
8196 else if (token_type
== CPP_NAME
)
8198 message
= catenate_messages (gmsgid
, " before %qE");
8199 error (message
, value
);
8203 else if (token_type
== CPP_PRAGMA
)
8204 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
8205 else if (token_type
== CPP_PRAGMA_EOL
)
8206 message
= catenate_messages (gmsgid
, " before end of line");
8207 else if (token_type
< N_TTYPES
)
8209 message
= catenate_messages (gmsgid
, " before %qs token");
8210 error (message
, cpp_type2name (token_type
, token_flags
));
8222 #undef catenate_messages
8225 /* Mapping for cpp message reasons to the options that enable them. */
8227 struct reason_option_codes_t
8229 const int reason
; /* cpplib message reason. */
8230 const int option_code
; /* gcc option that controls this message. */
8233 static const struct reason_option_codes_t option_codes
[] = {
8234 {CPP_W_DEPRECATED
, OPT_Wdeprecated
},
8235 {CPP_W_COMMENTS
, OPT_Wcomment
},
8236 {CPP_W_TRIGRAPHS
, OPT_Wtrigraphs
},
8237 {CPP_W_MULTICHAR
, OPT_Wmultichar
},
8238 {CPP_W_TRADITIONAL
, OPT_Wtraditional
},
8239 {CPP_W_LONG_LONG
, OPT_Wlong_long
},
8240 {CPP_W_ENDIF_LABELS
, OPT_Wendif_labels
},
8241 {CPP_W_VARIADIC_MACROS
, OPT_Wvariadic_macros
},
8242 {CPP_W_BUILTIN_MACRO_REDEFINED
, OPT_Wbuiltin_macro_redefined
},
8243 {CPP_W_UNDEF
, OPT_Wundef
},
8244 {CPP_W_UNUSED_MACROS
, OPT_Wunused_macros
},
8245 {CPP_W_CXX_OPERATOR_NAMES
, OPT_Wc___compat
},
8246 {CPP_W_NORMALIZE
, OPT_Wnormalized_
},
8247 {CPP_W_INVALID_PCH
, OPT_Winvalid_pch
},
8248 {CPP_W_WARNING_DIRECTIVE
, OPT_Wcpp
},
8252 /* Return the gcc option code associated with the reason for a cpp
8253 message, or 0 if none. */
8256 c_option_controlling_cpp_error (int reason
)
8258 const struct reason_option_codes_t
*entry
;
8260 for (entry
= option_codes
; entry
->reason
!= CPP_W_NONE
; entry
++)
8262 if (entry
->reason
== reason
)
8263 return entry
->option_code
;
8268 /* Callback from cpp_error for PFILE to print diagnostics from the
8269 preprocessor. The diagnostic is of type LEVEL, with REASON set
8270 to the reason code if LEVEL is represents a warning, at location
8271 LOCATION unless this is after lexing and the compiler's location
8272 should be used instead, with column number possibly overridden by
8273 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8274 the arguments. Returns true if a diagnostic was emitted, false
8278 c_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
, int reason
,
8279 location_t location
, unsigned int column_override
,
8280 const char *msg
, va_list *ap
)
8282 diagnostic_info diagnostic
;
8283 diagnostic_t dlevel
;
8284 bool save_warn_system_headers
= global_dc
->warn_system_headers
;
8289 case CPP_DL_WARNING_SYSHDR
:
8292 global_dc
->warn_system_headers
= 1;
8294 case CPP_DL_WARNING
:
8297 dlevel
= DK_WARNING
;
8299 case CPP_DL_PEDWARN
:
8300 if (flag_no_output
&& !flag_pedantic_errors
)
8302 dlevel
= DK_PEDWARN
;
8320 location
= input_location
;
8321 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
8323 if (column_override
)
8324 diagnostic_override_column (&diagnostic
, column_override
);
8325 diagnostic_override_option_index (&diagnostic
,
8326 c_option_controlling_cpp_error (reason
));
8327 ret
= report_diagnostic (&diagnostic
);
8328 if (level
== CPP_DL_WARNING_SYSHDR
)
8329 global_dc
->warn_system_headers
= save_warn_system_headers
;
8333 /* Convert a character from the host to the target execution character
8334 set. cpplib handles this, mostly. */
8337 c_common_to_target_charset (HOST_WIDE_INT c
)
8339 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8340 zero-extended under -fno-signed-char. cpplib insists that characters
8341 and character constants are always unsigned. Hence we must convert
8343 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
8345 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
8347 if (flag_signed_char
)
8348 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
8349 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
8354 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8355 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8356 NULL, at the bottom; much like the traditional rendering of offsetof as a
8357 macro. Returns the folded and properly cast result. */
8360 fold_offsetof_1 (tree expr
, tree stop_ref
)
8362 enum tree_code code
= PLUS_EXPR
;
8365 if (expr
== stop_ref
&& TREE_CODE (expr
) != ERROR_MARK
)
8366 return size_zero_node
;
8368 switch (TREE_CODE (expr
))
8374 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
8375 return error_mark_node
;
8379 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8380 return error_mark_node
;
8384 if (!integer_zerop (TREE_OPERAND (expr
, 0)))
8386 error ("cannot apply %<offsetof%> to a non constant address");
8387 return error_mark_node
;
8389 return size_zero_node
;
8392 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8393 if (base
== error_mark_node
)
8396 t
= TREE_OPERAND (expr
, 1);
8397 if (DECL_C_BIT_FIELD (t
))
8399 error ("attempt to take address of bit-field structure "
8401 return error_mark_node
;
8403 off
= size_binop_loc (input_location
, PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
8404 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
),
8410 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8411 if (base
== error_mark_node
)
8414 t
= TREE_OPERAND (expr
, 1);
8415 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) < 0)
8418 t
= fold_build1_loc (input_location
, NEGATE_EXPR
, TREE_TYPE (t
), t
);
8420 t
= convert (sizetype
, t
);
8421 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
8423 /* Check if the offset goes beyond the upper bound of the array. */
8424 if (code
== PLUS_EXPR
&& TREE_CODE (t
) == INTEGER_CST
)
8426 tree upbound
= array_ref_up_bound (expr
);
8427 if (upbound
!= NULL_TREE
8428 && TREE_CODE (upbound
) == INTEGER_CST
8429 && !tree_int_cst_equal (upbound
,
8430 TYPE_MAX_VALUE (TREE_TYPE (upbound
))))
8432 upbound
= size_binop (PLUS_EXPR
, upbound
,
8433 build_int_cst (TREE_TYPE (upbound
), 1));
8434 if (tree_int_cst_lt (upbound
, t
))
8438 for (v
= TREE_OPERAND (expr
, 0);
8439 TREE_CODE (v
) == COMPONENT_REF
;
8440 v
= TREE_OPERAND (v
, 0))
8441 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v
, 0)))
8444 tree fld_chain
= DECL_CHAIN (TREE_OPERAND (v
, 1));
8445 for (; fld_chain
; fld_chain
= DECL_CHAIN (fld_chain
))
8446 if (TREE_CODE (fld_chain
) == FIELD_DECL
)
8452 /* Don't warn if the array might be considered a poor
8453 man's flexible array member with a very permissive
8454 definition thereof. */
8455 if (TREE_CODE (v
) == ARRAY_REF
8456 || TREE_CODE (v
) == COMPONENT_REF
)
8457 warning (OPT_Warray_bounds
,
8458 "index %E denotes an offset "
8459 "greater than size of %qT",
8460 t
, TREE_TYPE (TREE_OPERAND (expr
, 0)));
8467 /* Handle static members of volatile structs. */
8468 t
= TREE_OPERAND (expr
, 1);
8469 gcc_assert (TREE_CODE (t
) == VAR_DECL
);
8470 return fold_offsetof_1 (t
, stop_ref
);
8476 return size_binop (code
, base
, off
);
8480 fold_offsetof (tree expr
, tree stop_ref
)
8482 /* Convert back from the internal sizetype to size_t. */
8483 return convert (size_type_node
, fold_offsetof_1 (expr
, stop_ref
));
8486 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
8487 expression, because B will always be true. */
8490 warn_for_omitted_condop (location_t location
, tree cond
)
8492 if (truth_value_p (TREE_CODE (cond
)))
8493 warning_at (location
, OPT_Wparentheses
,
8494 "the omitted middle operand in ?: will always be %<true%>, "
8495 "suggest explicit middle operand");
8498 /* Print an error message for an invalid lvalue. USE says
8499 how the lvalue is being used and so selects the error message. */
8502 lvalue_error (enum lvalue_use use
)
8507 error ("lvalue required as left operand of assignment");
8510 error ("lvalue required as increment operand");
8513 error ("lvalue required as decrement operand");
8516 error ("lvalue required as unary %<&%> operand");
8519 error ("lvalue required in asm statement");
8526 /* *PTYPE is an incomplete array. Complete it with a domain based on
8527 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8528 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8529 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8532 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8534 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
8535 int failure
= 0, quals
;
8536 hashval_t hashcode
= 0;
8538 maxindex
= size_zero_node
;
8541 if (TREE_CODE (initial_value
) == STRING_CST
)
8544 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8545 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
8547 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8549 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
8551 if (VEC_empty (constructor_elt
, v
))
8555 maxindex
= integer_minus_one_node
;
8560 unsigned HOST_WIDE_INT cnt
;
8561 constructor_elt
*ce
;
8562 bool fold_p
= false;
8564 if (VEC_index (constructor_elt
, v
, 0)->index
)
8565 maxindex
= fold_convert_loc (input_location
, sizetype
,
8566 VEC_index (constructor_elt
,
8568 curindex
= maxindex
;
8571 VEC_iterate (constructor_elt
, v
, cnt
, ce
);
8574 bool curfold_p
= false;
8576 curindex
= ce
->index
, curfold_p
= true;
8580 curindex
= fold_convert (sizetype
, curindex
);
8581 curindex
= size_binop (PLUS_EXPR
, curindex
,
8584 if (tree_int_cst_lt (maxindex
, curindex
))
8585 maxindex
= curindex
, fold_p
= curfold_p
;
8588 maxindex
= fold_convert (sizetype
, maxindex
);
8593 /* Make an error message unless that happened already. */
8594 if (initial_value
!= error_mark_node
)
8606 elt
= TREE_TYPE (type
);
8607 quals
= TYPE_QUALS (strip_array_types (elt
));
8611 unqual_elt
= c_build_qualified_type (elt
, KEEP_QUAL_ADDR_SPACE (quals
));
8613 /* Using build_distinct_type_copy and modifying things afterward instead
8614 of using build_array_type to create a new type preserves all of the
8615 TYPE_LANG_FLAG_? bits that the front end may have set. */
8616 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
8617 TREE_TYPE (main_type
) = unqual_elt
;
8618 TYPE_DOMAIN (main_type
) = build_index_type (maxindex
);
8619 layout_type (main_type
);
8621 /* Make sure we have the canonical MAIN_TYPE. */
8622 hashcode
= iterative_hash_object (TYPE_HASH (unqual_elt
), hashcode
);
8623 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type
)),
8625 main_type
= type_hash_canon (hashcode
, main_type
);
8627 /* Fix the canonical type. */
8628 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
8629 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
8630 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
8631 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
8632 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
8633 != TYPE_DOMAIN (main_type
)))
8634 TYPE_CANONICAL (main_type
)
8635 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
8636 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)));
8638 TYPE_CANONICAL (main_type
) = main_type
;
8643 type
= c_build_qualified_type (main_type
, quals
);
8645 if (COMPLETE_TYPE_P (type
)
8646 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
8647 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
8649 error ("size of array is too large");
8650 /* If we proceed with the array type as it is, we'll eventually
8651 crash in tree_low_cst(). */
8652 type
= error_mark_node
;
8660 /* Used to help initialize the builtin-types.def table. When a type of
8661 the correct size doesn't exist, use error_mark_node instead of NULL.
8662 The later results in segfaults even when a decl using the type doesn't
8666 builtin_type_for_size (int size
, bool unsignedp
)
8668 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
8669 return type
? type
: error_mark_node
;
8672 /* A helper function for resolve_overloaded_builtin in resolving the
8673 overloaded __sync_ builtins. Returns a positive power of 2 if the
8674 first operand of PARAMS is a pointer to a supported data type.
8675 Returns 0 if an error is encountered. */
8678 sync_resolve_size (tree function
, VEC(tree
,gc
) *params
)
8683 if (VEC_empty (tree
, params
))
8685 error ("too few arguments to function %qE", function
);
8689 type
= TREE_TYPE (VEC_index (tree
, params
, 0));
8690 if (TREE_CODE (type
) != POINTER_TYPE
)
8693 type
= TREE_TYPE (type
);
8694 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
8697 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
8698 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
8702 error ("incompatible type for argument %d of %qE", 1, function
);
8706 /* A helper function for resolve_overloaded_builtin. Adds casts to
8707 PARAMS to make arguments match up with those of FUNCTION. Drops
8708 the variadic arguments at the end. Returns false if some error
8709 was encountered; true on success. */
8712 sync_resolve_params (tree orig_function
, tree function
, VEC(tree
, gc
) *params
)
8714 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
8716 unsigned int parmnum
;
8718 /* We've declared the implementation functions to use "volatile void *"
8719 as the pointer parameter, so we shouldn't get any complaints from the
8720 call to check_function_arguments what ever type the user used. */
8721 arg_types
= TREE_CHAIN (arg_types
);
8722 ptype
= TREE_TYPE (TREE_TYPE (VEC_index (tree
, params
, 0)));
8724 /* For the rest of the values, we need to cast these to FTYPE, so that we
8725 don't get warnings for passing pointer types, etc. */
8727 while (arg_types
!= void_list_node
)
8732 if (VEC_length (tree
, params
) <= parmnum
)
8734 error ("too few arguments to function %qE", orig_function
);
8738 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8739 so that we get warnings for anything that doesn't match the pointer
8740 type. This isn't portable across the C and C++ front ends atm. */
8741 val
= VEC_index (tree
, params
, parmnum
);
8742 val
= convert (ptype
, val
);
8743 val
= convert (TREE_VALUE (arg_types
), val
);
8744 VEC_replace (tree
, params
, parmnum
, val
);
8746 arg_types
= TREE_CHAIN (arg_types
);
8749 /* The definition of these primitives is variadic, with the remaining
8750 being "an optional list of variables protected by the memory barrier".
8751 No clue what that's supposed to mean, precisely, but we consider all
8752 call-clobbered variables to be protected so we're safe. */
8753 VEC_truncate (tree
, params
, parmnum
+ 1);
8758 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8759 RESULT to make it match the type of the first pointer argument in
8763 sync_resolve_return (tree first_param
, tree result
)
8765 tree ptype
= TREE_TYPE (TREE_TYPE (first_param
));
8766 ptype
= TYPE_MAIN_VARIANT (ptype
);
8767 return convert (ptype
, result
);
8770 /* Some builtin functions are placeholders for other expressions. This
8771 function should be called immediately after parsing the call expression
8772 before surrounding code has committed to the type of the expression.
8774 LOC is the location of the builtin call.
8776 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8777 PARAMS is the argument list for the call. The return value is non-null
8778 when expansion is complete, and null if normal processing should
8782 resolve_overloaded_builtin (location_t loc
, tree function
, VEC(tree
,gc
) *params
)
8784 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
8785 switch (DECL_BUILT_IN_CLASS (function
))
8787 case BUILT_IN_NORMAL
:
8790 if (targetm
.resolve_overloaded_builtin
)
8791 return targetm
.resolve_overloaded_builtin (loc
, function
, params
);
8798 /* Handle BUILT_IN_NORMAL here. */
8801 case BUILT_IN_FETCH_AND_ADD_N
:
8802 case BUILT_IN_FETCH_AND_SUB_N
:
8803 case BUILT_IN_FETCH_AND_OR_N
:
8804 case BUILT_IN_FETCH_AND_AND_N
:
8805 case BUILT_IN_FETCH_AND_XOR_N
:
8806 case BUILT_IN_FETCH_AND_NAND_N
:
8807 case BUILT_IN_ADD_AND_FETCH_N
:
8808 case BUILT_IN_SUB_AND_FETCH_N
:
8809 case BUILT_IN_OR_AND_FETCH_N
:
8810 case BUILT_IN_AND_AND_FETCH_N
:
8811 case BUILT_IN_XOR_AND_FETCH_N
:
8812 case BUILT_IN_NAND_AND_FETCH_N
:
8813 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N
:
8814 case BUILT_IN_VAL_COMPARE_AND_SWAP_N
:
8815 case BUILT_IN_LOCK_TEST_AND_SET_N
:
8816 case BUILT_IN_LOCK_RELEASE_N
:
8818 int n
= sync_resolve_size (function
, params
);
8819 tree new_function
, first_param
, result
;
8822 return error_mark_node
;
8824 new_function
= built_in_decls
[orig_code
+ exact_log2 (n
) + 1];
8825 if (!sync_resolve_params (function
, new_function
, params
))
8826 return error_mark_node
;
8828 first_param
= VEC_index (tree
, params
, 0);
8829 result
= build_function_call_vec (loc
, new_function
, params
, NULL
);
8830 if (orig_code
!= BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8831 && orig_code
!= BUILT_IN_LOCK_RELEASE_N
)
8832 result
= sync_resolve_return (first_param
, result
);
8842 /* Ignoring their sign, return true if two scalar types are the same. */
8844 same_scalar_type_ignoring_signedness (tree t1
, tree t2
)
8846 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
8848 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
|| c1
== FIXED_POINT_TYPE
)
8849 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
8850 || c2
== FIXED_POINT_TYPE
));
8852 /* Equality works here because c_common_signed_type uses
8853 TYPE_MAIN_VARIANT. */
8854 return c_common_signed_type (t1
)
8855 == c_common_signed_type (t2
);
8858 /* Check for missing format attributes on function pointers. LTYPE is
8859 the new type or left-hand side type. RTYPE is the old type or
8860 right-hand side type. Returns TRUE if LTYPE is missing the desired
8864 check_missing_format_attribute (tree ltype
, tree rtype
)
8866 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
8869 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
8870 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
8875 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
8876 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
8884 /* Subscripting with type char is likely to lose on a machine where
8885 chars are signed. So warn on any machine, but optionally. Don't
8886 warn for unsigned char since that type is safe. Don't warn for
8887 signed char because anyone who uses that must have done so
8888 deliberately. Furthermore, we reduce the false positive load by
8889 warning only for non-constant value of type char. */
8892 warn_array_subscript_with_type_char (tree index
)
8894 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
8895 && TREE_CODE (index
) != INTEGER_CST
)
8896 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
8899 /* Implement -Wparentheses for the unexpected C precedence rules, to
8900 cover cases like x + y << z which readers are likely to
8901 misinterpret. We have seen an expression in which CODE is a binary
8902 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8903 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8904 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8905 expression was not formed using a binary or unary operator, or it
8906 was enclosed in parentheses. */
8909 warn_about_parentheses (enum tree_code code
,
8910 enum tree_code code_left
, tree arg_left
,
8911 enum tree_code code_right
, tree arg_right
)
8913 if (!warn_parentheses
)
8916 /* This macro tests that the expression ARG with original tree code
8917 CODE appears to be a boolean expression. or the result of folding a
8918 boolean expression. */
8919 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8920 (truth_value_p (TREE_CODE (ARG)) \
8921 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8922 /* Folding may create 0 or 1 integers from other expressions. */ \
8923 || ((CODE) != INTEGER_CST \
8924 && (integer_onep (ARG) || integer_zerop (ARG))))
8929 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8930 warning (OPT_Wparentheses
,
8931 "suggest parentheses around %<+%> inside %<<<%>");
8932 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8933 warning (OPT_Wparentheses
,
8934 "suggest parentheses around %<-%> inside %<<<%>");
8938 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8939 warning (OPT_Wparentheses
,
8940 "suggest parentheses around %<+%> inside %<>>%>");
8941 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8942 warning (OPT_Wparentheses
,
8943 "suggest parentheses around %<-%> inside %<>>%>");
8946 case TRUTH_ORIF_EXPR
:
8947 if (code_left
== TRUTH_ANDIF_EXPR
|| code_right
== TRUTH_ANDIF_EXPR
)
8948 warning (OPT_Wparentheses
,
8949 "suggest parentheses around %<&&%> within %<||%>");
8953 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
8954 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8955 || code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
8956 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8957 warning (OPT_Wparentheses
,
8958 "suggest parentheses around arithmetic in operand of %<|%>");
8959 /* Check cases like x|y==z */
8960 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8961 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8962 warning (OPT_Wparentheses
,
8963 "suggest parentheses around comparison in operand of %<|%>");
8964 /* Check cases like !x | y */
8965 else if (code_left
== TRUTH_NOT_EXPR
8966 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
8967 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
8968 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8972 if (code_left
== BIT_AND_EXPR
8973 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8974 || code_right
== BIT_AND_EXPR
8975 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8976 warning (OPT_Wparentheses
,
8977 "suggest parentheses around arithmetic in operand of %<^%>");
8978 /* Check cases like x^y==z */
8979 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8980 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8981 warning (OPT_Wparentheses
,
8982 "suggest parentheses around comparison in operand of %<^%>");
8986 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8987 warning (OPT_Wparentheses
,
8988 "suggest parentheses around %<+%> in operand of %<&%>");
8989 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8990 warning (OPT_Wparentheses
,
8991 "suggest parentheses around %<-%> in operand of %<&%>");
8992 /* Check cases like x&y==z */
8993 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8994 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8995 warning (OPT_Wparentheses
,
8996 "suggest parentheses around comparison in operand of %<&%>");
8997 /* Check cases like !x & y */
8998 else if (code_left
== TRUTH_NOT_EXPR
8999 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
9000 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
9001 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
9005 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
9006 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
9007 warning (OPT_Wparentheses
,
9008 "suggest parentheses around comparison in operand of %<==%>");
9011 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
9012 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
9013 warning (OPT_Wparentheses
,
9014 "suggest parentheses around comparison in operand of %<!=%>");
9018 if (TREE_CODE_CLASS (code
) == tcc_comparison
9019 && ((TREE_CODE_CLASS (code_left
) == tcc_comparison
9020 && code_left
!= NE_EXPR
&& code_left
!= EQ_EXPR
9021 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left
)))
9022 || (TREE_CODE_CLASS (code_right
) == tcc_comparison
9023 && code_right
!= NE_EXPR
&& code_right
!= EQ_EXPR
9024 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right
)))))
9025 warning (OPT_Wparentheses
, "comparisons like %<X<=Y<=Z%> do not "
9026 "have their mathematical meaning");
9029 #undef NOT_A_BOOLEAN_EXPR_P
9032 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
9035 warn_for_unused_label (tree label
)
9037 if (!TREE_USED (label
))
9039 if (DECL_INITIAL (label
))
9040 warning (OPT_Wunused_label
, "label %q+D defined but not used", label
);
9042 warning (OPT_Wunused_label
, "label %q+D declared but not defined", label
);
9046 #ifndef TARGET_HAS_TARGETCM
9047 struct gcc_targetcm targetcm
= TARGETCM_INITIALIZER
;
9050 /* Warn for division by zero according to the value of DIVISOR. LOC
9051 is the location of the division operator. */
9054 warn_for_div_by_zero (location_t loc
, tree divisor
)
9056 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9057 about division by zero. Do not issue a warning if DIVISOR has a
9058 floating-point type, since we consider 0.0/0.0 a valid way of
9059 generating a NaN. */
9060 if (c_inhibit_evaluation_warnings
== 0
9061 && (integer_zerop (divisor
) || fixed_zerop (divisor
)))
9062 warning_at (loc
, OPT_Wdiv_by_zero
, "division by zero");
9065 /* Subroutine of build_binary_op. Give warnings for comparisons
9066 between signed and unsigned quantities that may fail. Do the
9067 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9068 so that casts will be considered, but default promotions won't
9071 LOCATION is the location of the comparison operator.
9073 The arguments of this function map directly to local variables
9074 of build_binary_op. */
9077 warn_for_sign_compare (location_t location
,
9078 tree orig_op0
, tree orig_op1
,
9080 tree result_type
, enum tree_code resultcode
)
9082 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
9083 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
9084 int unsignedp0
, unsignedp1
;
9086 /* In C++, check for comparison of different enum types. */
9088 && TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
9089 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
9090 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
9091 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
9093 warning_at (location
,
9094 OPT_Wsign_compare
, "comparison between types %qT and %qT",
9095 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
9098 /* Do not warn if the comparison is being done in a signed type,
9099 since the signed type will only be chosen if it can represent
9100 all the values of the unsigned type. */
9101 if (!TYPE_UNSIGNED (result_type
))
9103 /* Do not warn if both operands are unsigned. */
9104 else if (op0_signed
== op1_signed
)
9108 tree sop
, uop
, base_type
;
9112 sop
= orig_op0
, uop
= orig_op1
;
9114 sop
= orig_op1
, uop
= orig_op0
;
9116 STRIP_TYPE_NOPS (sop
);
9117 STRIP_TYPE_NOPS (uop
);
9118 base_type
= (TREE_CODE (result_type
) == COMPLEX_TYPE
9119 ? TREE_TYPE (result_type
) : result_type
);
9121 /* Do not warn if the signed quantity is an unsuffixed integer
9122 literal (or some static constant expression involving such
9123 literals or a conditional expression involving such literals)
9124 and it is non-negative. */
9125 if (tree_expr_nonnegative_warnv_p (sop
, &ovf
))
9127 /* Do not warn if the comparison is an equality operation, the
9128 unsigned quantity is an integral constant, and it would fit
9129 in the result if the result were signed. */
9130 else if (TREE_CODE (uop
) == INTEGER_CST
9131 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
9132 && int_fits_type_p (uop
, c_common_signed_type (base_type
)))
9134 /* In C, do not warn if the unsigned quantity is an enumeration
9135 constant and its maximum value would fit in the result if the
9136 result were signed. */
9137 else if (!c_dialect_cxx() && TREE_CODE (uop
) == INTEGER_CST
9138 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
9139 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
9140 c_common_signed_type (base_type
)))
9143 warning_at (location
,
9145 "comparison between signed and unsigned integer expressions");
9148 /* Warn if two unsigned values are being compared in a size larger
9149 than their original size, and one (and only one) is the result of
9150 a `~' operator. This comparison will always fail.
9152 Also warn if one operand is a constant, and the constant does not
9153 have all bits set that are set in the ~ operand when it is
9156 op0
= get_narrower (op0
, &unsignedp0
);
9157 op1
= get_narrower (op1
, &unsignedp1
);
9159 if ((TREE_CODE (op0
) == BIT_NOT_EXPR
)
9160 ^ (TREE_CODE (op1
) == BIT_NOT_EXPR
))
9162 if (TREE_CODE (op0
) == BIT_NOT_EXPR
)
9163 op0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
9164 if (TREE_CODE (op1
) == BIT_NOT_EXPR
)
9165 op1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
9167 if (host_integerp (op0
, 0) || host_integerp (op1
, 0))
9170 HOST_WIDE_INT constant
, mask
;
9174 if (host_integerp (op0
, 0))
9177 unsignedp
= unsignedp1
;
9178 constant
= tree_low_cst (op0
, 0);
9183 unsignedp
= unsignedp0
;
9184 constant
= tree_low_cst (op1
, 0);
9187 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
9188 if (bits
< TYPE_PRECISION (result_type
)
9189 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
9191 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
9192 if ((mask
& constant
) != mask
)
9195 warning (OPT_Wsign_compare
,
9196 "promoted ~unsigned is always non-zero");
9198 warning_at (location
, OPT_Wsign_compare
,
9199 "comparison of promoted ~unsigned with constant");
9203 else if (unsignedp0
&& unsignedp1
9204 && (TYPE_PRECISION (TREE_TYPE (op0
))
9205 < TYPE_PRECISION (result_type
))
9206 && (TYPE_PRECISION (TREE_TYPE (op1
))
9207 < TYPE_PRECISION (result_type
)))
9208 warning_at (location
, OPT_Wsign_compare
,
9209 "comparison of promoted ~unsigned with unsigned");
9213 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
9214 type via c_common_type. If -Wdouble-promotion is in use, and the
9215 conditions for warning have been met, issue a warning. GMSGID is
9216 the warning message. It must have two %T specifiers for the type
9217 that was converted (generally "float") and the type to which it was
9218 converted (generally "double), respectively. LOC is the location
9219 to which the awrning should refer. */
9222 do_warn_double_promotion (tree result_type
, tree type1
, tree type2
,
9223 const char *gmsgid
, location_t loc
)
9227 if (!warn_double_promotion
)
9229 /* If the conversion will not occur at run-time, there is no need to
9231 if (c_inhibit_evaluation_warnings
)
9233 if (TYPE_MAIN_VARIANT (result_type
) != double_type_node
9234 && TYPE_MAIN_VARIANT (result_type
) != complex_double_type_node
)
9236 if (TYPE_MAIN_VARIANT (type1
) == float_type_node
9237 || TYPE_MAIN_VARIANT (type1
) == complex_float_type_node
)
9238 source_type
= type1
;
9239 else if (TYPE_MAIN_VARIANT (type2
) == float_type_node
9240 || TYPE_MAIN_VARIANT (type2
) == complex_float_type_node
)
9241 source_type
= type2
;
9244 warning_at (loc
, OPT_Wdouble_promotion
, gmsgid
, source_type
, result_type
);
9247 /* Setup a TYPE_DECL node as a typedef representation.
9249 X is a TYPE_DECL for a typedef statement. Create a brand new
9250 ..._TYPE node (which will be just a variant of the existing
9251 ..._TYPE node with identical properties) and then install X
9252 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9254 The whole point here is to end up with a situation where each
9255 and every ..._TYPE node the compiler creates will be uniquely
9256 associated with AT MOST one node representing a typedef name.
9257 This way, even though the compiler substitutes corresponding
9258 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9259 early on, later parts of the compiler can always do the reverse
9260 translation and get back the corresponding typedef name. For
9263 typedef struct S MY_TYPE;
9266 Later parts of the compiler might only know that `object' was of
9267 type `struct S' if it were not for code just below. With this
9268 code however, later parts of the compiler see something like:
9270 struct S' == struct S
9271 typedef struct S' MY_TYPE;
9274 And they can then deduce (from the node for type struct S') that
9275 the original object declaration was:
9279 Being able to do this is important for proper support of protoize,
9280 and also for generating precise symbolic debugging information
9281 which takes full account of the programmer's (typedef) vocabulary.
9283 Obviously, we don't want to generate a duplicate ..._TYPE node if
9284 the TYPE_DECL node that we are now processing really represents a
9285 standard built-in type. */
9288 set_underlying_type (tree x
)
9290 if (x
== error_mark_node
)
9292 if (DECL_IS_BUILTIN (x
))
9294 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
9295 TYPE_NAME (TREE_TYPE (x
)) = x
;
9297 else if (TREE_TYPE (x
) != error_mark_node
9298 && DECL_ORIGINAL_TYPE (x
) == NULL_TREE
)
9300 tree tt
= TREE_TYPE (x
);
9301 DECL_ORIGINAL_TYPE (x
) = tt
;
9302 tt
= build_variant_type_copy (tt
);
9303 TYPE_STUB_DECL (tt
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
9305 TREE_USED (tt
) = TREE_USED (x
);
9310 /* Record the types used by the current global variable declaration
9311 being parsed, so that we can decide later to emit their debug info.
9312 Those types are in types_used_by_cur_var_decl, and we are going to
9313 store them in the types_used_by_vars_hash hash table.
9314 DECL is the declaration of the global variable that has been parsed. */
9317 record_types_used_by_current_var_decl (tree decl
)
9319 gcc_assert (decl
&& DECL_P (decl
) && TREE_STATIC (decl
));
9321 while (!VEC_empty (tree
, types_used_by_cur_var_decl
))
9323 tree type
= VEC_pop (tree
, types_used_by_cur_var_decl
);
9324 types_used_by_var_decl_insert (type
, decl
);
9328 /* The C and C++ parsers both use vectors to hold function arguments.
9329 For efficiency, we keep a cache of unused vectors. This is the
9332 typedef VEC(tree
,gc
)* tree_gc_vec
;
9333 DEF_VEC_P(tree_gc_vec
);
9334 DEF_VEC_ALLOC_P(tree_gc_vec
,gc
);
9335 static GTY((deletable
)) VEC(tree_gc_vec
,gc
) *tree_vector_cache
;
9337 /* Return a new vector from the cache. If the cache is empty,
9338 allocate a new vector. These vectors are GC'ed, so it is OK if the
9339 pointer is not released.. */
9342 make_tree_vector (void)
9344 if (!VEC_empty (tree_gc_vec
, tree_vector_cache
))
9345 return VEC_pop (tree_gc_vec
, tree_vector_cache
);
9348 /* Passing 0 to VEC_alloc returns NULL, and our callers require
9349 that we always return a non-NULL value. The vector code uses
9350 4 when growing a NULL vector, so we do too. */
9351 return VEC_alloc (tree
, gc
, 4);
9355 /* Release a vector of trees back to the cache. */
9358 release_tree_vector (VEC(tree
,gc
) *vec
)
9362 VEC_truncate (tree
, vec
, 0);
9363 VEC_safe_push (tree_gc_vec
, gc
, tree_vector_cache
, vec
);
9367 /* Get a new tree vector holding a single tree. */
9370 make_tree_vector_single (tree t
)
9372 VEC(tree
,gc
) *ret
= make_tree_vector ();
9373 VEC_quick_push (tree
, ret
, t
);
9377 /* Get a new tree vector which is a copy of an existing one. */
9380 make_tree_vector_copy (const VEC(tree
,gc
) *orig
)
9386 ret
= make_tree_vector ();
9387 VEC_reserve (tree
, gc
, ret
, VEC_length (tree
, orig
));
9388 FOR_EACH_VEC_ELT (tree
, orig
, ix
, t
)
9389 VEC_quick_push (tree
, ret
, t
);
9393 #include "gt-c-family-c-common.h"