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/>. */
22 /* FIXME: Still need to include rtl.h here (via expr.h) in a front-end file.
23 Pretend this is a back-end file. */
24 #undef IN_GCC_FRONTEND
28 #include "coretypes.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
44 #include "diagnostic.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
50 #include "target-def.h"
53 #include "expr.h" /* For vector_mode_valid_p */
55 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
57 /* The following symbols are subsumed in the c_global_trees array, and
58 listed here individually for documentation purposes.
60 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
62 tree short_integer_type_node;
63 tree long_integer_type_node;
64 tree long_long_integer_type_node;
65 tree int128_integer_type_node;
67 tree short_unsigned_type_node;
68 tree long_unsigned_type_node;
69 tree long_long_unsigned_type_node;
70 tree int128_unsigned_type_node;
72 tree truthvalue_type_node;
73 tree truthvalue_false_node;
74 tree truthvalue_true_node;
76 tree ptrdiff_type_node;
78 tree unsigned_char_type_node;
79 tree signed_char_type_node;
82 tree char16_type_node;
83 tree char32_type_node;
86 tree double_type_node;
87 tree long_double_type_node;
89 tree complex_integer_type_node;
90 tree complex_float_type_node;
91 tree complex_double_type_node;
92 tree complex_long_double_type_node;
94 tree dfloat32_type_node;
95 tree dfloat64_type_node;
96 tree_dfloat128_type_node;
100 tree intSI_type_node;
101 tree intDI_type_node;
102 tree intTI_type_node;
104 tree unsigned_intQI_type_node;
105 tree unsigned_intHI_type_node;
106 tree unsigned_intSI_type_node;
107 tree unsigned_intDI_type_node;
108 tree unsigned_intTI_type_node;
110 tree widest_integer_literal_type_node;
111 tree widest_unsigned_literal_type_node;
113 Nodes for types `void *' and `const void *'.
115 tree ptr_type_node, const_ptr_type_node;
117 Nodes for types `char *' and `const char *'.
119 tree string_type_node, const_string_type_node;
121 Type `char[SOMENUMBER]'.
122 Used when an array of char is needed and the size is irrelevant.
124 tree char_array_type_node;
126 Type `int[SOMENUMBER]' or something like it.
127 Used when an array of int needed and the size is irrelevant.
129 tree int_array_type_node;
131 Type `wchar_t[SOMENUMBER]' or something like it.
132 Used when a wide string literal is created.
134 tree wchar_array_type_node;
136 Type `char16_t[SOMENUMBER]' or something like it.
137 Used when a UTF-16 string literal is created.
139 tree char16_array_type_node;
141 Type `char32_t[SOMENUMBER]' or something like it.
142 Used when a UTF-32 string literal is created.
144 tree char32_array_type_node;
146 Type `int ()' -- used for implicit declaration of functions.
148 tree default_function_type;
150 A VOID_TYPE node, packaged in a TREE_LIST.
154 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
155 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
156 VAR_DECLS, but C++ does.)
158 tree function_name_decl_node;
159 tree pretty_function_name_decl_node;
160 tree c99_function_name_decl_node;
162 Stack of nested function name VAR_DECLs.
164 tree saved_function_name_decls;
168 tree c_global_trees
[CTI_MAX
];
170 /* Switches common to the C front ends. */
172 /* Nonzero means don't output line number information. */
174 char flag_no_line_commands
;
176 /* Nonzero causes -E output not to be done, but directives such as
177 #define that have side effects are still obeyed. */
181 /* Nonzero means dump macros in some fashion. */
183 char flag_dump_macros
;
185 /* Nonzero means pass #include lines through to the output. */
187 char flag_dump_includes
;
189 /* Nonzero means process PCH files while preprocessing. */
191 bool flag_pch_preprocess
;
193 /* The file name to which we should write a precompiled header, or
194 NULL if no header will be written in this compile. */
196 const char *pch_file
;
198 /* Nonzero if an ISO standard was selected. It rejects macros in the
202 /* Warn about #pragma directives that are not recognized. */
204 int warn_unknown_pragmas
; /* Tri state variable. */
206 /* Warn about format/argument anomalies in calls to formatted I/O functions
207 (*printf, *scanf, strftime, strfmon, etc.). */
211 /* C/ObjC language option variables. */
214 /* Nonzero means allow type mismatches in conditional expressions;
215 just make their values `void'. */
217 int flag_cond_mismatch
;
219 /* Nonzero means enable C89 Amendment 1 features. */
223 /* Nonzero means use the ISO C99 (or C1X) dialect of C. */
227 /* Nonzero means use the ISO C1X dialect of C. */
231 /* Nonzero means that we have builtin functions, and main is an int. */
236 /* ObjC language option variables. */
239 /* Tells the compiler that this is a special run. Do not perform any
240 compiling, instead we are to test some platform dependent features
241 and output a C header file with appropriate definitions. */
243 int print_struct_values
;
245 /* Tells the compiler what is the constant string class for ObjC. */
247 const char *constant_string_class_name
;
250 /* C++ language option variables. */
253 /* Nonzero means generate separate instantiation control files and
254 juggle them at link time. */
256 int flag_use_repository
;
258 /* The C++ dialect being used. C++98 is the default. */
260 enum cxx_dialect cxx_dialect
= cxx98
;
262 /* Maximum template instantiation depth. This limit exists to limit the
263 time it takes to notice infinite template instantiations; the default
264 value of 1024 is likely to be in the next C++ standard. */
266 int max_tinst_depth
= 1024;
270 /* The elements of `ridpointers' are identifier nodes for the reserved
271 type names and storage classes. It is indexed by a RID_... value. */
274 tree (*make_fname_decl
) (location_t
, tree
, int);
276 /* Nonzero means don't warn about problems that occur when the code is
278 int c_inhibit_evaluation_warnings
;
280 /* Whether lexing has been completed, so subsequent preprocessor
281 errors should use the compiler's input_location. */
282 bool done_lexing
= false;
284 /* Information about how a function name is generated. */
287 tree
*const decl
; /* pointer to the VAR_DECL. */
288 const unsigned rid
; /* RID number for the identifier. */
289 const int pretty
; /* How pretty is it? */
292 /* The three ways of getting then name of the current function. */
294 const struct fname_var_t fname_vars
[] =
296 /* C99 compliant __func__, must be first. */
297 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
298 /* GCC __FUNCTION__ compliant. */
299 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
300 /* GCC __PRETTY_FUNCTION__ compliant. */
301 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
305 static tree
c_fully_fold_internal (tree expr
, bool, bool *, bool *);
306 static tree
check_case_value (tree
);
307 static bool check_case_bounds (tree
, tree
, tree
*, tree
*);
309 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
310 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
311 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
312 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
313 static tree
handle_hot_attribute (tree
*, tree
, tree
, int, bool *);
314 static tree
handle_cold_attribute (tree
*, tree
, tree
, int, bool *);
315 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
316 static tree
handle_noclone_attribute (tree
*, tree
, tree
, int, bool *);
317 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
319 static tree
handle_gnu_inline_attribute (tree
*, tree
, tree
, int, bool *);
320 static tree
handle_artificial_attribute (tree
*, tree
, tree
, int, bool *);
321 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
322 static tree
handle_error_attribute (tree
*, tree
, tree
, int, bool *);
323 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
324 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
325 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
327 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
328 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
330 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
331 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
332 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
333 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
334 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
335 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
336 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
337 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
338 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
340 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
342 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
344 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
345 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
346 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
348 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
349 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
350 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
352 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
354 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
355 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
356 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
357 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
359 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
360 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
361 static tree
handle_alloc_size_attribute (tree
*, tree
, tree
, int, bool *);
362 static tree
handle_target_attribute (tree
*, tree
, tree
, int, bool *);
363 static tree
handle_optimize_attribute (tree
*, tree
, tree
, int, bool *);
364 static tree
handle_fnspec_attribute (tree
*, tree
, tree
, int, bool *);
366 static void check_function_nonnull (tree
, int, tree
*);
367 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
368 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
369 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
370 static int resort_field_decl_cmp (const void *, const void *);
372 /* Reserved words. The third field is a mask: keywords are disabled
373 if they match the mask.
376 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
377 C --std=c99: D_CXXONLY | D_OBJC
378 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
379 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
380 C++ --std=c0x: D_CONLY | D_OBJC
381 ObjC++ is like C++ except that D_OBJC is not set
383 If -fno-asm is used, D_ASM is added to the mask. If
384 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
385 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
386 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
388 const struct c_common_resword c_common_reswords
[] =
390 { "_Bool", RID_BOOL
, D_CONLY
},
391 { "_Complex", RID_COMPLEX
, 0 },
392 { "_Imaginary", RID_IMAGINARY
, D_CONLY
},
393 { "_Decimal32", RID_DFLOAT32
, D_CONLY
| D_EXT
},
394 { "_Decimal64", RID_DFLOAT64
, D_CONLY
| D_EXT
},
395 { "_Decimal128", RID_DFLOAT128
, D_CONLY
| D_EXT
},
396 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
397 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
398 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
399 { "_Static_assert", RID_STATIC_ASSERT
, D_CONLY
},
400 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
401 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
402 { "__alignof", RID_ALIGNOF
, 0 },
403 { "__alignof__", RID_ALIGNOF
, 0 },
404 { "__asm", RID_ASM
, 0 },
405 { "__asm__", RID_ASM
, 0 },
406 { "__attribute", RID_ATTRIBUTE
, 0 },
407 { "__attribute__", RID_ATTRIBUTE
, 0 },
408 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
409 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
410 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
411 { "__builtin_va_arg", RID_VA_ARG
, 0 },
412 { "__complex", RID_COMPLEX
, 0 },
413 { "__complex__", RID_COMPLEX
, 0 },
414 { "__const", RID_CONST
, 0 },
415 { "__const__", RID_CONST
, 0 },
416 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
417 { "__extension__", RID_EXTENSION
, 0 },
418 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
419 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
420 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
421 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
422 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
423 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
424 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
425 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
426 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
427 { "__int128", RID_INT128
, 0 },
428 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
429 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
430 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
431 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO
, D_CXXONLY
},
432 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
433 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
434 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
435 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
436 { "__is_standard_layout", RID_IS_STD_LAYOUT
, D_CXXONLY
},
437 { "__is_trivial", RID_IS_TRIVIAL
, D_CXXONLY
},
438 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
439 { "__imag", RID_IMAGPART
, 0 },
440 { "__imag__", RID_IMAGPART
, 0 },
441 { "__inline", RID_INLINE
, 0 },
442 { "__inline__", RID_INLINE
, 0 },
443 { "__label__", RID_LABEL
, 0 },
444 { "__null", RID_NULL
, 0 },
445 { "__real", RID_REALPART
, 0 },
446 { "__real__", RID_REALPART
, 0 },
447 { "__restrict", RID_RESTRICT
, 0 },
448 { "__restrict__", RID_RESTRICT
, 0 },
449 { "__signed", RID_SIGNED
, 0 },
450 { "__signed__", RID_SIGNED
, 0 },
451 { "__thread", RID_THREAD
, 0 },
452 { "__typeof", RID_TYPEOF
, 0 },
453 { "__typeof__", RID_TYPEOF
, 0 },
454 { "__volatile", RID_VOLATILE
, 0 },
455 { "__volatile__", RID_VOLATILE
, 0 },
456 { "alignof", RID_ALIGNOF
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
457 { "asm", RID_ASM
, D_ASM
},
458 { "auto", RID_AUTO
, 0 },
459 { "bool", RID_BOOL
, D_CXXONLY
| D_CXXWARN
},
460 { "break", RID_BREAK
, 0 },
461 { "case", RID_CASE
, 0 },
462 { "catch", RID_CATCH
, D_CXX_OBJC
| D_CXXWARN
},
463 { "char", RID_CHAR
, 0 },
464 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
465 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
466 { "class", RID_CLASS
, D_CXX_OBJC
| D_CXXWARN
},
467 { "const", RID_CONST
, 0 },
468 { "constexpr", RID_CONSTEXPR
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
469 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
470 { "continue", RID_CONTINUE
, 0 },
471 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
472 { "default", RID_DEFAULT
, 0 },
473 { "delete", RID_DELETE
, D_CXXONLY
| D_CXXWARN
},
475 { "double", RID_DOUBLE
, 0 },
476 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
477 { "else", RID_ELSE
, 0 },
478 { "enum", RID_ENUM
, 0 },
479 { "explicit", RID_EXPLICIT
, D_CXXONLY
| D_CXXWARN
},
480 { "export", RID_EXPORT
, D_CXXONLY
| D_CXXWARN
},
481 { "extern", RID_EXTERN
, 0 },
482 { "false", RID_FALSE
, D_CXXONLY
| D_CXXWARN
},
483 { "float", RID_FLOAT
, 0 },
484 { "for", RID_FOR
, 0 },
485 { "friend", RID_FRIEND
, D_CXXONLY
| D_CXXWARN
},
486 { "goto", RID_GOTO
, 0 },
488 { "inline", RID_INLINE
, D_EXT89
},
489 { "int", RID_INT
, 0 },
490 { "long", RID_LONG
, 0 },
491 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
492 { "namespace", RID_NAMESPACE
, D_CXXONLY
| D_CXXWARN
},
493 { "new", RID_NEW
, D_CXXONLY
| D_CXXWARN
},
494 { "noexcept", RID_NOEXCEPT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
495 { "nullptr", RID_NULLPTR
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
496 { "operator", RID_OPERATOR
, D_CXXONLY
| D_CXXWARN
},
497 { "private", RID_PRIVATE
, D_CXX_OBJC
| D_CXXWARN
},
498 { "protected", RID_PROTECTED
, D_CXX_OBJC
| D_CXXWARN
},
499 { "public", RID_PUBLIC
, D_CXX_OBJC
| D_CXXWARN
},
500 { "register", RID_REGISTER
, 0 },
501 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
502 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
503 { "return", RID_RETURN
, 0 },
504 { "short", RID_SHORT
, 0 },
505 { "signed", RID_SIGNED
, 0 },
506 { "sizeof", RID_SIZEOF
, 0 },
507 { "static", RID_STATIC
, 0 },
508 { "static_assert", RID_STATIC_ASSERT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
509 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
510 { "struct", RID_STRUCT
, 0 },
511 { "switch", RID_SWITCH
, 0 },
512 { "template", RID_TEMPLATE
, D_CXXONLY
| D_CXXWARN
},
513 { "this", RID_THIS
, D_CXXONLY
| D_CXXWARN
},
514 { "throw", RID_THROW
, D_CXX_OBJC
| D_CXXWARN
},
515 { "true", RID_TRUE
, D_CXXONLY
| D_CXXWARN
},
516 { "try", RID_TRY
, D_CXX_OBJC
| D_CXXWARN
},
517 { "typedef", RID_TYPEDEF
, 0 },
518 { "typename", RID_TYPENAME
, D_CXXONLY
| D_CXXWARN
},
519 { "typeid", RID_TYPEID
, D_CXXONLY
| D_CXXWARN
},
520 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
521 { "union", RID_UNION
, 0 },
522 { "unsigned", RID_UNSIGNED
, 0 },
523 { "using", RID_USING
, D_CXXONLY
| D_CXXWARN
},
524 { "virtual", RID_VIRTUAL
, D_CXXONLY
| D_CXXWARN
},
525 { "void", RID_VOID
, 0 },
526 { "volatile", RID_VOLATILE
, 0 },
527 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
528 { "while", RID_WHILE
, 0 },
529 /* These Objective-C keywords are recognized only immediately after
531 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
532 { "defs", RID_AT_DEFS
, D_OBJC
},
533 { "encode", RID_AT_ENCODE
, D_OBJC
},
534 { "end", RID_AT_END
, D_OBJC
},
535 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
536 { "interface", RID_AT_INTERFACE
, D_OBJC
},
537 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
538 { "selector", RID_AT_SELECTOR
, D_OBJC
},
539 { "finally", RID_AT_FINALLY
, D_OBJC
},
540 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
541 /* These are recognized only in protocol-qualifier context
543 { "bycopy", RID_BYCOPY
, D_OBJC
},
544 { "byref", RID_BYREF
, D_OBJC
},
545 { "in", RID_IN
, D_OBJC
},
546 { "inout", RID_INOUT
, D_OBJC
},
547 { "oneway", RID_ONEWAY
, D_OBJC
},
548 { "out", RID_OUT
, D_OBJC
},
551 const unsigned int num_c_common_reswords
=
552 sizeof c_common_reswords
/ sizeof (struct c_common_resword
);
554 /* Table of machine-independent attributes common to all C-like languages. */
555 const struct attribute_spec c_common_attribute_table
[] =
557 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
558 { "packed", 0, 0, false, false, false,
559 handle_packed_attribute
},
560 { "nocommon", 0, 0, true, false, false,
561 handle_nocommon_attribute
},
562 { "common", 0, 0, true, false, false,
563 handle_common_attribute
},
564 /* FIXME: logically, noreturn attributes should be listed as
565 "false, true, true" and apply to function types. But implementing this
566 would require all the places in the compiler that use TREE_THIS_VOLATILE
567 on a decl to identify non-returning functions to be located and fixed
568 to check the function type instead. */
569 { "noreturn", 0, 0, true, false, false,
570 handle_noreturn_attribute
},
571 { "volatile", 0, 0, true, false, false,
572 handle_noreturn_attribute
},
573 { "noinline", 0, 0, true, false, false,
574 handle_noinline_attribute
},
575 { "noclone", 0, 0, true, false, false,
576 handle_noclone_attribute
},
577 { "always_inline", 0, 0, true, false, false,
578 handle_always_inline_attribute
},
579 { "gnu_inline", 0, 0, true, false, false,
580 handle_gnu_inline_attribute
},
581 { "artificial", 0, 0, true, false, false,
582 handle_artificial_attribute
},
583 { "flatten", 0, 0, true, false, false,
584 handle_flatten_attribute
},
585 { "used", 0, 0, true, false, false,
586 handle_used_attribute
},
587 { "unused", 0, 0, false, false, false,
588 handle_unused_attribute
},
589 { "externally_visible", 0, 0, true, false, false,
590 handle_externally_visible_attribute
},
591 /* The same comments as for noreturn attributes apply to const ones. */
592 { "const", 0, 0, true, false, false,
593 handle_const_attribute
},
594 { "transparent_union", 0, 0, false, false, false,
595 handle_transparent_union_attribute
},
596 { "constructor", 0, 1, true, false, false,
597 handle_constructor_attribute
},
598 { "destructor", 0, 1, true, false, false,
599 handle_destructor_attribute
},
600 { "mode", 1, 1, false, true, false,
601 handle_mode_attribute
},
602 { "section", 1, 1, true, false, false,
603 handle_section_attribute
},
604 { "aligned", 0, 1, false, false, false,
605 handle_aligned_attribute
},
606 { "weak", 0, 0, true, false, false,
607 handle_weak_attribute
},
608 { "alias", 1, 1, true, false, false,
609 handle_alias_attribute
},
610 { "weakref", 0, 1, true, false, false,
611 handle_weakref_attribute
},
612 { "no_instrument_function", 0, 0, true, false, false,
613 handle_no_instrument_function_attribute
},
614 { "malloc", 0, 0, true, false, false,
615 handle_malloc_attribute
},
616 { "returns_twice", 0, 0, true, false, false,
617 handle_returns_twice_attribute
},
618 { "no_stack_limit", 0, 0, true, false, false,
619 handle_no_limit_stack_attribute
},
620 { "pure", 0, 0, true, false, false,
621 handle_pure_attribute
},
622 /* For internal use (marking of builtins) only. The name contains space
623 to prevent its usage in source code. */
624 { "no vops", 0, 0, true, false, false,
625 handle_novops_attribute
},
626 { "deprecated", 0, 1, false, false, false,
627 handle_deprecated_attribute
},
628 { "vector_size", 1, 1, false, true, false,
629 handle_vector_size_attribute
},
630 { "visibility", 1, 1, false, false, false,
631 handle_visibility_attribute
},
632 { "tls_model", 1, 1, true, false, false,
633 handle_tls_model_attribute
},
634 { "nonnull", 0, -1, false, true, true,
635 handle_nonnull_attribute
},
636 { "nothrow", 0, 0, true, false, false,
637 handle_nothrow_attribute
},
638 { "may_alias", 0, 0, false, true, false, NULL
},
639 { "cleanup", 1, 1, true, false, false,
640 handle_cleanup_attribute
},
641 { "warn_unused_result", 0, 0, false, true, true,
642 handle_warn_unused_result_attribute
},
643 { "sentinel", 0, 1, false, true, true,
644 handle_sentinel_attribute
},
645 /* For internal use (marking of builtins) only. The name contains space
646 to prevent its usage in source code. */
647 { "type generic", 0, 0, false, true, true,
648 handle_type_generic_attribute
},
649 { "alloc_size", 1, 2, false, true, true,
650 handle_alloc_size_attribute
},
651 { "cold", 0, 0, true, false, false,
652 handle_cold_attribute
},
653 { "hot", 0, 0, true, false, false,
654 handle_hot_attribute
},
655 { "warning", 1, 1, true, false, false,
656 handle_error_attribute
},
657 { "error", 1, 1, true, false, false,
658 handle_error_attribute
},
659 { "target", 1, -1, true, false, false,
660 handle_target_attribute
},
661 { "optimize", 1, -1, true, false, false,
662 handle_optimize_attribute
},
663 /* For internal use (marking of builtins and runtime functions) only.
664 The name contains space to prevent its usage in source code. */
665 { "fn spec", 1, 1, false, true, true,
666 handle_fnspec_attribute
},
667 { NULL
, 0, 0, false, false, false, NULL
}
670 /* Give the specifications for the format attributes, used by C and all
673 const struct attribute_spec c_common_format_attribute_table
[] =
675 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
676 { "format", 3, 3, false, true, true,
677 handle_format_attribute
},
678 { "format_arg", 1, 1, false, true, true,
679 handle_format_arg_attribute
},
680 { NULL
, 0, 0, false, false, false, NULL
}
683 /* Return identifier for address space AS. */
686 c_addr_space_name (addr_space_t as
)
688 int rid
= RID_FIRST_ADDR_SPACE
+ as
;
689 gcc_assert (ridpointers
[rid
]);
690 return IDENTIFIER_POINTER (ridpointers
[rid
]);
693 /* Push current bindings for the function name VAR_DECLS. */
696 start_fname_decls (void)
699 tree saved
= NULL_TREE
;
701 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
703 tree decl
= *fname_vars
[ix
].decl
;
707 saved
= tree_cons (decl
, build_int_cst (NULL_TREE
, ix
), saved
);
708 *fname_vars
[ix
].decl
= NULL_TREE
;
711 if (saved
|| saved_function_name_decls
)
712 /* Normally they'll have been NULL, so only push if we've got a
713 stack, or they are non-NULL. */
714 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
715 saved_function_name_decls
);
718 /* Finish up the current bindings, adding them into the current function's
719 statement tree. This must be done _before_ finish_stmt_tree is called.
720 If there is no current function, we must be at file scope and no statements
721 are involved. Pop the previous bindings. */
724 finish_fname_decls (void)
727 tree stmts
= NULL_TREE
;
728 tree stack
= saved_function_name_decls
;
730 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
731 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
735 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
737 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
738 bodyp
= &BIND_EXPR_BODY (*bodyp
);
740 append_to_statement_list_force (*bodyp
, &stmts
);
744 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
745 *fname_vars
[ix
].decl
= NULL_TREE
;
749 /* We had saved values, restore them. */
752 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
754 tree decl
= TREE_PURPOSE (saved
);
755 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
757 *fname_vars
[ix
].decl
= decl
;
759 stack
= TREE_CHAIN (stack
);
761 saved_function_name_decls
= stack
;
764 /* Return the text name of the current function, suitably prettified
765 by PRETTY_P. Return string must be freed by caller. */
768 fname_as_string (int pretty_p
)
770 const char *name
= "top level";
773 cpp_string cstr
= { 0, 0 }, strname
;
781 if (current_function_decl
)
782 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
784 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
786 namep
= XNEWVEC (char, len
);
787 snprintf (namep
, len
, "\"%s\"", name
);
788 strname
.text
= (unsigned char *) namep
;
789 strname
.len
= len
- 1;
791 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
794 return (const char *) cstr
.text
;
800 /* Return the VAR_DECL for a const char array naming the current
801 function. If the VAR_DECL has not yet been created, create it
802 now. RID indicates how it should be formatted and IDENTIFIER_NODE
803 ID is its name (unfortunately C and C++ hold the RID values of
804 keywords in different places, so we can't derive RID from ID in
805 this language independent code. LOC is the location of the
809 fname_decl (location_t loc
, unsigned int rid
, tree id
)
812 tree decl
= NULL_TREE
;
814 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
815 if (fname_vars
[ix
].rid
== rid
)
818 decl
= *fname_vars
[ix
].decl
;
821 /* If a tree is built here, it would normally have the lineno of
822 the current statement. Later this tree will be moved to the
823 beginning of the function and this line number will be wrong.
824 To avoid this problem set the lineno to 0 here; that prevents
825 it from appearing in the RTL. */
827 location_t saved_location
= input_location
;
828 input_location
= UNKNOWN_LOCATION
;
830 stmts
= push_stmt_list ();
831 decl
= (*make_fname_decl
) (loc
, id
, fname_vars
[ix
].pretty
);
832 stmts
= pop_stmt_list (stmts
);
833 if (!IS_EMPTY_STMT (stmts
))
834 saved_function_name_decls
835 = tree_cons (decl
, stmts
, saved_function_name_decls
);
836 *fname_vars
[ix
].decl
= decl
;
837 input_location
= saved_location
;
839 if (!ix
&& !current_function_decl
)
840 pedwarn (loc
, 0, "%qD is not defined outside of function scope", decl
);
845 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
848 fix_string_type (tree value
)
850 int length
= TREE_STRING_LENGTH (value
);
852 tree e_type
, i_type
, a_type
;
854 /* Compute the number of elements, for the array type. */
855 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
858 e_type
= char_type_node
;
860 else if (TREE_TYPE (value
) == char16_array_type_node
)
862 nchars
= length
/ (TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
);
863 e_type
= char16_type_node
;
865 else if (TREE_TYPE (value
) == char32_array_type_node
)
867 nchars
= length
/ (TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
);
868 e_type
= char32_type_node
;
872 nchars
= length
/ (TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
);
873 e_type
= wchar_type_node
;
876 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
877 limit in C++98 Annex B is very large (65536) and is not normative,
878 so we do not diagnose it (warn_overlength_strings is forced off
879 in c_common_post_options). */
880 if (warn_overlength_strings
)
882 const int nchars_max
= flag_isoc99
? 4095 : 509;
883 const int relevant_std
= flag_isoc99
? 99 : 90;
884 if (nchars
- 1 > nchars_max
)
885 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
886 separate the %d from the 'C'. 'ISO' should not be
887 translated, but it may be moved after 'C%d' in languages
888 where modifiers follow nouns. */
889 pedwarn (input_location
, OPT_Woverlength_strings
,
890 "string length %qd is greater than the length %qd "
891 "ISO C%d compilers are required to support",
892 nchars
- 1, nchars_max
, relevant_std
);
895 /* Create the array type for the string constant. The ISO C++
896 standard says that a string literal has type `const char[N]' or
897 `const wchar_t[N]'. We use the same logic when invoked as a C
898 front-end with -Wwrite-strings.
899 ??? We should change the type of an expression depending on the
900 state of a warning flag. We should just be warning -- see how
901 this is handled in the C++ front-end for the deprecated implicit
902 conversion from string literals to `char*' or `wchar_t*'.
904 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
905 array type being the unqualified version of that type.
906 Therefore, if we are constructing an array of const char, we must
907 construct the matching unqualified array type first. The C front
908 end does not require this, but it does no harm, so we do it
910 i_type
= build_index_type (build_int_cst (NULL_TREE
, nchars
- 1));
911 a_type
= build_array_type (e_type
, i_type
);
912 if (c_dialect_cxx() || warn_write_strings
)
913 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
915 TREE_TYPE (value
) = a_type
;
916 TREE_CONSTANT (value
) = 1;
917 TREE_READONLY (value
) = 1;
918 TREE_STATIC (value
) = 1;
922 /* Fully fold EXPR, an expression that was not folded (beyond integer
923 constant expressions and null pointer constants) when being built
924 up. If IN_INIT, this is in a static initializer and certain
925 changes are made to the folding done. Clear *MAYBE_CONST if
926 MAYBE_CONST is not NULL and EXPR is definitely not a constant
927 expression because it contains an evaluated operator (in C99) or an
928 operator outside of sizeof returning an integer constant (in C90)
929 not permitted in constant expressions, or because it contains an
930 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
931 set to true by callers before calling this function.) Return the
932 folded expression. Function arguments have already been folded
933 before calling this function, as have the contents of SAVE_EXPR,
934 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
935 C_MAYBE_CONST_EXPR. */
938 c_fully_fold (tree expr
, bool in_init
, bool *maybe_const
)
941 tree eptype
= NULL_TREE
;
943 bool maybe_const_itself
= true;
944 location_t loc
= EXPR_LOCATION (expr
);
946 /* This function is not relevant to C++ because C++ folds while
947 parsing, and may need changes to be correct for C++ when C++
948 stops folding while parsing. */
949 if (c_dialect_cxx ())
953 maybe_const
= &dummy
;
954 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
956 eptype
= TREE_TYPE (expr
);
957 expr
= TREE_OPERAND (expr
, 0);
959 ret
= c_fully_fold_internal (expr
, in_init
, maybe_const
,
960 &maybe_const_itself
);
962 ret
= fold_convert_loc (loc
, eptype
, ret
);
963 *maybe_const
&= maybe_const_itself
;
967 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
968 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
969 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
970 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
971 both evaluated and unevaluated subexpressions while
972 *MAYBE_CONST_ITSELF is carried from only evaluated
976 c_fully_fold_internal (tree expr
, bool in_init
, bool *maybe_const_operands
,
977 bool *maybe_const_itself
)
980 enum tree_code code
= TREE_CODE (expr
);
981 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
982 location_t loc
= EXPR_LOCATION (expr
);
983 tree op0
, op1
, op2
, op3
;
984 tree orig_op0
, orig_op1
, orig_op2
;
985 bool op0_const
= true, op1_const
= true, op2_const
= true;
986 bool op0_const_self
= true, op1_const_self
= true, op2_const_self
= true;
987 bool nowarning
= TREE_NO_WARNING (expr
);
990 /* This function is not relevant to C++ because C++ folds while
991 parsing, and may need changes to be correct for C++ when C++
992 stops folding while parsing. */
993 if (c_dialect_cxx ())
996 /* Constants, declarations, statements, errors, SAVE_EXPRs and
997 anything else not counted as an expression cannot usefully be
998 folded further at this point. */
999 if (!IS_EXPR_CODE_CLASS (kind
)
1000 || kind
== tcc_statement
1001 || code
== SAVE_EXPR
)
1004 /* Operands of variable-length expressions (function calls) have
1005 already been folded, as have __builtin_* function calls, and such
1006 expressions cannot occur in constant expressions. */
1007 if (kind
== tcc_vl_exp
)
1009 *maybe_const_operands
= false;
1014 if (code
== C_MAYBE_CONST_EXPR
)
1016 tree pre
= C_MAYBE_CONST_EXPR_PRE (expr
);
1017 tree inner
= C_MAYBE_CONST_EXPR_EXPR (expr
);
1018 if (C_MAYBE_CONST_EXPR_NON_CONST (expr
))
1019 *maybe_const_operands
= false;
1020 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr
))
1021 *maybe_const_itself
= false;
1022 if (pre
&& !in_init
)
1023 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), pre
, inner
);
1029 /* Assignment, increment, decrement, function call and comma
1030 operators, and statement expressions, cannot occur in constant
1031 expressions if evaluated / outside of sizeof. (Function calls
1032 were handled above, though VA_ARG_EXPR is treated like a function
1033 call here, and statement expressions are handled through
1034 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1038 case PREDECREMENT_EXPR
:
1039 case PREINCREMENT_EXPR
:
1040 case POSTDECREMENT_EXPR
:
1041 case POSTINCREMENT_EXPR
:
1043 *maybe_const_operands
= false;
1050 *maybe_const_operands
= false;
1058 /* Fold individual tree codes as appropriate. */
1061 case COMPOUND_LITERAL_EXPR
:
1062 /* Any non-constancy will have been marked in a containing
1063 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1067 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1068 op1
= TREE_OPERAND (expr
, 1);
1069 op2
= TREE_OPERAND (expr
, 2);
1070 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1071 maybe_const_itself
);
1072 STRIP_TYPE_NOPS (op0
);
1073 if (op0
!= orig_op0
)
1074 ret
= build3 (COMPONENT_REF
, TREE_TYPE (expr
), op0
, op1
, op2
);
1077 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1078 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1083 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1084 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1085 op2
= TREE_OPERAND (expr
, 2);
1086 op3
= TREE_OPERAND (expr
, 3);
1087 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1088 maybe_const_itself
);
1089 STRIP_TYPE_NOPS (op0
);
1090 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1091 maybe_const_itself
);
1092 STRIP_TYPE_NOPS (op1
);
1093 op1
= decl_constant_value_for_optimization (op1
);
1094 if (op0
!= orig_op0
|| op1
!= orig_op1
)
1095 ret
= build4 (ARRAY_REF
, TREE_TYPE (expr
), op0
, op1
, op2
, op3
);
1098 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1099 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1100 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1107 case PREDECREMENT_EXPR
:
1108 case PREINCREMENT_EXPR
:
1109 case POSTDECREMENT_EXPR
:
1110 case POSTINCREMENT_EXPR
:
1114 case POINTER_PLUS_EXPR
:
1115 case TRUNC_DIV_EXPR
:
1117 case FLOOR_DIV_EXPR
:
1118 case TRUNC_MOD_EXPR
:
1120 case EXACT_DIV_EXPR
:
1133 case TRUTH_AND_EXPR
:
1135 case TRUTH_XOR_EXPR
:
1136 case UNORDERED_EXPR
:
1143 /* Binary operations evaluating both arguments (increment and
1144 decrement are binary internally in GCC). */
1145 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1146 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1147 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1148 maybe_const_itself
);
1149 STRIP_TYPE_NOPS (op0
);
1150 if (code
!= MODIFY_EXPR
1151 && code
!= PREDECREMENT_EXPR
1152 && code
!= PREINCREMENT_EXPR
1153 && code
!= POSTDECREMENT_EXPR
1154 && code
!= POSTINCREMENT_EXPR
)
1155 op0
= decl_constant_value_for_optimization (op0
);
1156 /* The RHS of a MODIFY_EXPR was fully folded when building that
1157 expression for the sake of conversion warnings. */
1158 if (code
!= MODIFY_EXPR
)
1159 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1160 maybe_const_itself
);
1161 STRIP_TYPE_NOPS (op1
);
1162 op1
= decl_constant_value_for_optimization (op1
);
1163 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1165 ? fold_build2_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
)
1166 : fold_build2_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
);
1169 if (TREE_OVERFLOW_P (ret
)
1170 && !TREE_OVERFLOW_P (op0
)
1171 && !TREE_OVERFLOW_P (op1
))
1172 overflow_warning (EXPR_LOCATION (expr
), ret
);
1176 case FIX_TRUNC_EXPR
:
1179 case NON_LVALUE_EXPR
:
1182 case TRUTH_NOT_EXPR
:
1187 /* Unary operations. */
1188 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1189 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1190 maybe_const_itself
);
1191 STRIP_TYPE_NOPS (op0
);
1192 if (code
!= ADDR_EXPR
&& code
!= REALPART_EXPR
&& code
!= IMAGPART_EXPR
)
1193 op0
= decl_constant_value_for_optimization (op0
);
1194 if (op0
!= orig_op0
|| in_init
)
1196 ? fold_build1_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
)
1197 : fold_build1_loc (loc
, code
, TREE_TYPE (expr
), op0
);
1200 if (code
== INDIRECT_REF
1202 && TREE_CODE (ret
) == INDIRECT_REF
)
1204 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1205 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1206 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1210 case FIX_TRUNC_EXPR
:
1213 /* Don't warn about explicit conversions. We will already
1214 have warned about suspect implicit conversions. */
1218 if (TREE_OVERFLOW_P (ret
) && !TREE_OVERFLOW_P (op0
))
1219 overflow_warning (EXPR_LOCATION (expr
), ret
);
1224 case TRUTH_ANDIF_EXPR
:
1225 case TRUTH_ORIF_EXPR
:
1226 /* Binary operations not necessarily evaluating both
1228 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1229 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1230 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1231 STRIP_TYPE_NOPS (op0
);
1233 unused_p
= (op0
== (code
== TRUTH_ANDIF_EXPR
1234 ? truthvalue_false_node
1235 : truthvalue_true_node
));
1236 c_inhibit_evaluation_warnings
+= unused_p
;
1237 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1238 STRIP_TYPE_NOPS (op1
);
1239 c_inhibit_evaluation_warnings
-= unused_p
;
1241 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1243 ? fold_build2_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
)
1244 : fold_build2_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
);
1247 *maybe_const_operands
&= op0_const
;
1248 *maybe_const_itself
&= op0_const_self
;
1252 && (code
== TRUTH_ANDIF_EXPR
1253 ? op0
== truthvalue_false_node
1254 : op0
== truthvalue_true_node
)))
1255 *maybe_const_operands
&= op1_const
;
1258 && (code
== TRUTH_ANDIF_EXPR
1259 ? op0
== truthvalue_false_node
1260 : op0
== truthvalue_true_node
)))
1261 *maybe_const_itself
&= op1_const_self
;
1265 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1266 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1267 orig_op2
= op2
= TREE_OPERAND (expr
, 2);
1268 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1270 STRIP_TYPE_NOPS (op0
);
1271 c_inhibit_evaluation_warnings
+= (op0
== truthvalue_false_node
);
1272 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1273 STRIP_TYPE_NOPS (op1
);
1274 c_inhibit_evaluation_warnings
-= (op0
== truthvalue_false_node
);
1276 c_inhibit_evaluation_warnings
+= (op0
== truthvalue_true_node
);
1277 op2
= c_fully_fold_internal (op2
, in_init
, &op2_const
, &op2_const_self
);
1278 STRIP_TYPE_NOPS (op2
);
1279 c_inhibit_evaluation_warnings
-= (op0
== truthvalue_true_node
);
1281 if (op0
!= orig_op0
|| op1
!= orig_op1
|| op2
!= orig_op2
)
1282 ret
= fold_build3_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
, op2
);
1285 *maybe_const_operands
&= op0_const
;
1286 *maybe_const_itself
&= op0_const_self
;
1290 && op0
== truthvalue_false_node
))
1291 *maybe_const_operands
&= op1_const
;
1294 && op0
== truthvalue_false_node
))
1295 *maybe_const_itself
&= op1_const_self
;
1299 && op0
== truthvalue_true_node
))
1300 *maybe_const_operands
&= op2_const
;
1303 && op0
== truthvalue_true_node
))
1304 *maybe_const_itself
&= op2_const_self
;
1307 case EXCESS_PRECISION_EXPR
:
1308 /* Each case where an operand with excess precision may be
1309 encountered must remove the EXCESS_PRECISION_EXPR around
1310 inner operands and possibly put one around the whole
1311 expression or possibly convert to the semantic type (which
1312 c_fully_fold does); we cannot tell at this stage which is
1313 appropriate in any particular case. */
1317 /* Various codes may appear through folding built-in functions
1318 and their arguments. */
1323 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1324 have been done by this point, so remove them again. */
1325 nowarning
|= TREE_NO_WARNING (ret
);
1326 STRIP_TYPE_NOPS (ret
);
1327 if (nowarning
&& !TREE_NO_WARNING (ret
))
1329 if (!CAN_HAVE_LOCATION_P (ret
))
1330 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
1331 TREE_NO_WARNING (ret
) = 1;
1334 protected_set_expr_location (ret
, loc
);
1338 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1339 return EXP. Otherwise, return either EXP or its known constant
1340 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1341 Is the BLKmode test appropriate? */
1344 decl_constant_value_for_optimization (tree exp
)
1348 /* This function is only used by C, for c_fully_fold and other
1349 optimization, and may not be correct for C++. */
1350 if (c_dialect_cxx ())
1354 || TREE_CODE (exp
) != VAR_DECL
1355 || TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1356 || DECL_MODE (exp
) == BLKmode
)
1359 ret
= decl_constant_value (exp
);
1360 /* Avoid unwanted tree sharing between the initializer and current
1361 function's body where the tree can be modified e.g. by the
1363 if (ret
!= exp
&& TREE_STATIC (exp
))
1364 ret
= unshare_expr (ret
);
1368 /* Print a warning if a constant expression had overflow in folding.
1369 Invoke this function on every expression that the language
1370 requires to be a constant expression.
1371 Note the ANSI C standard says it is erroneous for a
1372 constant expression to overflow. */
1375 constant_expression_warning (tree value
)
1377 if (warn_overflow
&& pedantic
1378 && (TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1379 || TREE_CODE (value
) == FIXED_CST
1380 || TREE_CODE (value
) == VECTOR_CST
1381 || TREE_CODE (value
) == COMPLEX_CST
)
1382 && TREE_OVERFLOW (value
))
1383 pedwarn (input_location
, OPT_Woverflow
, "overflow in constant expression");
1386 /* The same as above but print an unconditional error. */
1388 constant_expression_error (tree value
)
1390 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1391 || TREE_CODE (value
) == FIXED_CST
1392 || TREE_CODE (value
) == VECTOR_CST
1393 || TREE_CODE (value
) == COMPLEX_CST
)
1394 && TREE_OVERFLOW (value
))
1395 error ("overflow in constant expression");
1398 /* Print a warning if an expression had overflow in folding and its
1401 Invoke this function on every expression that
1402 (1) appears in the source code, and
1403 (2) is a constant expression that overflowed, and
1404 (3) is not already checked by convert_and_check;
1405 however, do not invoke this function on operands of explicit casts
1406 or when the expression is the result of an operator and any operand
1407 already overflowed. */
1410 overflow_warning (location_t loc
, tree value
)
1412 if (c_inhibit_evaluation_warnings
!= 0)
1415 switch (TREE_CODE (value
))
1418 warning_at (loc
, OPT_Woverflow
, "integer overflow in expression");
1422 warning_at (loc
, OPT_Woverflow
,
1423 "floating point overflow in expression");
1427 warning_at (loc
, OPT_Woverflow
, "fixed-point overflow in expression");
1431 warning_at (loc
, OPT_Woverflow
, "vector overflow in expression");
1435 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
1436 warning_at (loc
, OPT_Woverflow
,
1437 "complex integer overflow in expression");
1438 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
1439 warning_at (loc
, OPT_Woverflow
,
1440 "complex floating point overflow in expression");
1448 /* Warn about uses of logical || / && operator in a context where it
1449 is likely that the bitwise equivalent was intended by the
1450 programmer. We have seen an expression in which CODE is a binary
1451 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1452 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1454 warn_logical_operator (location_t location
, enum tree_code code
, tree type
,
1455 enum tree_code code_left
, tree op_left
,
1456 enum tree_code
ARG_UNUSED (code_right
), tree op_right
)
1458 int or_op
= (code
== TRUTH_ORIF_EXPR
|| code
== TRUTH_OR_EXPR
);
1459 int in0_p
, in1_p
, in_p
;
1460 tree low0
, low1
, low
, high0
, high1
, high
, lhs
, rhs
, tem
;
1461 bool strict_overflow_p
= false;
1463 if (code
!= TRUTH_ANDIF_EXPR
1464 && code
!= TRUTH_AND_EXPR
1465 && code
!= TRUTH_ORIF_EXPR
1466 && code
!= TRUTH_OR_EXPR
)
1469 /* Warn if &&/|| are being used in a context where it is
1470 likely that the bitwise equivalent was intended by the
1471 programmer. That is, an expression such as op && MASK
1472 where op should not be any boolean expression, nor a
1473 constant, and mask seems to be a non-boolean integer constant. */
1474 if (!truth_value_p (code_left
)
1475 && INTEGRAL_TYPE_P (TREE_TYPE (op_left
))
1476 && !CONSTANT_CLASS_P (op_left
)
1477 && !TREE_NO_WARNING (op_left
)
1478 && TREE_CODE (op_right
) == INTEGER_CST
1479 && !integer_zerop (op_right
)
1480 && !integer_onep (op_right
))
1483 warning_at (location
, OPT_Wlogical_op
, "logical %<or%>"
1484 " applied to non-boolean constant");
1486 warning_at (location
, OPT_Wlogical_op
, "logical %<and%>"
1487 " applied to non-boolean constant");
1488 TREE_NO_WARNING (op_left
) = true;
1492 /* We do not warn for constants because they are typical of macro
1493 expansions that test for features. */
1494 if (CONSTANT_CLASS_P (op_left
) || CONSTANT_CLASS_P (op_right
))
1497 /* This warning only makes sense with logical operands. */
1498 if (!(truth_value_p (TREE_CODE (op_left
))
1499 || INTEGRAL_TYPE_P (TREE_TYPE (op_left
)))
1500 || !(truth_value_p (TREE_CODE (op_right
))
1501 || INTEGRAL_TYPE_P (TREE_TYPE (op_right
))))
1504 lhs
= make_range (op_left
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
1505 rhs
= make_range (op_right
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
1507 if (lhs
&& TREE_CODE (lhs
) == C_MAYBE_CONST_EXPR
)
1508 lhs
= C_MAYBE_CONST_EXPR_EXPR (lhs
);
1510 if (rhs
&& TREE_CODE (rhs
) == C_MAYBE_CONST_EXPR
)
1511 rhs
= C_MAYBE_CONST_EXPR_EXPR (rhs
);
1513 /* If this is an OR operation, invert both sides; we will invert
1514 again at the end. */
1516 in0_p
= !in0_p
, in1_p
= !in1_p
;
1518 /* If both expressions are the same, if we can merge the ranges, and we
1519 can build the range test, return it or it inverted. */
1520 if (lhs
&& rhs
&& operand_equal_p (lhs
, rhs
, 0)
1521 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
1523 && 0 != (tem
= build_range_check (UNKNOWN_LOCATION
,
1524 type
, lhs
, in_p
, low
, high
)))
1526 if (TREE_CODE (tem
) != INTEGER_CST
)
1530 warning_at (location
, OPT_Wlogical_op
,
1532 "of collectively exhaustive tests is always true");
1534 warning_at (location
, OPT_Wlogical_op
,
1536 "of mutually exclusive tests is always false");
1541 /* Print a warning about casts that might indicate violation
1542 of strict aliasing rules if -Wstrict-aliasing is used and
1543 strict aliasing mode is in effect. OTYPE is the original
1544 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1547 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
1549 /* Strip pointer conversion chains and get to the correct original type. */
1551 otype
= TREE_TYPE (expr
);
1553 if (!(flag_strict_aliasing
1554 && POINTER_TYPE_P (type
)
1555 && POINTER_TYPE_P (otype
)
1556 && !VOID_TYPE_P (TREE_TYPE (type
)))
1557 /* If the type we are casting to is a ref-all pointer
1558 dereferencing it is always valid. */
1559 || TYPE_REF_CAN_ALIAS_ALL (type
))
1562 if ((warn_strict_aliasing
> 1) && TREE_CODE (expr
) == ADDR_EXPR
1563 && (DECL_P (TREE_OPERAND (expr
, 0))
1564 || handled_component_p (TREE_OPERAND (expr
, 0))))
1566 /* Casting the address of an object to non void pointer. Warn
1567 if the cast breaks type based aliasing. */
1568 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)) && warn_strict_aliasing
== 2)
1570 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
1571 "might break strict-aliasing rules");
1576 /* warn_strict_aliasing >= 3. This includes the default (3).
1577 Only warn if the cast is dereferenced immediately. */
1578 alias_set_type set1
=
1579 get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1580 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1582 if (set1
!= set2
&& set2
!= 0
1583 && (set1
== 0 || !alias_sets_conflict_p (set1
, set2
)))
1585 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1586 "pointer will break strict-aliasing rules");
1589 else if (warn_strict_aliasing
== 2
1590 && !alias_sets_must_conflict_p (set1
, set2
))
1592 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1593 "pointer might break strict-aliasing rules");
1599 if ((warn_strict_aliasing
== 1) && !VOID_TYPE_P (TREE_TYPE (otype
)))
1601 /* At this level, warn for any conversions, even if an address is
1602 not taken in the same statement. This will likely produce many
1603 false positives, but could be useful to pinpoint problems that
1604 are not revealed at higher levels. */
1605 alias_set_type set1
= get_alias_set (TREE_TYPE (otype
));
1606 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1607 if (!COMPLETE_TYPE_P (type
)
1608 || !alias_sets_must_conflict_p (set1
, set2
))
1610 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1611 "pointer might break strict-aliasing rules");
1619 /* Warn for unlikely, improbable, or stupid DECL declarations
1623 check_main_parameter_types (tree decl
)
1628 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); args
;
1629 args
= TREE_CHAIN (args
))
1631 tree type
= args
? TREE_VALUE (args
) : 0;
1633 if (type
== void_type_node
|| type
== error_mark_node
)
1640 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
1641 pedwarn (input_location
, OPT_Wmain
, "first argument of %q+D should be %<int%>",
1646 if (TREE_CODE (type
) != POINTER_TYPE
1647 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1648 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1650 pedwarn (input_location
, OPT_Wmain
, "second argument of %q+D should be %<char **%>",
1655 if (TREE_CODE (type
) != POINTER_TYPE
1656 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1657 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1659 pedwarn (input_location
, OPT_Wmain
, "third argument of %q+D should probably be "
1660 "%<char **%>", decl
);
1665 /* It is intentional that this message does not mention the third
1666 argument because it's only mentioned in an appendix of the
1668 if (argct
> 0 && (argct
< 2 || argct
> 3))
1669 pedwarn (input_location
, OPT_Wmain
, "%q+D takes only zero or two arguments", decl
);
1672 /* True if pointers to distinct types T1 and T2 can be converted to
1673 each other without an explicit cast. Only returns true for opaque
1676 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
1678 if (TREE_CODE (t1
) == VECTOR_TYPE
&& TREE_CODE (t2
) == VECTOR_TYPE
1679 && (TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
1680 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1686 /* True if vector types T1 and T2 can be converted to each other
1687 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1688 can only be converted with -flax-vector-conversions yet that is not
1689 in effect, emit a note telling the user about that option if such
1690 a note has not previously been emitted. */
1692 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
1694 static bool emitted_lax_note
= false;
1695 bool convertible_lax
;
1697 if ((TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
1698 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1702 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1703 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
1704 TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
1705 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1706 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
1708 if (!convertible_lax
|| flag_lax_vector_conversions
)
1709 return convertible_lax
;
1711 if (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
1712 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1715 if (emit_lax_note
&& !emitted_lax_note
)
1717 emitted_lax_note
= true;
1718 inform (input_location
, "use -flax-vector-conversions to permit "
1719 "conversions between vectors with differing "
1720 "element types or numbers of subparts");
1726 /* This is a helper function of build_binary_op.
1728 For certain operations if both args were extended from the same
1729 smaller type, do the arithmetic in that type and then extend.
1731 BITWISE indicates a bitwise operation.
1732 For them, this optimization is safe only if
1733 both args are zero-extended or both are sign-extended.
1734 Otherwise, we might change the result.
1735 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1736 but calculated in (unsigned short) it would be (unsigned short)-1.
1738 tree
shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
1740 int unsigned0
, unsigned1
;
1745 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1746 excessive narrowing when we call get_narrower below. For
1747 example, suppose that OP0 is of unsigned int extended
1748 from signed char and that RESULT_TYPE is long long int.
1749 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1752 (long long int) (unsigned int) signed_char
1754 which get_narrower would narrow down to
1756 (unsigned int) signed char
1758 If we do not cast OP0 first, get_narrower would return
1759 signed_char, which is inconsistent with the case of the
1761 op0
= convert (result_type
, op0
);
1762 op1
= convert (result_type
, op1
);
1764 arg0
= get_narrower (op0
, &unsigned0
);
1765 arg1
= get_narrower (op1
, &unsigned1
);
1767 /* UNS is 1 if the operation to be done is an unsigned one. */
1768 uns
= TYPE_UNSIGNED (result_type
);
1770 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1771 but it *requires* conversion to FINAL_TYPE. */
1773 if ((TYPE_PRECISION (TREE_TYPE (op0
))
1774 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1775 && TREE_TYPE (op0
) != result_type
)
1776 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1777 if ((TYPE_PRECISION (TREE_TYPE (op1
))
1778 == TYPE_PRECISION (TREE_TYPE (arg1
)))
1779 && TREE_TYPE (op1
) != result_type
)
1780 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1782 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1784 /* For bitwise operations, signedness of nominal type
1785 does not matter. Consider only how operands were extended. */
1789 /* Note that in all three cases below we refrain from optimizing
1790 an unsigned operation on sign-extended args.
1791 That would not be valid. */
1793 /* Both args variable: if both extended in same way
1794 from same width, do it in that width.
1795 Do it unsigned if args were zero-extended. */
1796 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
1797 < TYPE_PRECISION (result_type
))
1798 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1799 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1800 && unsigned0
== unsigned1
1801 && (unsigned0
|| !uns
))
1802 return c_common_signed_or_unsigned_type
1803 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
1805 else if (TREE_CODE (arg0
) == INTEGER_CST
1806 && (unsigned1
|| !uns
)
1807 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1808 < TYPE_PRECISION (result_type
))
1810 = c_common_signed_or_unsigned_type (unsigned1
,
1812 && !POINTER_TYPE_P (type
)
1813 && int_fits_type_p (arg0
, type
))
1816 else if (TREE_CODE (arg1
) == INTEGER_CST
1817 && (unsigned0
|| !uns
)
1818 && (TYPE_PRECISION (TREE_TYPE (arg0
))
1819 < TYPE_PRECISION (result_type
))
1821 = c_common_signed_or_unsigned_type (unsigned0
,
1823 && !POINTER_TYPE_P (type
)
1824 && int_fits_type_p (arg1
, type
))
1830 /* Warns if the conversion of EXPR to TYPE may alter a value.
1831 This is a helper function for warnings_for_convert_and_check. */
1834 conversion_warning (tree type
, tree expr
)
1836 bool give_warning
= false;
1839 const int expr_num_operands
= TREE_OPERAND_LENGTH (expr
);
1840 tree expr_type
= TREE_TYPE (expr
);
1841 location_t loc
= EXPR_HAS_LOCATION (expr
)
1842 ? EXPR_LOCATION (expr
) : input_location
;
1844 if (!warn_conversion
&& !warn_sign_conversion
)
1847 /* If any operand is artificial, then this expression was generated
1848 by the compiler and we do not warn. */
1849 for (i
= 0; i
< expr_num_operands
; i
++)
1851 tree op
= TREE_OPERAND (expr
, i
);
1852 if (op
&& DECL_P (op
) && DECL_ARTIFICIAL (op
))
1856 switch (TREE_CODE (expr
))
1864 case TRUTH_ANDIF_EXPR
:
1865 case TRUTH_ORIF_EXPR
:
1866 case TRUTH_AND_EXPR
:
1868 case TRUTH_XOR_EXPR
:
1869 case TRUTH_NOT_EXPR
:
1870 /* Conversion from boolean to a signed:1 bit-field (which only
1871 can hold the values 0 and -1) doesn't lose information - but
1872 it does change the value. */
1873 if (TYPE_PRECISION (type
) == 1 && !TYPE_UNSIGNED (type
))
1874 warning_at (loc
, OPT_Wconversion
,
1875 "conversion to %qT from boolean expression", type
);
1881 /* Warn for real constant that is not an exact integer converted
1883 if (TREE_CODE (expr_type
) == REAL_TYPE
1884 && TREE_CODE (type
) == INTEGER_TYPE
)
1886 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (expr_type
)))
1887 give_warning
= true;
1889 /* Warn for an integer constant that does not fit into integer type. */
1890 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1891 && TREE_CODE (type
) == INTEGER_TYPE
1892 && !int_fits_type_p (expr
, type
))
1894 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)
1895 && tree_int_cst_sgn (expr
) < 0)
1896 warning_at (loc
, OPT_Wsign_conversion
, "negative integer"
1897 " implicitly converted to unsigned type");
1898 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (expr_type
))
1899 warning_at (loc
, OPT_Wsign_conversion
, "conversion of unsigned"
1900 " constant value to negative integer");
1902 give_warning
= true;
1904 else if (TREE_CODE (type
) == REAL_TYPE
)
1906 /* Warn for an integer constant that does not fit into real type. */
1907 if (TREE_CODE (expr_type
) == INTEGER_TYPE
)
1909 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
1910 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1911 give_warning
= true;
1913 /* Warn for a real constant that does not fit into a smaller
1915 else if (TREE_CODE (expr_type
) == REAL_TYPE
1916 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1918 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
1919 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1920 give_warning
= true;
1925 warning_at (loc
, OPT_Wconversion
,
1926 "conversion to %qT alters %qT constant value",
1933 /* In case of COND_EXPR, if both operands are constants or
1934 COND_EXPR, then we do not care about the type of COND_EXPR,
1935 only about the conversion of each operand. */
1936 tree op1
= TREE_OPERAND (expr
, 1);
1937 tree op2
= TREE_OPERAND (expr
, 2);
1939 if ((TREE_CODE (op1
) == REAL_CST
|| TREE_CODE (op1
) == INTEGER_CST
1940 || TREE_CODE (op1
) == COND_EXPR
)
1941 && (TREE_CODE (op2
) == REAL_CST
|| TREE_CODE (op2
) == INTEGER_CST
1942 || TREE_CODE (op2
) == COND_EXPR
))
1944 conversion_warning (type
, op1
);
1945 conversion_warning (type
, op2
);
1951 default: /* 'expr' is not a constant. */
1953 /* Warn for real types converted to integer types. */
1954 if (TREE_CODE (expr_type
) == REAL_TYPE
1955 && TREE_CODE (type
) == INTEGER_TYPE
)
1956 give_warning
= true;
1958 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1959 && TREE_CODE (type
) == INTEGER_TYPE
)
1961 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1962 expr
= get_unwidened (expr
, 0);
1963 expr_type
= TREE_TYPE (expr
);
1965 /* Don't warn for short y; short x = ((int)y & 0xff); */
1966 if (TREE_CODE (expr
) == BIT_AND_EXPR
1967 || TREE_CODE (expr
) == BIT_IOR_EXPR
1968 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
1970 /* If both args were extended from a shortest type,
1971 use that type if that is safe. */
1972 expr_type
= shorten_binary_op (expr_type
,
1973 TREE_OPERAND (expr
, 0),
1974 TREE_OPERAND (expr
, 1),
1977 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
1979 tree op0
= TREE_OPERAND (expr
, 0);
1980 tree op1
= TREE_OPERAND (expr
, 1);
1981 bool unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1982 bool unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1984 /* If one of the operands is a non-negative constant
1985 that fits in the target type, then the type of the
1986 other operand does not matter. */
1987 if ((TREE_CODE (op0
) == INTEGER_CST
1988 && int_fits_type_p (op0
, c_common_signed_type (type
))
1989 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
1990 || (TREE_CODE (op1
) == INTEGER_CST
1991 && int_fits_type_p (op1
, c_common_signed_type (type
))
1992 && int_fits_type_p (op1
,
1993 c_common_unsigned_type (type
))))
1995 /* If constant is unsigned and fits in the target
1996 type, then the result will also fit. */
1997 else if ((TREE_CODE (op0
) == INTEGER_CST
1999 && int_fits_type_p (op0
, type
))
2000 || (TREE_CODE (op1
) == INTEGER_CST
2002 && int_fits_type_p (op1
, type
)))
2006 /* Warn for integer types converted to smaller integer types. */
2007 if (TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2008 give_warning
= true;
2010 /* When they are the same width but different signedness,
2011 then the value may change. */
2012 else if ((TYPE_PRECISION (type
) == TYPE_PRECISION (expr_type
)
2013 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
2014 /* Even when converted to a bigger type, if the type is
2015 unsigned but expr is signed, then negative values
2017 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
2018 warning_at (loc
, OPT_Wsign_conversion
, "conversion to %qT from %qT "
2019 "may change the sign of the result",
2023 /* Warn for integer types converted to real types if and only if
2024 all the range of values of the integer type cannot be
2025 represented by the real type. */
2026 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2027 && TREE_CODE (type
) == REAL_TYPE
)
2029 tree type_low_bound
, type_high_bound
;
2030 REAL_VALUE_TYPE real_low_bound
, real_high_bound
;
2032 /* Don't warn about char y = 0xff; float x = (int) y; */
2033 expr
= get_unwidened (expr
, 0);
2034 expr_type
= TREE_TYPE (expr
);
2036 type_low_bound
= TYPE_MIN_VALUE (expr_type
);
2037 type_high_bound
= TYPE_MAX_VALUE (expr_type
);
2038 real_low_bound
= real_value_from_int_cst (0, type_low_bound
);
2039 real_high_bound
= real_value_from_int_cst (0, type_high_bound
);
2041 if (!exact_real_truncate (TYPE_MODE (type
), &real_low_bound
)
2042 || !exact_real_truncate (TYPE_MODE (type
), &real_high_bound
))
2043 give_warning
= true;
2046 /* Warn for real types converted to smaller real types. */
2047 else if (TREE_CODE (expr_type
) == REAL_TYPE
2048 && TREE_CODE (type
) == REAL_TYPE
2049 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2050 give_warning
= true;
2054 warning_at (loc
, OPT_Wconversion
,
2055 "conversion to %qT from %qT may alter its value",
2060 /* Produce warnings after a conversion. RESULT is the result of
2061 converting EXPR to TYPE. This is a helper function for
2062 convert_and_check and cp_convert_and_check. */
2065 warnings_for_convert_and_check (tree type
, tree expr
, tree result
)
2067 if (TREE_CODE (expr
) == INTEGER_CST
2068 && (TREE_CODE (type
) == INTEGER_TYPE
2069 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2070 && !int_fits_type_p (expr
, type
))
2072 /* Do not diagnose overflow in a constant expression merely
2073 because a conversion overflowed. */
2074 if (TREE_OVERFLOW (result
))
2075 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
2077 if (TYPE_UNSIGNED (type
))
2079 /* This detects cases like converting -129 or 256 to
2081 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
2082 warning (OPT_Woverflow
,
2083 "large integer implicitly truncated to unsigned type");
2085 conversion_warning (type
, expr
);
2087 else if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
2088 warning (OPT_Woverflow
,
2089 "overflow in implicit constant conversion");
2090 /* No warning for converting 0x80000000 to int. */
2092 && (TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
2093 || TYPE_PRECISION (TREE_TYPE (expr
))
2094 != TYPE_PRECISION (type
)))
2095 warning (OPT_Woverflow
,
2096 "overflow in implicit constant conversion");
2099 conversion_warning (type
, expr
);
2101 else if ((TREE_CODE (result
) == INTEGER_CST
2102 || TREE_CODE (result
) == FIXED_CST
) && TREE_OVERFLOW (result
))
2103 warning (OPT_Woverflow
,
2104 "overflow in implicit constant conversion");
2106 conversion_warning (type
, expr
);
2110 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2111 Invoke this function on every expression that is converted implicitly,
2112 i.e. because of language rules and not because of an explicit cast. */
2115 convert_and_check (tree type
, tree expr
)
2118 tree expr_for_warning
;
2120 /* Convert from a value with possible excess precision rather than
2121 via the semantic type, but do not warn about values not fitting
2122 exactly in the semantic type. */
2123 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
2125 tree orig_type
= TREE_TYPE (expr
);
2126 expr
= TREE_OPERAND (expr
, 0);
2127 expr_for_warning
= convert (orig_type
, expr
);
2128 if (orig_type
== type
)
2129 return expr_for_warning
;
2132 expr_for_warning
= expr
;
2134 if (TREE_TYPE (expr
) == type
)
2137 result
= convert (type
, expr
);
2139 if (c_inhibit_evaluation_warnings
== 0
2140 && !TREE_OVERFLOW_P (expr
)
2141 && result
!= error_mark_node
)
2142 warnings_for_convert_and_check (type
, expr_for_warning
, result
);
2147 /* A node in a list that describes references to variables (EXPR), which are
2148 either read accesses if WRITER is zero, or write accesses, in which case
2149 WRITER is the parent of EXPR. */
2156 /* Used to implement a cache the results of a call to verify_tree. We only
2157 use this for SAVE_EXPRs. */
2160 struct tlist_cache
*next
;
2161 struct tlist
*cache_before_sp
;
2162 struct tlist
*cache_after_sp
;
2166 /* Obstack to use when allocating tlist structures, and corresponding
2168 static struct obstack tlist_obstack
;
2169 static char *tlist_firstobj
= 0;
2171 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2173 static struct tlist
*warned_ids
;
2174 /* SAVE_EXPRs need special treatment. We process them only once and then
2175 cache the results. */
2176 static struct tlist_cache
*save_expr_cache
;
2178 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
2179 static void merge_tlist (struct tlist
**, struct tlist
*, int);
2180 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
2181 static int warning_candidate_p (tree
);
2182 static bool candidate_equal_p (const_tree
, const_tree
);
2183 static void warn_for_collisions (struct tlist
*);
2184 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
2185 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
2187 /* Create a new struct tlist and fill in its fields. */
2188 static struct tlist
*
2189 new_tlist (struct tlist
*next
, tree t
, tree writer
)
2192 l
= XOBNEW (&tlist_obstack
, struct tlist
);
2199 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2200 is nonnull, we ignore any node we find which has a writer equal to it. */
2203 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
2207 struct tlist
*next
= add
->next
;
2210 if (!exclude_writer
|| !candidate_equal_p (add
->writer
, exclude_writer
))
2211 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
2216 /* Merge the nodes of ADD into TO. This merging process is done so that for
2217 each variable that already exists in TO, no new node is added; however if
2218 there is a write access recorded in ADD, and an occurrence on TO is only
2219 a read access, then the occurrence in TO will be modified to record the
2223 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
2225 struct tlist
**end
= to
;
2228 end
= &(*end
)->next
;
2234 struct tlist
*next
= add
->next
;
2236 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
2237 if (candidate_equal_p (tmp2
->expr
, add
->expr
))
2241 tmp2
->writer
= add
->writer
;
2245 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
2246 end
= &(*end
)->next
;
2253 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2254 references in list LIST conflict with it, excluding reads if ONLY writers
2258 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
2263 /* Avoid duplicate warnings. */
2264 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
2265 if (candidate_equal_p (tmp
->expr
, written
))
2270 if (candidate_equal_p (list
->expr
, written
)
2271 && !candidate_equal_p (list
->writer
, writer
)
2272 && (!only_writes
|| list
->writer
))
2274 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
2275 warning_at (EXPR_HAS_LOCATION (writer
)
2276 ? EXPR_LOCATION (writer
) : input_location
,
2277 OPT_Wsequence_point
, "operation on %qE may be undefined",
2284 /* Given a list LIST of references to variables, find whether any of these
2285 can cause conflicts due to missing sequence points. */
2288 warn_for_collisions (struct tlist
*list
)
2292 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
2295 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
2299 /* Return nonzero if X is a tree that can be verified by the sequence point
2302 warning_candidate_p (tree x
)
2304 /* !VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2305 (lvalue_p) crash on TRY/CATCH. */
2306 return !(DECL_P (x
) && DECL_ARTIFICIAL (x
))
2307 && TREE_TYPE (x
) && !VOID_TYPE_P (TREE_TYPE (x
)) && lvalue_p (x
);
2310 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2312 candidate_equal_p (const_tree x
, const_tree y
)
2314 return (x
== y
) || (x
&& y
&& operand_equal_p (x
, y
, 0));
2317 /* Walk the tree X, and record accesses to variables. If X is written by the
2318 parent tree, WRITER is the parent.
2319 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2320 expression or its only operand forces a sequence point, then everything up
2321 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2323 Once we return, we will have emitted warnings if any subexpression before
2324 such a sequence point could be undefined. On a higher level, however, the
2325 sequence point may not be relevant, and we'll merge the two lists.
2327 Example: (b++, a) + b;
2328 The call that processes the COMPOUND_EXPR will store the increment of B
2329 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2330 processes the PLUS_EXPR will need to merge the two lists so that
2331 eventually, all accesses end up on the same list (and we'll warn about the
2332 unordered subexpressions b++ and b.
2334 A note on merging. If we modify the former example so that our expression
2337 care must be taken not simply to add all three expressions into the final
2338 PNO_SP list. The function merge_tlist takes care of that by merging the
2339 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2340 way, so that no more than one access to B is recorded. */
2343 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
2346 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
2347 enum tree_code code
;
2348 enum tree_code_class cl
;
2350 /* X may be NULL if it is the operand of an empty statement expression
2356 code
= TREE_CODE (x
);
2357 cl
= TREE_CODE_CLASS (code
);
2359 if (warning_candidate_p (x
))
2360 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
2368 case TRUTH_ANDIF_EXPR
:
2369 case TRUTH_ORIF_EXPR
:
2370 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2371 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2372 warn_for_collisions (tmp_nosp
);
2373 merge_tlist (pbefore_sp
, tmp_before
, 0);
2374 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
2375 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
2376 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2380 tmp_before
= tmp_list2
= 0;
2381 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
2382 warn_for_collisions (tmp_list2
);
2383 merge_tlist (pbefore_sp
, tmp_before
, 0);
2384 merge_tlist (pbefore_sp
, tmp_list2
, 1);
2386 tmp_list3
= tmp_nosp
= 0;
2387 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
2388 warn_for_collisions (tmp_nosp
);
2389 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2391 tmp_list3
= tmp_list2
= 0;
2392 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
2393 warn_for_collisions (tmp_list2
);
2394 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2395 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2396 two first, to avoid warning for (a ? b++ : b++). */
2397 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
2398 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2401 case PREDECREMENT_EXPR
:
2402 case PREINCREMENT_EXPR
:
2403 case POSTDECREMENT_EXPR
:
2404 case POSTINCREMENT_EXPR
:
2405 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
2409 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2410 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2411 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
2412 /* Expressions inside the LHS are not ordered wrt. the sequence points
2413 in the RHS. Example:
2415 Despite the fact that the modification of "a" is in the before_sp
2416 list (tmp_before), it conflicts with the use of "a" in the LHS.
2417 We can handle this by adding the contents of tmp_list3
2418 to those of tmp_before, and redoing the collision warnings for that
2420 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
2421 warn_for_collisions (tmp_before
);
2422 /* Exclude the LHS itself here; we first have to merge it into the
2423 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2424 didn't exclude the LHS, we'd get it twice, once as a read and once
2426 add_tlist (pno_sp
, tmp_list3
, x
, 0);
2427 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
2429 merge_tlist (pbefore_sp
, tmp_before
, 0);
2430 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
2431 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
2432 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
2436 /* We need to warn about conflicts among arguments and conflicts between
2437 args and the function address. Side effects of the function address,
2438 however, are not ordered by the sequence point of the call. */
2440 call_expr_arg_iterator iter
;
2442 tmp_before
= tmp_nosp
= 0;
2443 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2444 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
2446 tmp_list2
= tmp_list3
= 0;
2447 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
2448 merge_tlist (&tmp_list3
, tmp_list2
, 0);
2449 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
2451 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
2452 warn_for_collisions (tmp_before
);
2453 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
2458 /* Scan all the list, e.g. indices of multi dimensional array. */
2461 tmp_before
= tmp_nosp
= 0;
2462 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2463 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2464 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2471 struct tlist_cache
*t
;
2472 for (t
= save_expr_cache
; t
; t
= t
->next
)
2473 if (candidate_equal_p (t
->expr
, x
))
2478 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
2479 t
->next
= save_expr_cache
;
2481 save_expr_cache
= t
;
2483 tmp_before
= tmp_nosp
= 0;
2484 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2485 warn_for_collisions (tmp_nosp
);
2490 struct tlist
*t
= tmp_nosp
;
2492 merge_tlist (&tmp_list3
, t
, 0);
2494 t
->cache_before_sp
= tmp_before
;
2495 t
->cache_after_sp
= tmp_list3
;
2497 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
2498 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
2503 x
= TREE_OPERAND (x
, 0);
2510 /* For other expressions, simply recurse on their operands.
2511 Manual tail recursion for unary expressions.
2512 Other non-expressions need not be processed. */
2513 if (cl
== tcc_unary
)
2515 x
= TREE_OPERAND (x
, 0);
2519 else if (IS_EXPR_CODE_CLASS (cl
))
2522 int max
= TREE_OPERAND_LENGTH (x
);
2523 for (lp
= 0; lp
< max
; lp
++)
2525 tmp_before
= tmp_nosp
= 0;
2526 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
2527 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2528 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2535 /* Try to warn for undefined behavior in EXPR due to missing sequence
2539 verify_sequence_points (tree expr
)
2541 struct tlist
*before_sp
= 0, *after_sp
= 0;
2544 save_expr_cache
= 0;
2545 if (tlist_firstobj
== 0)
2547 gcc_obstack_init (&tlist_obstack
);
2548 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
2551 verify_tree (expr
, &before_sp
, &after_sp
, 0);
2552 warn_for_collisions (after_sp
);
2553 obstack_free (&tlist_obstack
, tlist_firstobj
);
2556 /* Validate the expression after `case' and apply default promotions. */
2559 check_case_value (tree value
)
2561 if (value
== NULL_TREE
)
2564 /* ??? Can we ever get nops here for a valid case value? We
2566 STRIP_TYPE_NOPS (value
);
2567 /* In C++, the following is allowed:
2570 switch (...) { case i: ... }
2572 So, we try to reduce the VALUE to a constant that way. */
2573 if (c_dialect_cxx ())
2575 value
= decl_constant_value (value
);
2576 STRIP_TYPE_NOPS (value
);
2577 value
= fold (value
);
2580 if (TREE_CODE (value
) == INTEGER_CST
)
2581 /* Promote char or short to int. */
2582 value
= perform_integral_promotions (value
);
2583 else if (value
!= error_mark_node
)
2585 error ("case label does not reduce to an integer constant");
2586 value
= error_mark_node
;
2589 constant_expression_warning (value
);
2594 /* See if the case values LOW and HIGH are in the range of the original
2595 type (i.e. before the default conversion to int) of the switch testing
2597 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2598 the type before promoting it. CASE_LOW_P is a pointer to the lower
2599 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2600 if the case is not a case range.
2601 The caller has to make sure that we are not called with NULL for
2602 CASE_LOW_P (i.e. the default case).
2603 Returns true if the case label is in range of ORIG_TYPE (saturated or
2604 untouched) or false if the label is out of range. */
2607 check_case_bounds (tree type
, tree orig_type
,
2608 tree
*case_low_p
, tree
*case_high_p
)
2610 tree min_value
, max_value
;
2611 tree case_low
= *case_low_p
;
2612 tree case_high
= case_high_p
? *case_high_p
: case_low
;
2614 /* If there was a problem with the original type, do nothing. */
2615 if (orig_type
== error_mark_node
)
2618 min_value
= TYPE_MIN_VALUE (orig_type
);
2619 max_value
= TYPE_MAX_VALUE (orig_type
);
2621 /* Case label is less than minimum for type. */
2622 if (tree_int_cst_compare (case_low
, min_value
) < 0
2623 && tree_int_cst_compare (case_high
, min_value
) < 0)
2625 warning (0, "case label value is less than minimum value for type");
2629 /* Case value is greater than maximum for type. */
2630 if (tree_int_cst_compare (case_low
, max_value
) > 0
2631 && tree_int_cst_compare (case_high
, max_value
) > 0)
2633 warning (0, "case label value exceeds maximum value for type");
2637 /* Saturate lower case label value to minimum. */
2638 if (tree_int_cst_compare (case_high
, min_value
) >= 0
2639 && tree_int_cst_compare (case_low
, min_value
) < 0)
2641 warning (0, "lower value in case label range"
2642 " less than minimum value for type");
2643 case_low
= min_value
;
2646 /* Saturate upper case label value to maximum. */
2647 if (tree_int_cst_compare (case_low
, max_value
) <= 0
2648 && tree_int_cst_compare (case_high
, max_value
) > 0)
2650 warning (0, "upper value in case label range"
2651 " exceeds maximum value for type");
2652 case_high
= max_value
;
2655 if (*case_low_p
!= case_low
)
2656 *case_low_p
= convert (type
, case_low
);
2657 if (case_high_p
&& *case_high_p
!= case_high
)
2658 *case_high_p
= convert (type
, case_high
);
2663 /* Return an integer type with BITS bits of precision,
2664 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2667 c_common_type_for_size (unsigned int bits
, int unsignedp
)
2669 if (bits
== TYPE_PRECISION (integer_type_node
))
2670 return unsignedp
? unsigned_type_node
: integer_type_node
;
2672 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2673 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2675 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2676 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2678 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2679 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2681 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2682 return (unsignedp
? long_long_unsigned_type_node
2683 : long_long_integer_type_node
);
2685 if (int128_integer_type_node
2686 && bits
== TYPE_PRECISION (int128_integer_type_node
))
2687 return (unsignedp
? int128_unsigned_type_node
2688 : int128_integer_type_node
);
2690 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2691 return (unsignedp
? widest_unsigned_literal_type_node
2692 : widest_integer_literal_type_node
);
2694 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2695 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2697 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2698 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2700 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2701 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2703 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2704 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2709 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2710 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2711 and saturating if SATP is nonzero, otherwise not saturating. */
2714 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
2715 int unsignedp
, int satp
)
2717 enum machine_mode mode
;
2719 mode
= unsignedp
? UQQmode
: QQmode
;
2721 mode
= unsignedp
? UHAmode
: HAmode
;
2723 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
2724 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2727 if (mode
== VOIDmode
|| !targetm
.scalar_mode_supported_p (mode
))
2729 sorry ("GCC cannot support operators with integer types and "
2730 "fixed-point types that have too many integral and "
2731 "fractional bits together");
2735 return c_common_type_for_mode (mode
, satp
);
2738 /* Used for communication between c_common_type_for_mode and
2739 c_register_builtin_type. */
2740 static GTY(()) tree registered_builtin_types
;
2742 /* Return a data type that has machine mode MODE.
2743 If the mode is an integer,
2744 then UNSIGNEDP selects between signed and unsigned types.
2745 If the mode is a fixed-point mode,
2746 then UNSIGNEDP selects between saturating and nonsaturating types. */
2749 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
2753 if (mode
== TYPE_MODE (integer_type_node
))
2754 return unsignedp
? unsigned_type_node
: integer_type_node
;
2756 if (mode
== TYPE_MODE (signed_char_type_node
))
2757 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2759 if (mode
== TYPE_MODE (short_integer_type_node
))
2760 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2762 if (mode
== TYPE_MODE (long_integer_type_node
))
2763 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2765 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2766 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2768 if (int128_integer_type_node
2769 && mode
== TYPE_MODE (int128_integer_type_node
))
2770 return unsignedp
? int128_unsigned_type_node
: int128_integer_type_node
;
2772 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2773 return unsignedp
? widest_unsigned_literal_type_node
2774 : widest_integer_literal_type_node
;
2777 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2780 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2783 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2786 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2788 #if HOST_BITS_PER_WIDE_INT >= 64
2789 if (mode
== TYPE_MODE (intTI_type_node
))
2790 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2793 if (mode
== TYPE_MODE (float_type_node
))
2794 return float_type_node
;
2796 if (mode
== TYPE_MODE (double_type_node
))
2797 return double_type_node
;
2799 if (mode
== TYPE_MODE (long_double_type_node
))
2800 return long_double_type_node
;
2802 if (mode
== TYPE_MODE (void_type_node
))
2803 return void_type_node
;
2805 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2807 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2808 : make_signed_type (GET_MODE_PRECISION (mode
)));
2810 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2812 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2813 : make_signed_type (GET_MODE_PRECISION (mode
)));
2815 if (COMPLEX_MODE_P (mode
))
2817 enum machine_mode inner_mode
;
2820 if (mode
== TYPE_MODE (complex_float_type_node
))
2821 return complex_float_type_node
;
2822 if (mode
== TYPE_MODE (complex_double_type_node
))
2823 return complex_double_type_node
;
2824 if (mode
== TYPE_MODE (complex_long_double_type_node
))
2825 return complex_long_double_type_node
;
2827 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
2828 return complex_integer_type_node
;
2830 inner_mode
= GET_MODE_INNER (mode
);
2831 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2832 if (inner_type
!= NULL_TREE
)
2833 return build_complex_type (inner_type
);
2835 else if (VECTOR_MODE_P (mode
))
2837 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
2838 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2839 if (inner_type
!= NULL_TREE
)
2840 return build_vector_type_for_mode (inner_type
, mode
);
2843 if (mode
== TYPE_MODE (dfloat32_type_node
))
2844 return dfloat32_type_node
;
2845 if (mode
== TYPE_MODE (dfloat64_type_node
))
2846 return dfloat64_type_node
;
2847 if (mode
== TYPE_MODE (dfloat128_type_node
))
2848 return dfloat128_type_node
;
2850 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
2852 if (mode
== TYPE_MODE (short_fract_type_node
))
2853 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
2854 if (mode
== TYPE_MODE (fract_type_node
))
2855 return unsignedp
? sat_fract_type_node
: fract_type_node
;
2856 if (mode
== TYPE_MODE (long_fract_type_node
))
2857 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
2858 if (mode
== TYPE_MODE (long_long_fract_type_node
))
2859 return unsignedp
? sat_long_long_fract_type_node
2860 : long_long_fract_type_node
;
2862 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
2863 return unsignedp
? sat_unsigned_short_fract_type_node
2864 : unsigned_short_fract_type_node
;
2865 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
2866 return unsignedp
? sat_unsigned_fract_type_node
2867 : unsigned_fract_type_node
;
2868 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
2869 return unsignedp
? sat_unsigned_long_fract_type_node
2870 : unsigned_long_fract_type_node
;
2871 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
2872 return unsignedp
? sat_unsigned_long_long_fract_type_node
2873 : unsigned_long_long_fract_type_node
;
2875 if (mode
== TYPE_MODE (short_accum_type_node
))
2876 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
2877 if (mode
== TYPE_MODE (accum_type_node
))
2878 return unsignedp
? sat_accum_type_node
: accum_type_node
;
2879 if (mode
== TYPE_MODE (long_accum_type_node
))
2880 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
2881 if (mode
== TYPE_MODE (long_long_accum_type_node
))
2882 return unsignedp
? sat_long_long_accum_type_node
2883 : long_long_accum_type_node
;
2885 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
2886 return unsignedp
? sat_unsigned_short_accum_type_node
2887 : unsigned_short_accum_type_node
;
2888 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
2889 return unsignedp
? sat_unsigned_accum_type_node
2890 : unsigned_accum_type_node
;
2891 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
2892 return unsignedp
? sat_unsigned_long_accum_type_node
2893 : unsigned_long_accum_type_node
;
2894 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
2895 return unsignedp
? sat_unsigned_long_long_accum_type_node
2896 : unsigned_long_long_accum_type_node
;
2899 return unsignedp
? sat_qq_type_node
: qq_type_node
;
2901 return unsignedp
? sat_hq_type_node
: hq_type_node
;
2903 return unsignedp
? sat_sq_type_node
: sq_type_node
;
2905 return unsignedp
? sat_dq_type_node
: dq_type_node
;
2907 return unsignedp
? sat_tq_type_node
: tq_type_node
;
2909 if (mode
== UQQmode
)
2910 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
2911 if (mode
== UHQmode
)
2912 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
2913 if (mode
== USQmode
)
2914 return unsignedp
? sat_usq_type_node
: usq_type_node
;
2915 if (mode
== UDQmode
)
2916 return unsignedp
? sat_udq_type_node
: udq_type_node
;
2917 if (mode
== UTQmode
)
2918 return unsignedp
? sat_utq_type_node
: utq_type_node
;
2921 return unsignedp
? sat_ha_type_node
: ha_type_node
;
2923 return unsignedp
? sat_sa_type_node
: sa_type_node
;
2925 return unsignedp
? sat_da_type_node
: da_type_node
;
2927 return unsignedp
? sat_ta_type_node
: ta_type_node
;
2929 if (mode
== UHAmode
)
2930 return unsignedp
? sat_uha_type_node
: uha_type_node
;
2931 if (mode
== USAmode
)
2932 return unsignedp
? sat_usa_type_node
: usa_type_node
;
2933 if (mode
== UDAmode
)
2934 return unsignedp
? sat_uda_type_node
: uda_type_node
;
2935 if (mode
== UTAmode
)
2936 return unsignedp
? sat_uta_type_node
: uta_type_node
;
2939 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
2940 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
2941 return TREE_VALUE (t
);
2947 c_common_unsigned_type (tree type
)
2949 return c_common_signed_or_unsigned_type (1, type
);
2952 /* Return a signed type the same as TYPE in other respects. */
2955 c_common_signed_type (tree type
)
2957 return c_common_signed_or_unsigned_type (0, type
);
2960 /* Return a type the same as TYPE except unsigned or
2961 signed according to UNSIGNEDP. */
2964 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
2968 /* This block of code emulates the behavior of the old
2969 c_common_unsigned_type. In particular, it returns
2970 long_unsigned_type_node if passed a long, even when a int would
2971 have the same size. This is necessary for warnings to work
2972 correctly in archs where sizeof(int) == sizeof(long) */
2974 type1
= TYPE_MAIN_VARIANT (type
);
2975 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
2976 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2977 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2978 return unsignedp
? unsigned_type_node
: integer_type_node
;
2979 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2980 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2981 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2982 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2983 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
2984 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2985 if (int128_integer_type_node
2986 && (type1
== int128_integer_type_node
2987 || type1
== int128_unsigned_type_node
))
2988 return unsignedp
? int128_unsigned_type_node
: int128_integer_type_node
;
2989 if (type1
== widest_integer_literal_type_node
|| type1
== widest_unsigned_literal_type_node
)
2990 return unsignedp
? widest_unsigned_literal_type_node
: widest_integer_literal_type_node
;
2991 #if HOST_BITS_PER_WIDE_INT >= 64
2992 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2993 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2995 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2996 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2997 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2998 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2999 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
3000 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3001 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
3002 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3004 #define C_COMMON_FIXED_TYPES(NAME) \
3005 if (type1 == short_ ## NAME ## _type_node \
3006 || type1 == unsigned_short_ ## NAME ## _type_node) \
3007 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3008 : short_ ## NAME ## _type_node; \
3009 if (type1 == NAME ## _type_node \
3010 || type1 == unsigned_ ## NAME ## _type_node) \
3011 return unsignedp ? unsigned_ ## NAME ## _type_node \
3012 : NAME ## _type_node; \
3013 if (type1 == long_ ## NAME ## _type_node \
3014 || type1 == unsigned_long_ ## NAME ## _type_node) \
3015 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3016 : long_ ## NAME ## _type_node; \
3017 if (type1 == long_long_ ## NAME ## _type_node \
3018 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3019 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3020 : long_long_ ## NAME ## _type_node;
3022 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3023 if (type1 == NAME ## _type_node \
3024 || type1 == u ## NAME ## _type_node) \
3025 return unsignedp ? u ## NAME ## _type_node \
3026 : NAME ## _type_node;
3028 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3029 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3030 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3031 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3032 : sat_ ## short_ ## NAME ## _type_node; \
3033 if (type1 == sat_ ## NAME ## _type_node \
3034 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3035 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3036 : sat_ ## NAME ## _type_node; \
3037 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3038 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3039 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3040 : sat_ ## long_ ## NAME ## _type_node; \
3041 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3042 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3043 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3044 : sat_ ## long_long_ ## NAME ## _type_node;
3046 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3047 if (type1 == sat_ ## NAME ## _type_node \
3048 || type1 == sat_ ## u ## NAME ## _type_node) \
3049 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3050 : sat_ ## NAME ## _type_node;
3052 C_COMMON_FIXED_TYPES (fract
);
3053 C_COMMON_FIXED_TYPES_SAT (fract
);
3054 C_COMMON_FIXED_TYPES (accum
);
3055 C_COMMON_FIXED_TYPES_SAT (accum
);
3057 C_COMMON_FIXED_MODE_TYPES (qq
);
3058 C_COMMON_FIXED_MODE_TYPES (hq
);
3059 C_COMMON_FIXED_MODE_TYPES (sq
);
3060 C_COMMON_FIXED_MODE_TYPES (dq
);
3061 C_COMMON_FIXED_MODE_TYPES (tq
);
3062 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
3063 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
3064 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
3065 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
3066 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
3067 C_COMMON_FIXED_MODE_TYPES (ha
);
3068 C_COMMON_FIXED_MODE_TYPES (sa
);
3069 C_COMMON_FIXED_MODE_TYPES (da
);
3070 C_COMMON_FIXED_MODE_TYPES (ta
);
3071 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
3072 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
3073 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
3074 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
3076 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3077 the precision; they have precision set to match their range, but
3078 may use a wider mode to match an ABI. If we change modes, we may
3079 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3080 the precision as well, so as to yield correct results for
3081 bit-field types. C++ does not have these separate bit-field
3082 types, and producing a signed or unsigned variant of an
3083 ENUMERAL_TYPE may cause other problems as well. */
3085 if (!INTEGRAL_TYPE_P (type
)
3086 || TYPE_UNSIGNED (type
) == unsignedp
)
3089 #define TYPE_OK(node) \
3090 (TYPE_MODE (type) == TYPE_MODE (node) \
3091 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3092 if (TYPE_OK (signed_char_type_node
))
3093 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3094 if (TYPE_OK (integer_type_node
))
3095 return unsignedp
? unsigned_type_node
: integer_type_node
;
3096 if (TYPE_OK (short_integer_type_node
))
3097 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3098 if (TYPE_OK (long_integer_type_node
))
3099 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3100 if (TYPE_OK (long_long_integer_type_node
))
3101 return (unsignedp
? long_long_unsigned_type_node
3102 : long_long_integer_type_node
);
3103 if (int128_integer_type_node
&& TYPE_OK (int128_integer_type_node
))
3104 return (unsignedp
? int128_unsigned_type_node
3105 : int128_integer_type_node
);
3106 if (TYPE_OK (widest_integer_literal_type_node
))
3107 return (unsignedp
? widest_unsigned_literal_type_node
3108 : widest_integer_literal_type_node
);
3110 #if HOST_BITS_PER_WIDE_INT >= 64
3111 if (TYPE_OK (intTI_type_node
))
3112 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3114 if (TYPE_OK (intDI_type_node
))
3115 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3116 if (TYPE_OK (intSI_type_node
))
3117 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3118 if (TYPE_OK (intHI_type_node
))
3119 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3120 if (TYPE_OK (intQI_type_node
))
3121 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3124 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
3127 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3130 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
3132 /* Extended integer types of the same width as a standard type have
3133 lesser rank, so those of the same width as int promote to int or
3134 unsigned int and are valid for printf formats expecting int or
3135 unsigned int. To avoid such special cases, avoid creating
3136 extended integer types for bit-fields if a standard integer type
3138 if (width
== TYPE_PRECISION (integer_type_node
))
3139 return unsignedp
? unsigned_type_node
: integer_type_node
;
3140 if (width
== TYPE_PRECISION (signed_char_type_node
))
3141 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3142 if (width
== TYPE_PRECISION (short_integer_type_node
))
3143 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3144 if (width
== TYPE_PRECISION (long_integer_type_node
))
3145 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3146 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
3147 return (unsignedp
? long_long_unsigned_type_node
3148 : long_long_integer_type_node
);
3149 if (int128_integer_type_node
3150 && width
== TYPE_PRECISION (int128_integer_type_node
))
3151 return (unsignedp
? int128_unsigned_type_node
3152 : int128_integer_type_node
);
3153 return build_nonstandard_integer_type (width
, unsignedp
);
3156 /* The C version of the register_builtin_type langhook. */
3159 c_register_builtin_type (tree type
, const char* name
)
3163 decl
= build_decl (UNKNOWN_LOCATION
,
3164 TYPE_DECL
, get_identifier (name
), type
);
3165 DECL_ARTIFICIAL (decl
) = 1;
3166 if (!TYPE_NAME (type
))
3167 TYPE_NAME (type
) = decl
;
3170 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
3173 /* Print an error message for invalid operands to arith operation
3174 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3175 LOCATION is the location of the message. */
3178 binary_op_error (location_t location
, enum tree_code code
,
3179 tree type0
, tree type1
)
3186 opname
= "+"; break;
3188 opname
= "-"; break;
3190 opname
= "*"; break;
3192 opname
= "max"; break;
3194 opname
= "min"; break;
3196 opname
= "=="; break;
3198 opname
= "!="; break;
3200 opname
= "<="; break;
3202 opname
= ">="; break;
3204 opname
= "<"; break;
3206 opname
= ">"; break;
3208 opname
= "<<"; break;
3210 opname
= ">>"; break;
3211 case TRUNC_MOD_EXPR
:
3212 case FLOOR_MOD_EXPR
:
3213 opname
= "%"; break;
3214 case TRUNC_DIV_EXPR
:
3215 case FLOOR_DIV_EXPR
:
3216 opname
= "/"; break;
3218 opname
= "&"; break;
3220 opname
= "|"; break;
3221 case TRUTH_ANDIF_EXPR
:
3222 opname
= "&&"; break;
3223 case TRUTH_ORIF_EXPR
:
3224 opname
= "||"; break;
3226 opname
= "^"; break;
3231 "invalid operands to binary %s (have %qT and %qT)", opname
,
3235 /* Subroutine of build_binary_op, used for comparison operations.
3236 See if the operands have both been converted from subword integer types
3237 and, if so, perhaps change them both back to their original type.
3238 This function is also responsible for converting the two operands
3239 to the proper common type for comparison.
3241 The arguments of this function are all pointers to local variables
3242 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3243 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3245 If this function returns nonzero, it means that the comparison has
3246 a constant value. What this function returns is an expression for
3250 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
3251 enum tree_code
*rescode_ptr
)
3254 tree op0
= *op0_ptr
;
3255 tree op1
= *op1_ptr
;
3256 int unsignedp0
, unsignedp1
;
3258 tree primop0
, primop1
;
3259 enum tree_code code
= *rescode_ptr
;
3261 /* Throw away any conversions to wider types
3262 already present in the operands. */
3264 primop0
= get_narrower (op0
, &unsignedp0
);
3265 primop1
= get_narrower (op1
, &unsignedp1
);
3267 /* Handle the case that OP0 does not *contain* a conversion
3268 but it *requires* conversion to FINAL_TYPE. */
3270 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
3271 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
3272 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
3273 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
3275 /* If one of the operands must be floated, we cannot optimize. */
3276 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
3277 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
3279 /* If first arg is constant, swap the args (changing operation
3280 so value is preserved), for canonicalization. Don't do this if
3281 the second arg is 0. */
3283 if (TREE_CONSTANT (primop0
)
3284 && !integer_zerop (primop1
) && !real_zerop (primop1
)
3285 && !fixed_zerop (primop1
))
3288 int temi
= unsignedp0
;
3296 unsignedp0
= unsignedp1
;
3319 *rescode_ptr
= code
;
3322 /* If comparing an integer against a constant more bits wide,
3323 maybe we can deduce a value of 1 or 0 independent of the data.
3324 Or else truncate the constant now
3325 rather than extend the variable at run time.
3327 This is only interesting if the constant is the wider arg.
3328 Also, it is not safe if the constant is unsigned and the
3329 variable arg is signed, since in this case the variable
3330 would be sign-extended and then regarded as unsigned.
3331 Our technique fails in this case because the lowest/highest
3332 possible unsigned results don't follow naturally from the
3333 lowest/highest possible values of the variable operand.
3334 For just EQ_EXPR and NE_EXPR there is another technique that
3335 could be used: see if the constant can be faithfully represented
3336 in the other operand's type, by truncating it and reextending it
3337 and see if that preserves the constant's value. */
3339 if (!real1
&& !real2
3340 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
3341 && TREE_CODE (primop1
) == INTEGER_CST
3342 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
3344 int min_gt
, max_gt
, min_lt
, max_lt
;
3345 tree maxval
, minval
;
3346 /* 1 if comparison is nominally unsigned. */
3347 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
3350 type
= c_common_signed_or_unsigned_type (unsignedp0
,
3351 TREE_TYPE (primop0
));
3353 maxval
= TYPE_MAX_VALUE (type
);
3354 minval
= TYPE_MIN_VALUE (type
);
3356 if (unsignedp
&& !unsignedp0
)
3357 *restype_ptr
= c_common_signed_type (*restype_ptr
);
3359 if (TREE_TYPE (primop1
) != *restype_ptr
)
3361 /* Convert primop1 to target type, but do not introduce
3362 additional overflow. We know primop1 is an int_cst. */
3363 primop1
= force_fit_type_double (*restype_ptr
,
3364 tree_to_double_int (primop1
),
3365 0, TREE_OVERFLOW (primop1
));
3367 if (type
!= *restype_ptr
)
3369 minval
= convert (*restype_ptr
, minval
);
3370 maxval
= convert (*restype_ptr
, maxval
);
3373 if (unsignedp
&& unsignedp0
)
3375 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
3376 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
3377 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
3378 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
3382 min_gt
= INT_CST_LT (primop1
, minval
);
3383 max_gt
= INT_CST_LT (primop1
, maxval
);
3384 min_lt
= INT_CST_LT (minval
, primop1
);
3385 max_lt
= INT_CST_LT (maxval
, primop1
);
3389 /* This used to be a switch, but Genix compiler can't handle that. */
3390 if (code
== NE_EXPR
)
3392 if (max_lt
|| min_gt
)
3393 val
= truthvalue_true_node
;
3395 else if (code
== EQ_EXPR
)
3397 if (max_lt
|| min_gt
)
3398 val
= truthvalue_false_node
;
3400 else if (code
== LT_EXPR
)
3403 val
= truthvalue_true_node
;
3405 val
= truthvalue_false_node
;
3407 else if (code
== GT_EXPR
)
3410 val
= truthvalue_true_node
;
3412 val
= truthvalue_false_node
;
3414 else if (code
== LE_EXPR
)
3417 val
= truthvalue_true_node
;
3419 val
= truthvalue_false_node
;
3421 else if (code
== GE_EXPR
)
3424 val
= truthvalue_true_node
;
3426 val
= truthvalue_false_node
;
3429 /* If primop0 was sign-extended and unsigned comparison specd,
3430 we did a signed comparison above using the signed type bounds.
3431 But the comparison we output must be unsigned.
3433 Also, for inequalities, VAL is no good; but if the signed
3434 comparison had *any* fixed result, it follows that the
3435 unsigned comparison just tests the sign in reverse
3436 (positive values are LE, negative ones GE).
3437 So we can generate an unsigned comparison
3438 against an extreme value of the signed type. */
3440 if (unsignedp
&& !unsignedp0
)
3447 primop1
= TYPE_MIN_VALUE (type
);
3453 primop1
= TYPE_MAX_VALUE (type
);
3460 type
= c_common_unsigned_type (type
);
3463 if (TREE_CODE (primop0
) != INTEGER_CST
)
3465 if (val
== truthvalue_false_node
)
3466 warning (OPT_Wtype_limits
, "comparison is always false due to limited range of data type");
3467 if (val
== truthvalue_true_node
)
3468 warning (OPT_Wtype_limits
, "comparison is always true due to limited range of data type");
3473 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3474 if (TREE_SIDE_EFFECTS (primop0
))
3475 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
3479 /* Value is not predetermined, but do the comparison
3480 in the type of the operand that is not constant.
3481 TYPE is already properly set. */
3484 /* If either arg is decimal float and the other is float, find the
3485 proper common type to use for comparison. */
3486 else if (real1
&& real2
3487 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3488 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
3489 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3491 else if (real1
&& real2
3492 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3493 == TYPE_PRECISION (TREE_TYPE (primop1
))))
3494 type
= TREE_TYPE (primop0
);
3496 /* If args' natural types are both narrower than nominal type
3497 and both extend in the same manner, compare them
3498 in the type of the wider arg.
3499 Otherwise must actually extend both to the nominal
3500 common type lest different ways of extending
3502 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3504 else if (unsignedp0
== unsignedp1
&& real1
== real2
3505 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
3506 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
3508 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3509 type
= c_common_signed_or_unsigned_type (unsignedp0
3510 || TYPE_UNSIGNED (*restype_ptr
),
3512 /* Make sure shorter operand is extended the right way
3513 to match the longer operand. */
3515 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
3516 TREE_TYPE (primop0
)),
3519 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
3520 TREE_TYPE (primop1
)),
3525 /* Here we must do the comparison on the nominal type
3526 using the args exactly as we received them. */
3527 type
= *restype_ptr
;
3531 if (!real1
&& !real2
&& integer_zerop (primop1
)
3532 && TYPE_UNSIGNED (*restype_ptr
))
3538 /* All unsigned values are >= 0, so we warn. However,
3539 if OP0 is a constant that is >= 0, the signedness of
3540 the comparison isn't an issue, so suppress the
3542 if (warn_type_limits
&& !in_system_header
3543 && !(TREE_CODE (primop0
) == INTEGER_CST
3544 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3546 warning (OPT_Wtype_limits
,
3547 "comparison of unsigned expression >= 0 is always true");
3548 value
= truthvalue_true_node
;
3552 if (warn_type_limits
&& !in_system_header
3553 && !(TREE_CODE (primop0
) == INTEGER_CST
3554 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3556 warning (OPT_Wtype_limits
,
3557 "comparison of unsigned expression < 0 is always false");
3558 value
= truthvalue_false_node
;
3567 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3568 if (TREE_SIDE_EFFECTS (primop0
))
3569 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3576 *op0_ptr
= convert (type
, primop0
);
3577 *op1_ptr
= convert (type
, primop1
);
3579 *restype_ptr
= truthvalue_type_node
;
3584 /* Return a tree for the sum or difference (RESULTCODE says which)
3585 of pointer PTROP and integer INTOP. */
3588 pointer_int_sum (location_t loc
, enum tree_code resultcode
,
3589 tree ptrop
, tree intop
)
3593 /* The result is a pointer of the same type that is being added. */
3594 tree result_type
= TREE_TYPE (ptrop
);
3596 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3598 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3599 "pointer of type %<void *%> used in arithmetic");
3600 size_exp
= integer_one_node
;
3602 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3604 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3605 "pointer to a function used in arithmetic");
3606 size_exp
= integer_one_node
;
3608 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3610 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3611 "pointer to member function used in arithmetic");
3612 size_exp
= integer_one_node
;
3615 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3617 /* We are manipulating pointer values, so we don't need to warn
3618 about relying on undefined signed overflow. We disable the
3619 warning here because we use integer types so fold won't know that
3620 they are really pointers. */
3621 fold_defer_overflow_warnings ();
3623 /* If what we are about to multiply by the size of the elements
3624 contains a constant term, apply distributive law
3625 and multiply that constant term separately.
3626 This helps produce common subexpressions. */
3627 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3628 && !TREE_CONSTANT (intop
)
3629 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3630 && TREE_CONSTANT (size_exp
)
3631 /* If the constant comes from pointer subtraction,
3632 skip this optimization--it would cause an error. */
3633 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
3634 /* If the constant is unsigned, and smaller than the pointer size,
3635 then we must skip this optimization. This is because it could cause
3636 an overflow error if the constant is negative but INTOP is not. */
3637 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
3638 || (TYPE_PRECISION (TREE_TYPE (intop
))
3639 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
3641 enum tree_code subcode
= resultcode
;
3642 tree int_type
= TREE_TYPE (intop
);
3643 if (TREE_CODE (intop
) == MINUS_EXPR
)
3644 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3645 /* Convert both subexpression types to the type of intop,
3646 because weird cases involving pointer arithmetic
3647 can result in a sum or difference with different type args. */
3648 ptrop
= build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop
, 1)),
3650 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
3651 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
3654 /* Convert the integer argument to a type the same size as sizetype
3655 so the multiply won't overflow spuriously. */
3656 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
3657 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
3658 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
3659 TYPE_UNSIGNED (sizetype
)), intop
);
3661 /* Replace the integer argument with a suitable product by the object size.
3662 Do this multiplication as signed, then convert to the appropriate type
3663 for the pointer operation and disregard an overflow that occured only
3664 because of the sign-extension change in the latter conversion. */
3666 tree t
= build_binary_op (loc
,
3668 convert (TREE_TYPE (intop
), size_exp
), 1);
3669 intop
= convert (sizetype
, t
);
3670 if (TREE_OVERFLOW_P (intop
) && !TREE_OVERFLOW (t
))
3671 intop
= build_int_cst_wide (TREE_TYPE (intop
), TREE_INT_CST_LOW (intop
),
3672 TREE_INT_CST_HIGH (intop
));
3675 /* Create the sum or difference. */
3676 if (resultcode
== MINUS_EXPR
)
3677 intop
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, intop
);
3679 ret
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, result_type
, ptrop
, intop
);
3681 fold_undefer_and_ignore_overflow_warnings ();
3686 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3687 and if NON_CONST is known not to be permitted in an evaluated part
3688 of a constant expression. */
3691 c_wrap_maybe_const (tree expr
, bool non_const
)
3693 bool nowarning
= TREE_NO_WARNING (expr
);
3694 location_t loc
= EXPR_LOCATION (expr
);
3696 /* This should never be called for C++. */
3697 if (c_dialect_cxx ())
3700 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3701 STRIP_TYPE_NOPS (expr
);
3702 expr
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL
, expr
);
3703 C_MAYBE_CONST_EXPR_NON_CONST (expr
) = non_const
;
3705 TREE_NO_WARNING (expr
) = 1;
3706 protected_set_expr_location (expr
, loc
);
3711 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3712 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3713 around the SAVE_EXPR if needed so that c_fully_fold does not need
3714 to look inside SAVE_EXPRs. */
3717 c_save_expr (tree expr
)
3719 bool maybe_const
= true;
3720 if (c_dialect_cxx ())
3721 return save_expr (expr
);
3722 expr
= c_fully_fold (expr
, false, &maybe_const
);
3723 expr
= save_expr (expr
);
3725 expr
= c_wrap_maybe_const (expr
, true);
3729 /* Return whether EXPR is a declaration whose address can never be
3733 decl_with_nonnull_addr_p (const_tree expr
)
3735 return (DECL_P (expr
)
3736 && (TREE_CODE (expr
) == PARM_DECL
3737 || TREE_CODE (expr
) == LABEL_DECL
3738 || !DECL_WEAK (expr
)));
3741 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3742 or for an `if' or `while' statement or ?..: exp. It should already
3743 have been validated to be of suitable type; otherwise, a bad
3744 diagnostic may result.
3746 The EXPR is located at LOCATION.
3748 This preparation consists of taking the ordinary
3749 representation of an expression expr and producing a valid tree
3750 boolean expression describing whether expr is nonzero. We could
3751 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3752 but we optimize comparisons, &&, ||, and !.
3754 The resulting type should always be `truthvalue_type_node'. */
3757 c_common_truthvalue_conversion (location_t location
, tree expr
)
3759 switch (TREE_CODE (expr
))
3761 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
3762 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3763 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
3764 case ORDERED_EXPR
: case UNORDERED_EXPR
:
3765 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3767 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3768 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
3771 case TRUTH_ANDIF_EXPR
:
3772 case TRUTH_ORIF_EXPR
:
3773 case TRUTH_AND_EXPR
:
3775 case TRUTH_XOR_EXPR
:
3776 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3778 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3779 c_common_truthvalue_conversion (location
,
3780 TREE_OPERAND (expr
, 0)),
3781 c_common_truthvalue_conversion (location
,
3782 TREE_OPERAND (expr
, 1)));
3785 case TRUTH_NOT_EXPR
:
3786 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3788 expr
= build1 (TREE_CODE (expr
), truthvalue_type_node
,
3789 c_common_truthvalue_conversion (location
,
3790 TREE_OPERAND (expr
, 0)));
3797 return integer_zerop (expr
) ? truthvalue_false_node
3798 : truthvalue_true_node
;
3801 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3802 ? truthvalue_true_node
3803 : truthvalue_false_node
;
3806 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3807 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3808 ? truthvalue_true_node
3809 : truthvalue_false_node
;
3812 expr
= build_unary_op (location
, ADDR_EXPR
, expr
, 0);
3817 tree inner
= TREE_OPERAND (expr
, 0);
3818 if (decl_with_nonnull_addr_p (inner
))
3820 /* Common Ada/Pascal programmer's mistake. */
3821 warning_at (location
,
3823 "the address of %qD will always evaluate as %<true%>",
3825 return truthvalue_true_node
;
3831 expr
= build_binary_op (EXPR_LOCATION (expr
),
3832 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3833 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3834 c_common_truthvalue_conversion (location
,
3835 TREE_OPERAND (expr
, 0)),
3836 c_common_truthvalue_conversion (location
,
3837 TREE_OPERAND (expr
, 1)),
3844 case EXCESS_PRECISION_EXPR
:
3845 /* These don't change whether an object is nonzero or zero. */
3846 return c_common_truthvalue_conversion (location
, TREE_OPERAND (expr
, 0));
3850 /* These don't change whether an object is zero or nonzero, but
3851 we can't ignore them if their second arg has side-effects. */
3852 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3854 expr
= build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3855 TREE_OPERAND (expr
, 1),
3856 c_common_truthvalue_conversion
3857 (location
, TREE_OPERAND (expr
, 0)));
3861 return c_common_truthvalue_conversion (location
,
3862 TREE_OPERAND (expr
, 0));
3865 /* Distribute the conversion into the arms of a COND_EXPR. */
3866 if (c_dialect_cxx ())
3868 expr
= fold_build3_loc (location
, COND_EXPR
, truthvalue_type_node
,
3869 TREE_OPERAND (expr
, 0),
3870 c_common_truthvalue_conversion (location
,
3873 c_common_truthvalue_conversion (location
,
3880 /* Folding will happen later for C. */
3881 expr
= build3 (COND_EXPR
, truthvalue_type_node
,
3882 TREE_OPERAND (expr
, 0),
3883 c_common_truthvalue_conversion (location
,
3884 TREE_OPERAND (expr
, 1)),
3885 c_common_truthvalue_conversion (location
,
3886 TREE_OPERAND (expr
, 2)));
3891 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3892 since that affects how `default_conversion' will behave. */
3893 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
3894 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
3896 /* If this is widening the argument, we can ignore it. */
3897 if (TYPE_PRECISION (TREE_TYPE (expr
))
3898 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
3899 return c_common_truthvalue_conversion (location
,
3900 TREE_OPERAND (expr
, 0));
3904 if (!TREE_NO_WARNING (expr
)
3905 && warn_parentheses
)
3907 warning (OPT_Wparentheses
,
3908 "suggest parentheses around assignment used as truth value");
3909 TREE_NO_WARNING (expr
) = 1;
3917 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
3919 tree t
= c_save_expr (expr
);
3920 expr
= (build_binary_op
3921 (EXPR_LOCATION (expr
),
3922 (TREE_SIDE_EFFECTS (expr
)
3923 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3924 c_common_truthvalue_conversion
3926 build_unary_op (location
, REALPART_EXPR
, t
, 0)),
3927 c_common_truthvalue_conversion
3929 build_unary_op (location
, IMAGPART_EXPR
, t
, 0)),
3934 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
3936 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
3938 (TREE_TYPE (expr
))));
3939 return build_binary_op (location
, NE_EXPR
, expr
, fixed_zero_node
, 1);
3942 return build_binary_op (location
, NE_EXPR
, expr
, integer_zero_node
, 1);
3945 protected_set_expr_location (expr
, location
);
3949 static void def_builtin_1 (enum built_in_function fncode
,
3951 enum built_in_class fnclass
,
3952 tree fntype
, tree libtype
,
3953 bool both_p
, bool fallback_p
, bool nonansi_p
,
3954 tree fnattrs
, bool implicit_p
);
3957 /* Apply the TYPE_QUALS to the new DECL. */
3960 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
3962 tree type
= TREE_TYPE (decl
);
3964 if (type
== error_mark_node
)
3967 if (((type_quals
& TYPE_QUAL_CONST
)
3968 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
3969 /* An object declared 'const' is only readonly after it is
3970 initialized. We don't have any way of expressing this currently,
3971 so we need to be conservative and unset TREE_READONLY for types
3972 with constructors. Otherwise aliasing code will ignore stores in
3973 an inline constructor. */
3974 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
3975 TREE_READONLY (decl
) = 1;
3976 if (type_quals
& TYPE_QUAL_VOLATILE
)
3978 TREE_SIDE_EFFECTS (decl
) = 1;
3979 TREE_THIS_VOLATILE (decl
) = 1;
3981 if (type_quals
& TYPE_QUAL_RESTRICT
)
3983 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
3984 /* Allow 'restrict' on arrays of pointers.
3985 FIXME currently we just ignore it. */
3986 type
= TREE_TYPE (type
);
3988 || !POINTER_TYPE_P (type
)
3989 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
3990 error ("invalid use of %<restrict%>");
3994 /* Hash function for the problem of multiple type definitions in
3995 different files. This must hash all types that will compare
3996 equal via comptypes to the same value. In practice it hashes
3997 on some of the simple stuff and leaves the details to comptypes. */
4000 c_type_hash (const void *p
)
4004 const_tree
const t
= (const_tree
) p
;
4006 switch (TREE_CODE (t
))
4008 /* For pointers, hash on pointee type plus some swizzling. */
4010 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
4011 /* Hash on number of elements and total size. */
4014 t2
= TYPE_VALUES (t
);
4018 t2
= TYPE_FIELDS (t
);
4020 case QUAL_UNION_TYPE
:
4022 t2
= TYPE_FIELDS (t
);
4026 t2
= TYPE_FIELDS (t
);
4031 for (; t2
; t2
= TREE_CHAIN (t2
))
4033 /* We might have a VLA here. */
4034 if (TREE_CODE (TYPE_SIZE (t
)) != INTEGER_CST
)
4037 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
4038 return ((size
<< 24) | (i
<< shift
));
4041 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
4043 /* Return the typed-based alias set for T, which may be an expression
4044 or a type. Return -1 if we don't do anything special. */
4047 c_common_get_alias_set (tree t
)
4052 /* For VLAs, use the alias set of the element type rather than the
4053 default of alias set 0 for types compared structurally. */
4054 if (TYPE_P (t
) && TYPE_STRUCTURAL_EQUALITY_P (t
))
4056 if (TREE_CODE (t
) == ARRAY_TYPE
)
4057 return get_alias_set (TREE_TYPE (t
));
4061 /* Permit type-punning when accessing a union, provided the access
4062 is directly through the union. For example, this code does not
4063 permit taking the address of a union member and then storing
4064 through it. Even the type-punning allowed here is a GCC
4065 extension, albeit a common and useful one; the C standard says
4066 that such accesses have implementation-defined behavior. */
4068 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
4069 u
= TREE_OPERAND (u
, 0))
4070 if (TREE_CODE (u
) == COMPONENT_REF
4071 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
4074 /* That's all the expressions we handle specially. */
4078 /* The C standard guarantees that any object may be accessed via an
4079 lvalue that has character type. */
4080 if (t
== char_type_node
4081 || t
== signed_char_type_node
4082 || t
== unsigned_char_type_node
)
4085 /* The C standard specifically allows aliasing between signed and
4086 unsigned variants of the same type. We treat the signed
4087 variant as canonical. */
4088 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
4090 tree t1
= c_common_signed_type (t
);
4092 /* t1 == t can happen for boolean nodes which are always unsigned. */
4094 return get_alias_set (t1
);
4096 else if (POINTER_TYPE_P (t
))
4100 /* Unfortunately, there is no canonical form of a pointer type.
4101 In particular, if we have `typedef int I', then `int *', and
4102 `I *' are different types. So, we have to pick a canonical
4103 representative. We do this below.
4105 Technically, this approach is actually more conservative that
4106 it needs to be. In particular, `const int *' and `int *'
4107 should be in different alias sets, according to the C and C++
4108 standard, since their types are not the same, and so,
4109 technically, an `int **' and `const int **' cannot point at
4112 But, the standard is wrong. In particular, this code is
4117 const int* const* cipp = ipp;
4119 And, it doesn't make sense for that to be legal unless you
4120 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4121 the pointed-to types. This issue has been reported to the
4123 t1
= build_type_no_quals (t
);
4125 return get_alias_set (t1
);
4128 /* Handle the case of multiple type nodes referring to "the same" type,
4129 which occurs with IMA. These share an alias set. FIXME: Currently only
4130 C90 is handled. (In C99 type compatibility is not transitive, which
4131 complicates things mightily. The alias set splay trees can theoretically
4132 represent this, but insertion is tricky when you consider all the
4133 different orders things might arrive in.) */
4135 if (c_language
!= clk_c
|| flag_isoc99
)
4138 /* Save time if there's only one input file. */
4139 if (num_in_fnames
== 1)
4142 /* Pointers need special handling if they point to any type that
4143 needs special handling (below). */
4144 if (TREE_CODE (t
) == POINTER_TYPE
)
4147 /* Find bottom type under any nested POINTERs. */
4148 for (t2
= TREE_TYPE (t
);
4149 TREE_CODE (t2
) == POINTER_TYPE
;
4150 t2
= TREE_TYPE (t2
))
4152 if (TREE_CODE (t2
) != RECORD_TYPE
4153 && TREE_CODE (t2
) != ENUMERAL_TYPE
4154 && TREE_CODE (t2
) != QUAL_UNION_TYPE
4155 && TREE_CODE (t2
) != UNION_TYPE
)
4157 if (TYPE_SIZE (t2
) == 0)
4160 /* These are the only cases that need special handling. */
4161 if (TREE_CODE (t
) != RECORD_TYPE
4162 && TREE_CODE (t
) != ENUMERAL_TYPE
4163 && TREE_CODE (t
) != QUAL_UNION_TYPE
4164 && TREE_CODE (t
) != UNION_TYPE
4165 && TREE_CODE (t
) != POINTER_TYPE
)
4168 if (TYPE_SIZE (t
) == 0)
4171 /* Look up t in hash table. Only one of the compatible types within each
4172 alias set is recorded in the table. */
4173 if (!type_hash_table
)
4174 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
4175 (htab_eq
) lang_hooks
.types_compatible_p
,
4177 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
4180 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
4181 return TYPE_ALIAS_SET ((tree
)*slot
);
4184 /* Our caller will assign and record (in t) a new alias set; all we need
4185 to do is remember t in the hash table. */
4191 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4192 the second parameter indicates which OPERATOR is being applied.
4193 The COMPLAIN flag controls whether we should diagnose possibly
4194 ill-formed constructs or not. LOC is the location of the SIZEOF or
4198 c_sizeof_or_alignof_type (location_t loc
,
4199 tree type
, bool is_sizeof
, int complain
)
4201 const char *op_name
;
4203 enum tree_code type_code
= TREE_CODE (type
);
4205 op_name
= is_sizeof
? "sizeof" : "__alignof__";
4207 if (type_code
== FUNCTION_TYPE
)
4211 if (complain
&& (pedantic
|| warn_pointer_arith
))
4212 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4213 "invalid application of %<sizeof%> to a function type");
4215 return error_mark_node
;
4216 value
= size_one_node
;
4219 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
4221 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
4223 if (type_code
== VOID_TYPE
4224 && complain
&& (pedantic
|| warn_pointer_arith
))
4225 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4226 "invalid application of %qs to a void type", op_name
);
4228 return error_mark_node
;
4229 value
= size_one_node
;
4231 else if (!COMPLETE_TYPE_P (type
))
4234 error_at (loc
, "invalid application of %qs to incomplete type %qT ",
4236 return error_mark_node
;
4241 /* Convert in case a char is more than one unit. */
4242 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
4243 size_int (TYPE_PRECISION (char_type_node
)
4246 value
= size_int (TYPE_ALIGN_UNIT (type
));
4249 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4250 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4251 never happen. However, this node should really have type
4252 `size_t', which is just a typedef for an ordinary integer type. */
4253 value
= fold_convert_loc (loc
, size_type_node
, value
);
4254 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)));
4259 /* Implement the __alignof keyword: Return the minimum required
4260 alignment of EXPR, measured in bytes. For VAR_DECLs,
4261 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4262 from an "aligned" __attribute__ specification). LOC is the
4263 location of the ALIGNOF operator. */
4266 c_alignof_expr (location_t loc
, tree expr
)
4270 if (VAR_OR_FUNCTION_DECL_P (expr
))
4271 t
= size_int (DECL_ALIGN_UNIT (expr
));
4273 else if (TREE_CODE (expr
) == COMPONENT_REF
4274 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
4276 error_at (loc
, "%<__alignof%> applied to a bit-field");
4279 else if (TREE_CODE (expr
) == COMPONENT_REF
4280 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
4281 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
4283 else if (TREE_CODE (expr
) == INDIRECT_REF
)
4285 tree t
= TREE_OPERAND (expr
, 0);
4287 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4289 while (CONVERT_EXPR_P (t
)
4290 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
4294 t
= TREE_OPERAND (t
, 0);
4295 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4296 if (thisalign
> bestalign
)
4297 best
= t
, bestalign
= thisalign
;
4299 return c_alignof (loc
, TREE_TYPE (TREE_TYPE (best
)));
4302 return c_alignof (loc
, TREE_TYPE (expr
));
4304 return fold_convert_loc (loc
, size_type_node
, t
);
4307 /* Handle C and C++ default attributes. */
4309 enum built_in_attribute
4311 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4312 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4313 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4314 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4315 #include "builtin-attrs.def"
4316 #undef DEF_ATTR_NULL_TREE
4318 #undef DEF_ATTR_IDENT
4319 #undef DEF_ATTR_TREE_LIST
4323 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
4325 static void c_init_attributes (void);
4329 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4330 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4331 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4332 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4333 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4334 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4335 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4336 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4337 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4338 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4339 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4340 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4341 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4342 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4343 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4345 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4346 #include "builtin-types.def"
4347 #undef DEF_PRIMITIVE_TYPE
4348 #undef DEF_FUNCTION_TYPE_0
4349 #undef DEF_FUNCTION_TYPE_1
4350 #undef DEF_FUNCTION_TYPE_2
4351 #undef DEF_FUNCTION_TYPE_3
4352 #undef DEF_FUNCTION_TYPE_4
4353 #undef DEF_FUNCTION_TYPE_5
4354 #undef DEF_FUNCTION_TYPE_6
4355 #undef DEF_FUNCTION_TYPE_7
4356 #undef DEF_FUNCTION_TYPE_VAR_0
4357 #undef DEF_FUNCTION_TYPE_VAR_1
4358 #undef DEF_FUNCTION_TYPE_VAR_2
4359 #undef DEF_FUNCTION_TYPE_VAR_3
4360 #undef DEF_FUNCTION_TYPE_VAR_4
4361 #undef DEF_FUNCTION_TYPE_VAR_5
4362 #undef DEF_POINTER_TYPE
4366 typedef enum c_builtin_type builtin_type
;
4368 /* A temporary array for c_common_nodes_and_builtins. Used in
4369 communication with def_fn_type. */
4370 static tree builtin_types
[(int) BT_LAST
+ 1];
4372 /* A helper function for c_common_nodes_and_builtins. Build function type
4373 for DEF with return type RET and N arguments. If VAR is true, then the
4374 function should be variadic after those N arguments.
4376 Takes special care not to ICE if any of the types involved are
4377 error_mark_node, which indicates that said type is not in fact available
4378 (see builtin_type_for_size). In which case the function type as a whole
4379 should be error_mark_node. */
4382 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
4384 tree args
= NULL
, t
;
4389 for (i
= 0; i
< n
; ++i
)
4391 builtin_type a
= (builtin_type
) va_arg (list
, int);
4392 t
= builtin_types
[a
];
4393 if (t
== error_mark_node
)
4395 args
= tree_cons (NULL_TREE
, t
, args
);
4399 args
= nreverse (args
);
4401 args
= chainon (args
, void_list_node
);
4403 t
= builtin_types
[ret
];
4404 if (t
== error_mark_node
)
4406 t
= build_function_type (t
, args
);
4409 builtin_types
[def
] = t
;
4412 /* Build builtin functions common to both C and C++ language
4416 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
4418 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4419 builtin_types[ENUM] = VALUE;
4420 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4421 def_fn_type (ENUM, RETURN, 0, 0);
4422 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4423 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4424 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4425 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4426 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4427 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4428 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4429 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4430 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4431 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4432 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4434 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4435 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4437 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4438 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4439 def_fn_type (ENUM, RETURN, 1, 0);
4440 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4441 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4442 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4443 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4444 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4445 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4446 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4447 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4448 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4449 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4450 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4451 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4453 #include "builtin-types.def"
4455 #undef DEF_PRIMITIVE_TYPE
4456 #undef DEF_FUNCTION_TYPE_1
4457 #undef DEF_FUNCTION_TYPE_2
4458 #undef DEF_FUNCTION_TYPE_3
4459 #undef DEF_FUNCTION_TYPE_4
4460 #undef DEF_FUNCTION_TYPE_5
4461 #undef DEF_FUNCTION_TYPE_6
4462 #undef DEF_FUNCTION_TYPE_VAR_0
4463 #undef DEF_FUNCTION_TYPE_VAR_1
4464 #undef DEF_FUNCTION_TYPE_VAR_2
4465 #undef DEF_FUNCTION_TYPE_VAR_3
4466 #undef DEF_FUNCTION_TYPE_VAR_4
4467 #undef DEF_FUNCTION_TYPE_VAR_5
4468 #undef DEF_POINTER_TYPE
4469 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
4471 c_init_attributes ();
4473 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4474 NONANSI_P, ATTRS, IMPLICIT, COND) \
4476 def_builtin_1 (ENUM, NAME, CLASS, \
4477 builtin_types[(int) TYPE], \
4478 builtin_types[(int) LIBTYPE], \
4479 BOTH_P, FALLBACK_P, NONANSI_P, \
4480 built_in_attributes[(int) ATTRS], IMPLICIT);
4481 #include "builtins.def"
4484 targetm
.init_builtins ();
4486 build_common_builtin_nodes ();
4492 /* Like get_identifier, but avoid warnings about null arguments when
4493 the argument may be NULL for targets where GCC lacks stdint.h type
4497 c_get_ident (const char *id
)
4499 return get_identifier (id
);
4502 /* Build tree nodes and builtin functions common to both C and C++ language
4506 c_common_nodes_and_builtins (void)
4508 int char16_type_size
;
4509 int char32_type_size
;
4510 int wchar_type_size
;
4511 tree array_domain_type
;
4512 tree va_list_ref_type_node
;
4513 tree va_list_arg_type_node
;
4515 /* Define `int' and `char' first so that dbx will output them first. */
4516 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
4517 record_builtin_type (RID_CHAR
, "char", char_type_node
);
4519 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4520 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4521 but not C. Are the conditionals here needed? */
4522 if (c_dialect_cxx ())
4523 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
4524 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
4525 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
4526 record_builtin_type (RID_MAX
, "long unsigned int",
4527 long_unsigned_type_node
);
4528 if (int128_integer_type_node
!= NULL_TREE
)
4530 record_builtin_type (RID_INT128
, "__int128",
4531 int128_integer_type_node
);
4532 record_builtin_type (RID_MAX
, "__int128 unsigned",
4533 int128_unsigned_type_node
);
4535 if (c_dialect_cxx ())
4536 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
4537 record_builtin_type (RID_MAX
, "long long int",
4538 long_long_integer_type_node
);
4539 record_builtin_type (RID_MAX
, "long long unsigned int",
4540 long_long_unsigned_type_node
);
4541 if (c_dialect_cxx ())
4542 record_builtin_type (RID_MAX
, "long long unsigned",
4543 long_long_unsigned_type_node
);
4544 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
4545 record_builtin_type (RID_MAX
, "short unsigned int",
4546 short_unsigned_type_node
);
4547 if (c_dialect_cxx ())
4548 record_builtin_type (RID_MAX
, "unsigned short",
4549 short_unsigned_type_node
);
4551 /* Define both `signed char' and `unsigned char'. */
4552 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
4553 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
4555 /* These are types that c_common_type_for_size and
4556 c_common_type_for_mode use. */
4557 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4558 TYPE_DECL
, NULL_TREE
,
4560 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4561 TYPE_DECL
, NULL_TREE
,
4563 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4564 TYPE_DECL
, NULL_TREE
,
4566 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4567 TYPE_DECL
, NULL_TREE
,
4569 #if HOST_BITS_PER_WIDE_INT >= 64
4570 if (targetm
.scalar_mode_supported_p (TImode
))
4571 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4573 get_identifier ("__int128_t"),
4576 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4577 TYPE_DECL
, NULL_TREE
,
4578 unsigned_intQI_type_node
));
4579 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4580 TYPE_DECL
, NULL_TREE
,
4581 unsigned_intHI_type_node
));
4582 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4583 TYPE_DECL
, NULL_TREE
,
4584 unsigned_intSI_type_node
));
4585 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4586 TYPE_DECL
, NULL_TREE
,
4587 unsigned_intDI_type_node
));
4588 #if HOST_BITS_PER_WIDE_INT >= 64
4589 if (targetm
.scalar_mode_supported_p (TImode
))
4590 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4592 get_identifier ("__uint128_t"),
4593 unsigned_intTI_type_node
));
4596 /* Create the widest literal types. */
4597 widest_integer_literal_type_node
4598 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
4599 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4600 TYPE_DECL
, NULL_TREE
,
4601 widest_integer_literal_type_node
));
4603 widest_unsigned_literal_type_node
4604 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
4605 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4606 TYPE_DECL
, NULL_TREE
,
4607 widest_unsigned_literal_type_node
));
4609 /* `unsigned long' is the standard type for sizeof.
4610 Note that stddef.h uses `unsigned long',
4611 and this must agree, even if long and int are the same size. */
4613 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
4614 signed_size_type_node
= c_common_signed_type (size_type_node
);
4615 set_sizetype (size_type_node
);
4618 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
4620 build_common_tree_nodes_2 (flag_short_double
);
4622 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
4623 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
4624 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
4626 /* Only supported decimal floating point extension if the target
4627 actually supports underlying modes. */
4628 if (targetm
.scalar_mode_supported_p (SDmode
)
4629 && targetm
.scalar_mode_supported_p (DDmode
)
4630 && targetm
.scalar_mode_supported_p (TDmode
))
4632 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
4633 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
4634 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
4637 if (targetm
.fixed_point_supported_p ())
4639 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
4640 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
4641 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
4642 record_builtin_type (RID_MAX
, "long long _Fract",
4643 long_long_fract_type_node
);
4644 record_builtin_type (RID_MAX
, "unsigned short _Fract",
4645 unsigned_short_fract_type_node
);
4646 record_builtin_type (RID_MAX
, "unsigned _Fract",
4647 unsigned_fract_type_node
);
4648 record_builtin_type (RID_MAX
, "unsigned long _Fract",
4649 unsigned_long_fract_type_node
);
4650 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
4651 unsigned_long_long_fract_type_node
);
4652 record_builtin_type (RID_MAX
, "_Sat short _Fract",
4653 sat_short_fract_type_node
);
4654 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
4655 record_builtin_type (RID_MAX
, "_Sat long _Fract",
4656 sat_long_fract_type_node
);
4657 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
4658 sat_long_long_fract_type_node
);
4659 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
4660 sat_unsigned_short_fract_type_node
);
4661 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
4662 sat_unsigned_fract_type_node
);
4663 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
4664 sat_unsigned_long_fract_type_node
);
4665 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
4666 sat_unsigned_long_long_fract_type_node
);
4667 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
4668 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
4669 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
4670 record_builtin_type (RID_MAX
, "long long _Accum",
4671 long_long_accum_type_node
);
4672 record_builtin_type (RID_MAX
, "unsigned short _Accum",
4673 unsigned_short_accum_type_node
);
4674 record_builtin_type (RID_MAX
, "unsigned _Accum",
4675 unsigned_accum_type_node
);
4676 record_builtin_type (RID_MAX
, "unsigned long _Accum",
4677 unsigned_long_accum_type_node
);
4678 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
4679 unsigned_long_long_accum_type_node
);
4680 record_builtin_type (RID_MAX
, "_Sat short _Accum",
4681 sat_short_accum_type_node
);
4682 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
4683 record_builtin_type (RID_MAX
, "_Sat long _Accum",
4684 sat_long_accum_type_node
);
4685 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
4686 sat_long_long_accum_type_node
);
4687 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
4688 sat_unsigned_short_accum_type_node
);
4689 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
4690 sat_unsigned_accum_type_node
);
4691 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
4692 sat_unsigned_long_accum_type_node
);
4693 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
4694 sat_unsigned_long_long_accum_type_node
);
4698 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4700 get_identifier ("complex int"),
4701 complex_integer_type_node
));
4702 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4704 get_identifier ("complex float"),
4705 complex_float_type_node
));
4706 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4708 get_identifier ("complex double"),
4709 complex_double_type_node
));
4710 lang_hooks
.decls
.pushdecl
4711 (build_decl (UNKNOWN_LOCATION
,
4712 TYPE_DECL
, get_identifier ("complex long double"),
4713 complex_long_double_type_node
));
4715 if (c_dialect_cxx ())
4716 /* For C++, make fileptr_type_node a distinct void * type until
4717 FILE type is defined. */
4718 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
4720 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
4722 /* Set the TYPE_NAME for any variants that were built before
4723 record_builtin_type gave names to the built-in types. */
4725 tree void_name
= TYPE_NAME (void_type_node
);
4726 TYPE_NAME (void_type_node
) = NULL_TREE
;
4727 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
4729 TYPE_NAME (void_type_node
) = void_name
;
4732 /* This node must not be shared. */
4733 void_zero_node
= make_node (INTEGER_CST
);
4734 TREE_TYPE (void_zero_node
) = void_type_node
;
4736 void_list_node
= build_void_list_node ();
4738 /* Make a type to be the domain of a few array types
4739 whose domains don't really matter.
4740 200 is small enough that it always fits in size_t
4741 and large enough that it can hold most function names for the
4742 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4743 array_domain_type
= build_index_type (size_int (200));
4745 /* Make a type for arrays of characters.
4746 With luck nothing will ever really depend on the length of this
4748 char_array_type_node
4749 = build_array_type (char_type_node
, array_domain_type
);
4751 /* Likewise for arrays of ints. */
4753 = build_array_type (integer_type_node
, array_domain_type
);
4755 string_type_node
= build_pointer_type (char_type_node
);
4756 const_string_type_node
4757 = build_pointer_type (build_qualified_type
4758 (char_type_node
, TYPE_QUAL_CONST
));
4760 /* This is special for C++ so functions can be overloaded. */
4761 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
4762 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
4763 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
4764 underlying_wchar_type_node
= wchar_type_node
;
4765 if (c_dialect_cxx ())
4767 if (TYPE_UNSIGNED (wchar_type_node
))
4768 wchar_type_node
= make_unsigned_type (wchar_type_size
);
4770 wchar_type_node
= make_signed_type (wchar_type_size
);
4771 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
4774 /* This is for wide string constants. */
4775 wchar_array_type_node
4776 = build_array_type (wchar_type_node
, array_domain_type
);
4778 /* Define 'char16_t'. */
4779 char16_type_node
= get_identifier (CHAR16_TYPE
);
4780 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
4781 char16_type_size
= TYPE_PRECISION (char16_type_node
);
4782 if (c_dialect_cxx ())
4784 char16_type_node
= make_unsigned_type (char16_type_size
);
4786 if (cxx_dialect
== cxx0x
)
4787 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
4790 /* This is for UTF-16 string constants. */
4791 char16_array_type_node
4792 = build_array_type (char16_type_node
, array_domain_type
);
4794 /* Define 'char32_t'. */
4795 char32_type_node
= get_identifier (CHAR32_TYPE
);
4796 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
4797 char32_type_size
= TYPE_PRECISION (char32_type_node
);
4798 if (c_dialect_cxx ())
4800 char32_type_node
= make_unsigned_type (char32_type_size
);
4802 if (cxx_dialect
== cxx0x
)
4803 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
4806 /* This is for UTF-32 string constants. */
4807 char32_array_type_node
4808 = build_array_type (char32_type_node
, array_domain_type
);
4811 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
4814 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
4816 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
4818 if (SIG_ATOMIC_TYPE
)
4819 sig_atomic_type_node
=
4820 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE
)));
4823 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE
)));
4826 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE
)));
4829 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE
)));
4832 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE
)));
4835 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE
)));
4838 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE
)));
4840 c_uint32_type_node
=
4841 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE
)));
4843 c_uint64_type_node
=
4844 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE
)));
4845 if (INT_LEAST8_TYPE
)
4846 int_least8_type_node
=
4847 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE
)));
4848 if (INT_LEAST16_TYPE
)
4849 int_least16_type_node
=
4850 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE
)));
4851 if (INT_LEAST32_TYPE
)
4852 int_least32_type_node
=
4853 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE
)));
4854 if (INT_LEAST64_TYPE
)
4855 int_least64_type_node
=
4856 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE
)));
4857 if (UINT_LEAST8_TYPE
)
4858 uint_least8_type_node
=
4859 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE
)));
4860 if (UINT_LEAST16_TYPE
)
4861 uint_least16_type_node
=
4862 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE
)));
4863 if (UINT_LEAST32_TYPE
)
4864 uint_least32_type_node
=
4865 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE
)));
4866 if (UINT_LEAST64_TYPE
)
4867 uint_least64_type_node
=
4868 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE
)));
4870 int_fast8_type_node
=
4871 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE
)));
4872 if (INT_FAST16_TYPE
)
4873 int_fast16_type_node
=
4874 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE
)));
4875 if (INT_FAST32_TYPE
)
4876 int_fast32_type_node
=
4877 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE
)));
4878 if (INT_FAST64_TYPE
)
4879 int_fast64_type_node
=
4880 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE
)));
4881 if (UINT_FAST8_TYPE
)
4882 uint_fast8_type_node
=
4883 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE
)));
4884 if (UINT_FAST16_TYPE
)
4885 uint_fast16_type_node
=
4886 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE
)));
4887 if (UINT_FAST32_TYPE
)
4888 uint_fast32_type_node
=
4889 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE
)));
4890 if (UINT_FAST64_TYPE
)
4891 uint_fast64_type_node
=
4892 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE
)));
4895 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE
)));
4898 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE
)));
4900 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
4902 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
4903 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
4905 lang_hooks
.decls
.pushdecl
4906 (build_decl (UNKNOWN_LOCATION
,
4907 TYPE_DECL
, get_identifier ("__builtin_va_list"),
4908 va_list_type_node
));
4909 if (targetm
.enum_va_list_p
)
4915 for (l
= 0; targetm
.enum_va_list_p (l
, &pname
, &ptype
); ++l
)
4917 lang_hooks
.decls
.pushdecl
4918 (build_decl (UNKNOWN_LOCATION
,
4919 TYPE_DECL
, get_identifier (pname
),
4925 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4927 va_list_arg_type_node
= va_list_ref_type_node
=
4928 build_pointer_type (TREE_TYPE (va_list_type_node
));
4932 va_list_arg_type_node
= va_list_type_node
;
4933 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
4936 if (!flag_preprocess_only
)
4937 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
4939 main_identifier_node
= get_identifier ("main");
4941 /* Create the built-in __null node. It is important that this is
4943 null_node
= make_node (INTEGER_CST
);
4944 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
4946 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4947 memset (builtin_types
, 0, sizeof (builtin_types
));
4950 /* The number of named compound-literals generated thus far. */
4951 static GTY(()) int compound_literal_number
;
4953 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4956 set_compound_literal_name (tree decl
)
4959 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
4960 compound_literal_number
);
4961 compound_literal_number
++;
4962 DECL_NAME (decl
) = get_identifier (name
);
4966 build_va_arg (location_t loc
, tree expr
, tree type
)
4968 expr
= build1 (VA_ARG_EXPR
, type
, expr
);
4969 SET_EXPR_LOCATION (expr
, loc
);
4974 /* Linked list of disabled built-in functions. */
4976 typedef struct disabled_builtin
4979 struct disabled_builtin
*next
;
4981 static disabled_builtin
*disabled_builtins
= NULL
;
4983 static bool builtin_function_disabled_p (const char *);
4985 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4986 begins with "__builtin_", give an error. */
4989 disable_builtin_function (const char *name
)
4991 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
4992 error ("cannot disable built-in function %qs", name
);
4995 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
4996 new_disabled_builtin
->name
= name
;
4997 new_disabled_builtin
->next
= disabled_builtins
;
4998 disabled_builtins
= new_disabled_builtin
;
5003 /* Return true if the built-in function NAME has been disabled, false
5007 builtin_function_disabled_p (const char *name
)
5009 disabled_builtin
*p
;
5010 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
5012 if (strcmp (name
, p
->name
) == 0)
5019 /* Worker for DEF_BUILTIN.
5020 Possibly define a builtin function with one or two names.
5021 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5022 nonansi_p and flag_no_nonansi_builtin. */
5025 def_builtin_1 (enum built_in_function fncode
,
5027 enum built_in_class fnclass
,
5028 tree fntype
, tree libtype
,
5029 bool both_p
, bool fallback_p
, bool nonansi_p
,
5030 tree fnattrs
, bool implicit_p
)
5033 const char *libname
;
5035 if (fntype
== error_mark_node
)
5038 gcc_assert ((!both_p
&& !fallback_p
)
5039 || !strncmp (name
, "__builtin_",
5040 strlen ("__builtin_")));
5042 libname
= name
+ strlen ("__builtin_");
5043 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
5044 (fallback_p
? libname
: NULL
),
5047 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
5048 && !(nonansi_p
&& flag_no_nonansi_builtin
))
5049 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
5052 built_in_decls
[(int) fncode
] = decl
;
5054 implicit_built_in_decls
[(int) fncode
] = decl
;
5057 /* Nonzero if the type T promotes to int. This is (nearly) the
5058 integral promotions defined in ISO C99 6.3.1.1/2. */
5061 c_promoting_integer_type_p (const_tree t
)
5063 switch (TREE_CODE (t
))
5066 return (TYPE_MAIN_VARIANT (t
) == char_type_node
5067 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
5068 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
5069 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
5070 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
5071 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
5074 /* ??? Technically all enumerations not larger than an int
5075 promote to an int. But this is used along code paths
5076 that only want to notice a size change. */
5077 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
5087 /* Return 1 if PARMS specifies a fixed number of parameters
5088 and none of their types is affected by default promotions. */
5091 self_promoting_args_p (const_tree parms
)
5094 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
5096 tree type
= TREE_VALUE (t
);
5098 if (type
== error_mark_node
)
5101 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
5107 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
5110 if (c_promoting_integer_type_p (type
))
5116 /* Recursively remove any '*' or '&' operator from TYPE. */
5118 strip_pointer_operator (tree t
)
5120 while (POINTER_TYPE_P (t
))
5125 /* Recursively remove pointer or array type from TYPE. */
5127 strip_pointer_or_array_types (tree t
)
5129 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
5134 /* Used to compare case labels. K1 and K2 are actually tree nodes
5135 representing case labels, or NULL_TREE for a `default' label.
5136 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5137 K2, and 0 if K1 and K2 are equal. */
5140 case_compare (splay_tree_key k1
, splay_tree_key k2
)
5142 /* Consider a NULL key (such as arises with a `default' label) to be
5143 smaller than anything else. */
5149 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5152 /* Process a case label, located at LOC, for the range LOW_VALUE
5153 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5154 then this case label is actually a `default' label. If only
5155 HIGH_VALUE is NULL_TREE, then case label was declared using the
5156 usual C/C++ syntax, rather than the GNU case range extension.
5157 CASES is a tree containing all the case ranges processed so far;
5158 COND is the condition for the switch-statement itself. Returns the
5159 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5163 c_add_case_label (location_t loc
, splay_tree cases
, tree cond
, tree orig_type
,
5164 tree low_value
, tree high_value
)
5169 splay_tree_node node
;
5171 /* Create the LABEL_DECL itself. */
5172 label
= create_artificial_label (loc
);
5174 /* If there was an error processing the switch condition, bail now
5175 before we get more confused. */
5176 if (!cond
|| cond
== error_mark_node
)
5179 if ((low_value
&& TREE_TYPE (low_value
)
5180 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
5181 || (high_value
&& TREE_TYPE (high_value
)
5182 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
5184 error_at (loc
, "pointers are not permitted as case values");
5188 /* Case ranges are a GNU extension. */
5190 pedwarn (loc
, OPT_pedantic
,
5191 "range expressions in switch statements are non-standard");
5193 type
= TREE_TYPE (cond
);
5196 low_value
= check_case_value (low_value
);
5197 low_value
= convert_and_check (type
, low_value
);
5198 if (low_value
== error_mark_node
)
5203 high_value
= check_case_value (high_value
);
5204 high_value
= convert_and_check (type
, high_value
);
5205 if (high_value
== error_mark_node
)
5209 if (low_value
&& high_value
)
5211 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5212 really a case range, even though it was written that way.
5213 Remove the HIGH_VALUE to simplify later processing. */
5214 if (tree_int_cst_equal (low_value
, high_value
))
5215 high_value
= NULL_TREE
;
5216 else if (!tree_int_cst_lt (low_value
, high_value
))
5217 warning_at (loc
, 0, "empty range specified");
5220 /* See if the case is in range of the type of the original testing
5221 expression. If both low_value and high_value are out of range,
5222 don't insert the case label and return NULL_TREE. */
5224 && !check_case_bounds (type
, orig_type
,
5225 &low_value
, high_value
? &high_value
: NULL
))
5228 /* Look up the LOW_VALUE in the table of case labels we already
5230 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
5231 /* If there was not an exact match, check for overlapping ranges.
5232 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5233 that's a `default' label and the only overlap is an exact match. */
5234 if (!node
&& (low_value
|| high_value
))
5236 splay_tree_node low_bound
;
5237 splay_tree_node high_bound
;
5239 /* Even though there wasn't an exact match, there might be an
5240 overlap between this case range and another case range.
5241 Since we've (inductively) not allowed any overlapping case
5242 ranges, we simply need to find the greatest low case label
5243 that is smaller that LOW_VALUE, and the smallest low case
5244 label that is greater than LOW_VALUE. If there is an overlap
5245 it will occur in one of these two ranges. */
5246 low_bound
= splay_tree_predecessor (cases
,
5247 (splay_tree_key
) low_value
);
5248 high_bound
= splay_tree_successor (cases
,
5249 (splay_tree_key
) low_value
);
5251 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5252 the LOW_VALUE, so there is no need to check unless the
5253 LOW_BOUND is in fact itself a case range. */
5255 && CASE_HIGH ((tree
) low_bound
->value
)
5256 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
5259 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5260 range is bigger than the low end of the current range, so we
5261 are only interested if the current range is a real range, and
5262 not an ordinary case label. */
5265 && (tree_int_cst_compare ((tree
) high_bound
->key
,
5270 /* If there was an overlap, issue an error. */
5273 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
5277 error_at (loc
, "duplicate (or overlapping) case value");
5278 error_at (DECL_SOURCE_LOCATION (duplicate
),
5279 "this is the first entry overlapping that value");
5283 error_at (loc
, "duplicate case value") ;
5284 error_at (DECL_SOURCE_LOCATION (duplicate
), "previously used here");
5288 error_at (loc
, "multiple default labels in one switch");
5289 error_at (DECL_SOURCE_LOCATION (duplicate
),
5290 "this is the first default label");
5295 /* Add a CASE_LABEL to the statement-tree. */
5296 case_label
= add_stmt (build_case_label (loc
, low_value
, high_value
, label
));
5297 /* Register this case label in the splay tree. */
5298 splay_tree_insert (cases
,
5299 (splay_tree_key
) low_value
,
5300 (splay_tree_value
) case_label
);
5305 /* Add a label so that the back-end doesn't think that the beginning of
5306 the switch is unreachable. Note that we do not add a case label, as
5307 that just leads to duplicates and thence to failure later on. */
5310 tree t
= create_artificial_label (loc
);
5311 add_stmt (build_stmt (loc
, LABEL_EXPR
, t
));
5313 return error_mark_node
;
5316 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5317 Used to verify that case values match up with enumerator values. */
5320 match_case_to_enum_1 (tree key
, tree type
, tree label
)
5322 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
5324 /* ??? Not working too hard to print the double-word value.
5325 Should perhaps be done with %lwd in the diagnostic routines? */
5326 if (TREE_INT_CST_HIGH (key
) == 0)
5327 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
5328 TREE_INT_CST_LOW (key
));
5329 else if (!TYPE_UNSIGNED (type
)
5330 && TREE_INT_CST_HIGH (key
) == -1
5331 && TREE_INT_CST_LOW (key
) != 0)
5332 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
5333 -TREE_INT_CST_LOW (key
));
5335 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
5336 (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (key
),
5337 (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (key
));
5339 if (TYPE_NAME (type
) == 0)
5340 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
5341 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5342 "case value %qs not in enumerated type",
5345 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
5346 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5347 "case value %qs not in enumerated type %qT",
5351 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5352 Used to verify that case values match up with enumerator values. */
5355 match_case_to_enum (splay_tree_node node
, void *data
)
5357 tree label
= (tree
) node
->value
;
5358 tree type
= (tree
) data
;
5360 /* Skip default case. */
5361 if (!CASE_LOW (label
))
5364 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5365 when we did our enum->case scan. Reset our scratch bit after. */
5366 if (!CASE_LOW_SEEN (label
))
5367 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
5369 CASE_LOW_SEEN (label
) = 0;
5371 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5372 not set, that means that CASE_HIGH did not appear when we did our
5373 enum->case scan. Reset our scratch bit after. */
5374 if (CASE_HIGH (label
))
5376 if (!CASE_HIGH_SEEN (label
))
5377 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
5379 CASE_HIGH_SEEN (label
) = 0;
5385 /* Handle -Wswitch*. Called from the front end after parsing the
5386 switch construct. */
5387 /* ??? Should probably be somewhere generic, since other languages
5388 besides C and C++ would want this. At the moment, however, C/C++
5389 are the only tree-ssa languages that support enumerations at all,
5390 so the point is moot. */
5393 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
5394 tree type
, tree cond
)
5396 splay_tree_node default_node
;
5397 splay_tree_node node
;
5400 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
5403 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
5405 warning_at (switch_location
, OPT_Wswitch_default
,
5406 "switch missing default case");
5408 /* From here on, we only care about about enumerated types. */
5409 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
5412 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
5413 if (!warn_switch_enum
&& !warn_switch
)
5416 /* Check the cases. Warn about case values which are not members of
5417 the enumerated type. For -Wswitch-enum, or for -Wswitch when
5418 there is no default case, check that exactly all enumeration
5419 literals are covered by the cases. */
5421 /* Clearing COND if it is not an integer constant simplifies
5422 the tests inside the loop below. */
5423 if (TREE_CODE (cond
) != INTEGER_CST
)
5426 /* The time complexity here is O(N*lg(N)) worst case, but for the
5427 common case of monotonically increasing enumerators, it is
5428 O(N), since the nature of the splay tree will keep the next
5429 element adjacent to the root at all times. */
5431 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
5433 tree value
= TREE_VALUE (chain
);
5434 if (TREE_CODE (value
) == CONST_DECL
)
5435 value
= DECL_INITIAL (value
);
5436 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
5439 /* Mark the CASE_LOW part of the case entry as seen. */
5440 tree label
= (tree
) node
->value
;
5441 CASE_LOW_SEEN (label
) = 1;
5445 /* Even though there wasn't an exact match, there might be a
5446 case range which includes the enumerator's value. */
5447 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
5448 if (node
&& CASE_HIGH ((tree
) node
->value
))
5450 tree label
= (tree
) node
->value
;
5451 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
5454 /* If we match the upper bound exactly, mark the CASE_HIGH
5455 part of the case entry as seen. */
5457 CASE_HIGH_SEEN (label
) = 1;
5462 /* We've now determined that this enumerated literal isn't
5463 handled by the case labels of the switch statement. */
5465 /* If the switch expression is a constant, we only really care
5466 about whether that constant is handled by the switch. */
5467 if (cond
&& tree_int_cst_compare (cond
, value
))
5470 /* If there is a default_node, the only relevant option is
5471 Wswitch-enum. Otherwise, if both are enabled then we prefer
5472 to warn using -Wswitch because -Wswitch is enabled by -Wall
5473 while -Wswitch-enum is explicit. */
5474 warning_at (switch_location
,
5475 (default_node
|| !warn_switch
5478 "enumeration value %qE not handled in switch",
5479 TREE_PURPOSE (chain
));
5482 /* Warn if there are case expressions that don't correspond to
5483 enumerators. This can occur since C and C++ don't enforce
5484 type-checking of assignments to enumeration variables.
5486 The time complexity here is now always O(N) worst case, since
5487 we should have marked both the lower bound and upper bound of
5488 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5489 above. This scan also resets those fields. */
5491 splay_tree_foreach (cases
, match_case_to_enum
, type
);
5494 /* Finish an expression taking the address of LABEL (an
5495 IDENTIFIER_NODE). Returns an expression for the address.
5497 LOC is the location for the expression returned. */
5500 finish_label_address_expr (tree label
, location_t loc
)
5504 pedwarn (input_location
, OPT_pedantic
, "taking the address of a label is non-standard");
5506 if (label
== error_mark_node
)
5507 return error_mark_node
;
5509 label
= lookup_label (label
);
5510 if (label
== NULL_TREE
)
5511 result
= null_pointer_node
;
5514 TREE_USED (label
) = 1;
5515 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
5516 /* The current function is not necessarily uninlinable.
5517 Computed gotos are incompatible with inlining, but the value
5518 here could be used only in a diagnostic, for example. */
5519 protected_set_expr_location (result
, loc
);
5526 /* Given a boolean expression ARG, return a tree representing an increment
5527 or decrement (as indicated by CODE) of ARG. The front end must check for
5528 invalid cases (e.g., decrement in C++). */
5530 boolean_increment (enum tree_code code
, tree arg
)
5533 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
5535 arg
= stabilize_reference (arg
);
5538 case PREINCREMENT_EXPR
:
5539 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5541 case POSTINCREMENT_EXPR
:
5542 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5543 arg
= save_expr (arg
);
5544 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5545 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5547 case PREDECREMENT_EXPR
:
5548 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5549 invert_truthvalue_loc (input_location
, arg
));
5551 case POSTDECREMENT_EXPR
:
5552 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5553 invert_truthvalue_loc (input_location
, arg
));
5554 arg
= save_expr (arg
);
5555 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5556 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5561 TREE_SIDE_EFFECTS (val
) = 1;
5565 /* Built-in macros for stddef.h and stdint.h, that require macros
5566 defined in this file. */
5568 c_stddef_cpp_builtins(void)
5570 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
5571 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
5572 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
5573 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
5574 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
5575 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
5576 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
5577 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
5578 if (SIG_ATOMIC_TYPE
)
5579 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE
, 0);
5581 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE
, 0);
5583 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE
, 0);
5585 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE
, 0);
5587 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE
, 0);
5589 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE
, 0);
5591 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE
, 0);
5593 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE
, 0);
5595 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE
, 0);
5596 if (INT_LEAST8_TYPE
)
5597 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE
, 0);
5598 if (INT_LEAST16_TYPE
)
5599 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE
, 0);
5600 if (INT_LEAST32_TYPE
)
5601 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE
, 0);
5602 if (INT_LEAST64_TYPE
)
5603 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE
, 0);
5604 if (UINT_LEAST8_TYPE
)
5605 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE
, 0);
5606 if (UINT_LEAST16_TYPE
)
5607 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE
, 0);
5608 if (UINT_LEAST32_TYPE
)
5609 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE
, 0);
5610 if (UINT_LEAST64_TYPE
)
5611 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE
, 0);
5613 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE
, 0);
5614 if (INT_FAST16_TYPE
)
5615 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE
, 0);
5616 if (INT_FAST32_TYPE
)
5617 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE
, 0);
5618 if (INT_FAST64_TYPE
)
5619 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE
, 0);
5620 if (UINT_FAST8_TYPE
)
5621 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE
, 0);
5622 if (UINT_FAST16_TYPE
)
5623 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE
, 0);
5624 if (UINT_FAST32_TYPE
)
5625 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE
, 0);
5626 if (UINT_FAST64_TYPE
)
5627 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE
, 0);
5629 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE
, 0);
5631 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE
, 0);
5635 c_init_attributes (void)
5637 /* Fill in the built_in_attributes array. */
5638 #define DEF_ATTR_NULL_TREE(ENUM) \
5639 built_in_attributes[(int) ENUM] = NULL_TREE;
5640 #define DEF_ATTR_INT(ENUM, VALUE) \
5641 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5642 #define DEF_ATTR_IDENT(ENUM, STRING) \
5643 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5644 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5645 built_in_attributes[(int) ENUM] \
5646 = tree_cons (built_in_attributes[(int) PURPOSE], \
5647 built_in_attributes[(int) VALUE], \
5648 built_in_attributes[(int) CHAIN]);
5649 #include "builtin-attrs.def"
5650 #undef DEF_ATTR_NULL_TREE
5652 #undef DEF_ATTR_IDENT
5653 #undef DEF_ATTR_TREE_LIST
5656 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
5657 identifier as an argument, so the front end shouldn't look it up. */
5660 attribute_takes_identifier_p (const_tree attr_id
)
5662 if (is_attribute_p ("mode", attr_id
)
5663 || is_attribute_p ("format", attr_id
)
5664 || is_attribute_p ("cleanup", attr_id
))
5667 return targetm
.attribute_takes_identifier_p (attr_id
);
5670 /* Attribute handlers common to C front ends. */
5672 /* Handle a "packed" attribute; arguments as in
5673 struct attribute_spec.handler. */
5676 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5677 int flags
, bool *no_add_attrs
)
5681 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5682 *node
= build_variant_type_copy (*node
);
5683 TYPE_PACKED (*node
) = 1;
5685 else if (TREE_CODE (*node
) == FIELD_DECL
)
5687 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
5688 /* Still pack bitfields. */
5689 && ! DECL_INITIAL (*node
))
5690 warning (OPT_Wattributes
,
5691 "%qE attribute ignored for field of type %qT",
5692 name
, TREE_TYPE (*node
));
5694 DECL_PACKED (*node
) = 1;
5696 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5697 used for DECL_REGISTER. It wouldn't mean anything anyway.
5698 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5699 that changes what the typedef is typing. */
5702 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5703 *no_add_attrs
= true;
5709 /* Handle a "nocommon" attribute; arguments as in
5710 struct attribute_spec.handler. */
5713 handle_nocommon_attribute (tree
*node
, tree name
,
5714 tree
ARG_UNUSED (args
),
5715 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5717 if (TREE_CODE (*node
) == VAR_DECL
)
5718 DECL_COMMON (*node
) = 0;
5721 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5722 *no_add_attrs
= true;
5728 /* Handle a "common" attribute; arguments as in
5729 struct attribute_spec.handler. */
5732 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5733 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5735 if (TREE_CODE (*node
) == VAR_DECL
)
5736 DECL_COMMON (*node
) = 1;
5739 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5740 *no_add_attrs
= true;
5746 /* Handle a "noreturn" attribute; arguments as in
5747 struct attribute_spec.handler. */
5750 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5751 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5753 tree type
= TREE_TYPE (*node
);
5755 /* See FIXME comment in c_common_attribute_table. */
5756 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5757 TREE_THIS_VOLATILE (*node
) = 1;
5758 else if (TREE_CODE (type
) == POINTER_TYPE
5759 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5761 = build_pointer_type
5762 (build_type_variant (TREE_TYPE (type
),
5763 TYPE_READONLY (TREE_TYPE (type
)), 1));
5766 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5767 *no_add_attrs
= true;
5773 /* Handle a "hot" and attribute; arguments as in
5774 struct attribute_spec.handler. */
5777 handle_hot_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5778 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5780 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5782 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node
)) != NULL
)
5784 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5786 *no_add_attrs
= true;
5788 /* Most of the rest of the hot processing is done later with
5789 lookup_attribute. */
5793 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5794 *no_add_attrs
= true;
5799 /* Handle a "cold" and attribute; arguments as in
5800 struct attribute_spec.handler. */
5803 handle_cold_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5804 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5806 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5808 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node
)) != NULL
)
5810 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5812 *no_add_attrs
= true;
5814 /* Most of the rest of the cold processing is done later with
5815 lookup_attribute. */
5819 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5820 *no_add_attrs
= true;
5826 /* Handle a "noinline" attribute; arguments as in
5827 struct attribute_spec.handler. */
5830 handle_noinline_attribute (tree
*node
, tree name
,
5831 tree
ARG_UNUSED (args
),
5832 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5834 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5835 DECL_UNINLINABLE (*node
) = 1;
5838 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5839 *no_add_attrs
= true;
5845 /* Handle a "noclone" attribute; arguments as in
5846 struct attribute_spec.handler. */
5849 handle_noclone_attribute (tree
*node
, tree name
,
5850 tree
ARG_UNUSED (args
),
5851 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5853 if (TREE_CODE (*node
) != FUNCTION_DECL
)
5855 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5856 *no_add_attrs
= true;
5862 /* Handle a "always_inline" attribute; arguments as in
5863 struct attribute_spec.handler. */
5866 handle_always_inline_attribute (tree
*node
, tree name
,
5867 tree
ARG_UNUSED (args
),
5868 int ARG_UNUSED (flags
),
5871 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5873 /* Set the attribute and mark it for disregarding inline
5875 DECL_DISREGARD_INLINE_LIMITS (*node
) = 1;
5879 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5880 *no_add_attrs
= true;
5886 /* Handle a "gnu_inline" attribute; arguments as in
5887 struct attribute_spec.handler. */
5890 handle_gnu_inline_attribute (tree
*node
, tree name
,
5891 tree
ARG_UNUSED (args
),
5892 int ARG_UNUSED (flags
),
5895 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
5897 /* Do nothing else, just set the attribute. We'll get at
5898 it later with lookup_attribute. */
5902 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5903 *no_add_attrs
= true;
5909 /* Handle an "artificial" attribute; arguments as in
5910 struct attribute_spec.handler. */
5913 handle_artificial_attribute (tree
*node
, tree name
,
5914 tree
ARG_UNUSED (args
),
5915 int ARG_UNUSED (flags
),
5918 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
5920 /* Do nothing else, just set the attribute. We'll get at
5921 it later with lookup_attribute. */
5925 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5926 *no_add_attrs
= true;
5932 /* Handle a "flatten" attribute; arguments as in
5933 struct attribute_spec.handler. */
5936 handle_flatten_attribute (tree
*node
, tree name
,
5937 tree args ATTRIBUTE_UNUSED
,
5938 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5940 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5941 /* Do nothing else, just set the attribute. We'll get at
5942 it later with lookup_attribute. */
5946 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5947 *no_add_attrs
= true;
5953 /* Handle a "warning" or "error" attribute; arguments as in
5954 struct attribute_spec.handler. */
5957 handle_error_attribute (tree
*node
, tree name
, tree args
,
5958 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5960 if (TREE_CODE (*node
) == FUNCTION_DECL
5961 || TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5962 /* Do nothing else, just set the attribute. We'll get at
5963 it later with lookup_attribute. */
5967 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5968 *no_add_attrs
= true;
5974 /* Handle a "used" attribute; arguments as in
5975 struct attribute_spec.handler. */
5978 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
5979 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5983 if (TREE_CODE (node
) == FUNCTION_DECL
5984 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
5986 TREE_USED (node
) = 1;
5987 DECL_PRESERVE_P (node
) = 1;
5988 if (TREE_CODE (node
) == VAR_DECL
)
5989 DECL_READ_P (node
) = 1;
5993 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5994 *no_add_attrs
= true;
6000 /* Handle a "unused" attribute; arguments as in
6001 struct attribute_spec.handler. */
6004 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6005 int flags
, bool *no_add_attrs
)
6011 if (TREE_CODE (decl
) == PARM_DECL
6012 || TREE_CODE (decl
) == VAR_DECL
6013 || TREE_CODE (decl
) == FUNCTION_DECL
6014 || TREE_CODE (decl
) == LABEL_DECL
6015 || TREE_CODE (decl
) == TYPE_DECL
)
6017 TREE_USED (decl
) = 1;
6018 if (TREE_CODE (decl
) == VAR_DECL
6019 || TREE_CODE (decl
) == PARM_DECL
)
6020 DECL_READ_P (decl
) = 1;
6024 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6025 *no_add_attrs
= true;
6030 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6031 *node
= build_variant_type_copy (*node
);
6032 TREE_USED (*node
) = 1;
6038 /* Handle a "externally_visible" attribute; arguments as in
6039 struct attribute_spec.handler. */
6042 handle_externally_visible_attribute (tree
*pnode
, tree name
,
6043 tree
ARG_UNUSED (args
),
6044 int ARG_UNUSED (flags
),
6049 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
6051 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
6052 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
6054 warning (OPT_Wattributes
,
6055 "%qE attribute have effect only on public objects", name
);
6056 *no_add_attrs
= true;
6061 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6062 *no_add_attrs
= true;
6068 /* Handle a "const" attribute; arguments as in
6069 struct attribute_spec.handler. */
6072 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6073 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6075 tree type
= TREE_TYPE (*node
);
6077 /* See FIXME comment on noreturn in c_common_attribute_table. */
6078 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6079 TREE_READONLY (*node
) = 1;
6080 else if (TREE_CODE (type
) == POINTER_TYPE
6081 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
6083 = build_pointer_type
6084 (build_type_variant (TREE_TYPE (type
), 1,
6085 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
6088 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6089 *no_add_attrs
= true;
6095 /* Handle a "transparent_union" attribute; arguments as in
6096 struct attribute_spec.handler. */
6099 handle_transparent_union_attribute (tree
*node
, tree name
,
6100 tree
ARG_UNUSED (args
), int flags
,
6105 *no_add_attrs
= true;
6107 if (TREE_CODE (*node
) == TYPE_DECL
)
6108 node
= &TREE_TYPE (*node
);
6111 if (TREE_CODE (type
) == UNION_TYPE
)
6113 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6114 the code in finish_struct. */
6115 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6117 if (TYPE_FIELDS (type
) == NULL_TREE
6118 || TYPE_MODE (type
) != DECL_MODE (TYPE_FIELDS (type
)))
6121 /* A type variant isn't good enough, since we don't a cast
6122 to such a type removed as a no-op. */
6123 *node
= type
= build_duplicate_type (type
);
6126 TYPE_TRANSPARENT_AGGR (type
) = 1;
6131 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6135 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6136 get the requested priority for a constructor or destructor,
6137 possibly issuing diagnostics for invalid or reserved
6140 static priority_type
6141 get_priority (tree args
, bool is_destructor
)
6147 return DEFAULT_INIT_PRIORITY
;
6149 if (!SUPPORTS_INIT_PRIORITY
)
6152 error ("destructor priorities are not supported");
6154 error ("constructor priorities are not supported");
6155 return DEFAULT_INIT_PRIORITY
;
6158 arg
= TREE_VALUE (args
);
6159 if (!host_integerp (arg
, /*pos=*/0)
6160 || !INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
6163 pri
= tree_low_cst (TREE_VALUE (args
), /*pos=*/0);
6164 if (pri
< 0 || pri
> MAX_INIT_PRIORITY
)
6167 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
6171 "destructor priorities from 0 to %d are reserved "
6172 "for the implementation",
6173 MAX_RESERVED_INIT_PRIORITY
);
6176 "constructor priorities from 0 to %d are reserved "
6177 "for the implementation",
6178 MAX_RESERVED_INIT_PRIORITY
);
6184 error ("destructor priorities must be integers from 0 to %d inclusive",
6187 error ("constructor priorities must be integers from 0 to %d inclusive",
6189 return DEFAULT_INIT_PRIORITY
;
6192 /* Handle a "constructor" attribute; arguments as in
6193 struct attribute_spec.handler. */
6196 handle_constructor_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_CONSTRUCTOR (decl
) = 1;
6209 priority
= get_priority (args
, /*is_destructor=*/false);
6210 SET_DECL_INIT_PRIORITY (decl
, priority
);
6211 TREE_USED (decl
) = 1;
6215 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6216 *no_add_attrs
= true;
6222 /* Handle a "destructor" attribute; arguments as in
6223 struct attribute_spec.handler. */
6226 handle_destructor_attribute (tree
*node
, tree name
, tree args
,
6227 int ARG_UNUSED (flags
),
6231 tree type
= TREE_TYPE (decl
);
6233 if (TREE_CODE (decl
) == FUNCTION_DECL
6234 && TREE_CODE (type
) == FUNCTION_TYPE
6235 && decl_function_context (decl
) == 0)
6237 priority_type priority
;
6238 DECL_STATIC_DESTRUCTOR (decl
) = 1;
6239 priority
= get_priority (args
, /*is_destructor=*/true);
6240 SET_DECL_FINI_PRIORITY (decl
, priority
);
6241 TREE_USED (decl
) = 1;
6245 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6246 *no_add_attrs
= true;
6252 /* Handle a "mode" attribute; arguments as in
6253 struct attribute_spec.handler. */
6256 handle_mode_attribute (tree
*node
, tree name
, tree args
,
6257 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6260 tree ident
= TREE_VALUE (args
);
6262 *no_add_attrs
= true;
6264 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
6265 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6269 const char *p
= IDENTIFIER_POINTER (ident
);
6270 int len
= strlen (p
);
6271 enum machine_mode mode
= VOIDmode
;
6275 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
6276 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
6278 char *newp
= (char *) alloca (len
- 1);
6280 strcpy (newp
, &p
[2]);
6281 newp
[len
- 4] = '\0';
6285 /* Change this type to have a type with the specified mode.
6286 First check for the special modes. */
6287 if (!strcmp (p
, "byte"))
6289 else if (!strcmp (p
, "word"))
6291 else if (!strcmp (p
, "pointer"))
6293 else if (!strcmp (p
, "libgcc_cmp_return"))
6294 mode
= targetm
.libgcc_cmp_return_mode ();
6295 else if (!strcmp (p
, "libgcc_shift_count"))
6296 mode
= targetm
.libgcc_shift_count_mode ();
6297 else if (!strcmp (p
, "unwind_word"))
6298 mode
= targetm
.unwind_word_mode ();
6300 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
6301 if (!strcmp (p
, GET_MODE_NAME (j
)))
6303 mode
= (enum machine_mode
) j
;
6307 if (mode
== VOIDmode
)
6309 error ("unknown machine mode %qE", ident
);
6314 switch (GET_MODE_CLASS (mode
))
6317 case MODE_PARTIAL_INT
:
6319 case MODE_DECIMAL_FLOAT
:
6324 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
6327 case MODE_COMPLEX_INT
:
6328 case MODE_COMPLEX_FLOAT
:
6329 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
6332 case MODE_VECTOR_INT
:
6333 case MODE_VECTOR_FLOAT
:
6334 case MODE_VECTOR_FRACT
:
6335 case MODE_VECTOR_UFRACT
:
6336 case MODE_VECTOR_ACCUM
:
6337 case MODE_VECTOR_UACCUM
:
6338 warning (OPT_Wattributes
, "specifying vector types with "
6339 "__attribute__ ((mode)) is deprecated");
6340 warning (OPT_Wattributes
,
6341 "use __attribute__ ((vector_size)) instead");
6342 valid_mode
= vector_mode_valid_p (mode
);
6350 error ("unable to emulate %qs", p
);
6354 if (POINTER_TYPE_P (type
))
6356 addr_space_t as
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
6357 tree (*fn
)(tree
, enum machine_mode
, bool);
6359 if (!targetm
.addr_space
.valid_pointer_mode (mode
, as
))
6361 error ("invalid pointer mode %qs", p
);
6365 if (TREE_CODE (type
) == POINTER_TYPE
)
6366 fn
= build_pointer_type_for_mode
;
6368 fn
= build_reference_type_for_mode
;
6369 typefm
= fn (TREE_TYPE (type
), mode
, false);
6373 /* For fixed-point modes, we need to test if the signness of type
6374 and the machine mode are consistent. */
6375 if (ALL_FIXED_POINT_MODE_P (mode
)
6376 && TYPE_UNSIGNED (type
) != UNSIGNED_FIXED_POINT_MODE_P (mode
))
6378 error ("signness of type and machine mode %qs don't match", p
);
6381 /* For fixed-point modes, we need to pass saturating info. */
6382 typefm
= lang_hooks
.types
.type_for_mode (mode
,
6383 ALL_FIXED_POINT_MODE_P (mode
) ? TYPE_SATURATING (type
)
6384 : TYPE_UNSIGNED (type
));
6387 if (typefm
== NULL_TREE
)
6389 error ("no data type for mode %qs", p
);
6392 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
6394 /* For enumeral types, copy the precision from the integer
6395 type returned above. If not an INTEGER_TYPE, we can't use
6396 this mode for this type. */
6397 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
6399 error ("cannot use mode %qs for enumeral types", p
);
6403 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
6405 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
6410 /* We cannot build a type variant, as there's code that assumes
6411 that TYPE_MAIN_VARIANT has the same mode. This includes the
6412 debug generators. Instead, create a subrange type. This
6413 results in all of the enumeral values being emitted only once
6414 in the original, and the subtype gets them by reference. */
6415 if (TYPE_UNSIGNED (type
))
6416 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
6418 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
6419 TREE_TYPE (typefm
) = type
;
6422 else if (VECTOR_MODE_P (mode
)
6423 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
6424 : TREE_CODE (type
) != TREE_CODE (typefm
))
6426 error ("mode %qs applied to inappropriate type", p
);
6436 /* Handle a "section" attribute; arguments as in
6437 struct attribute_spec.handler. */
6440 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6441 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6445 if (targetm
.have_named_sections
)
6447 user_defined_section_attribute
= true;
6449 if ((TREE_CODE (decl
) == FUNCTION_DECL
6450 || TREE_CODE (decl
) == VAR_DECL
)
6451 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
6453 if (TREE_CODE (decl
) == VAR_DECL
6454 && current_function_decl
!= NULL_TREE
6455 && !TREE_STATIC (decl
))
6457 error_at (DECL_SOURCE_LOCATION (decl
),
6458 "section attribute cannot be specified for "
6460 *no_add_attrs
= true;
6463 /* The decl may have already been given a section attribute
6464 from a previous declaration. Ensure they match. */
6465 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
6466 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
6467 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
6469 error ("section of %q+D conflicts with previous declaration",
6471 *no_add_attrs
= true;
6473 else if (TREE_CODE (decl
) == VAR_DECL
6474 && !targetm
.have_tls
&& targetm
.emutls
.tmpl_section
6475 && DECL_THREAD_LOCAL_P (decl
))
6477 error ("section of %q+D cannot be overridden", *node
);
6478 *no_add_attrs
= true;
6481 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
6485 error ("section attribute not allowed for %q+D", *node
);
6486 *no_add_attrs
= true;
6491 error_at (DECL_SOURCE_LOCATION (*node
),
6492 "section attributes are not supported for this target");
6493 *no_add_attrs
= true;
6499 /* Handle a "aligned" attribute; arguments as in
6500 struct attribute_spec.handler. */
6503 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6504 int flags
, bool *no_add_attrs
)
6506 tree decl
= NULL_TREE
;
6509 tree align_expr
= (args
? TREE_VALUE (args
)
6510 : size_int (ATTRIBUTE_ALIGNED_VALUE
/ BITS_PER_UNIT
));
6516 type
= &TREE_TYPE (decl
);
6517 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
6519 else if (TYPE_P (*node
))
6520 type
= node
, is_type
= 1;
6522 if (TREE_CODE (align_expr
) != INTEGER_CST
)
6524 error ("requested alignment is not a constant");
6525 *no_add_attrs
= true;
6527 else if ((i
= tree_log2 (align_expr
)) == -1)
6529 error ("requested alignment is not a power of 2");
6530 *no_add_attrs
= true;
6532 else if (i
>= HOST_BITS_PER_INT
- BITS_PER_UNIT_LOG
)
6534 error ("requested alignment is too large");
6535 *no_add_attrs
= true;
6539 if ((flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6540 /* OK, modify the type in place. */;
6541 /* If we have a TYPE_DECL, then copy the type, so that we
6542 don't accidentally modify a builtin type. See pushdecl. */
6543 else if (decl
&& TREE_TYPE (decl
) != error_mark_node
6544 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
6546 tree tt
= TREE_TYPE (decl
);
6547 *type
= build_variant_type_copy (*type
);
6548 DECL_ORIGINAL_TYPE (decl
) = tt
;
6549 TYPE_NAME (*type
) = decl
;
6550 TREE_USED (*type
) = TREE_USED (decl
);
6551 TREE_TYPE (decl
) = *type
;
6554 *type
= build_variant_type_copy (*type
);
6556 TYPE_ALIGN (*type
) = (1U << i
) * BITS_PER_UNIT
;
6557 TYPE_USER_ALIGN (*type
) = 1;
6559 else if (! VAR_OR_FUNCTION_DECL_P (decl
)
6560 && TREE_CODE (decl
) != FIELD_DECL
)
6562 error ("alignment may not be specified for %q+D", decl
);
6563 *no_add_attrs
= true;
6565 else if (TREE_CODE (decl
) == FUNCTION_DECL
6566 && DECL_ALIGN (decl
) > (1U << i
) * BITS_PER_UNIT
)
6568 if (DECL_USER_ALIGN (decl
))
6569 error ("alignment for %q+D was previously specified as %d "
6570 "and may not be decreased", decl
,
6571 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6573 error ("alignment for %q+D must be at least %d", decl
,
6574 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6575 *no_add_attrs
= true;
6579 DECL_ALIGN (decl
) = (1U << i
) * BITS_PER_UNIT
;
6580 DECL_USER_ALIGN (decl
) = 1;
6586 /* Handle a "weak" attribute; arguments as in
6587 struct attribute_spec.handler. */
6590 handle_weak_attribute (tree
*node
, tree name
,
6591 tree
ARG_UNUSED (args
),
6592 int ARG_UNUSED (flags
),
6593 bool * ARG_UNUSED (no_add_attrs
))
6595 if (TREE_CODE (*node
) == FUNCTION_DECL
6596 && DECL_DECLARED_INLINE_P (*node
))
6598 error ("inline function %q+D cannot be declared weak", *node
);
6599 *no_add_attrs
= true;
6601 else if (TREE_CODE (*node
) == FUNCTION_DECL
6602 || TREE_CODE (*node
) == VAR_DECL
)
6603 declare_weak (*node
);
6605 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6610 /* Handle an "alias" attribute; arguments as in
6611 struct attribute_spec.handler. */
6614 handle_alias_attribute (tree
*node
, tree name
, tree args
,
6615 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6619 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
6621 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6622 *no_add_attrs
= true;
6624 else if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
6625 || (TREE_CODE (decl
) != FUNCTION_DECL
6626 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
6627 /* A static variable declaration is always a tentative definition,
6628 but the alias is a non-tentative definition which overrides. */
6629 || (TREE_CODE (decl
) != FUNCTION_DECL
6630 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
6632 error ("%q+D defined both normally and as an alias", decl
);
6633 *no_add_attrs
= true;
6636 /* Note that the very first time we process a nested declaration,
6637 decl_function_context will not be set. Indeed, *would* never
6638 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6639 we do below. After such frobbery, pushdecl would set the context.
6640 In any case, this is never what we want. */
6641 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
6645 id
= TREE_VALUE (args
);
6646 if (TREE_CODE (id
) != STRING_CST
)
6648 error ("alias argument not a string");
6649 *no_add_attrs
= true;
6652 id
= get_identifier (TREE_STRING_POINTER (id
));
6653 /* This counts as a use of the object pointed to. */
6656 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6657 DECL_INITIAL (decl
) = error_mark_node
;
6660 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
6661 DECL_EXTERNAL (decl
) = 1;
6663 DECL_EXTERNAL (decl
) = 0;
6664 TREE_STATIC (decl
) = 1;
6669 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6670 *no_add_attrs
= true;
6676 /* Handle a "weakref" attribute; arguments as in struct
6677 attribute_spec.handler. */
6680 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6681 int flags
, bool *no_add_attrs
)
6683 tree attr
= NULL_TREE
;
6685 /* We must ignore the attribute when it is associated with
6686 local-scoped decls, since attribute alias is ignored and many
6687 such symbols do not even have a DECL_WEAK field. */
6688 if (decl_function_context (*node
)
6689 || current_function_decl
6690 || (TREE_CODE (*node
) != VAR_DECL
&& TREE_CODE (*node
) != FUNCTION_DECL
))
6692 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6693 *no_add_attrs
= true;
6697 /* The idea here is that `weakref("name")' mutates into `weakref,
6698 alias("name")', and weakref without arguments, in turn,
6699 implicitly adds weak. */
6703 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
6704 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
6706 *no_add_attrs
= true;
6708 decl_attributes (node
, attr
, flags
);
6712 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
6713 error_at (DECL_SOURCE_LOCATION (*node
),
6714 "weakref attribute must appear before alias attribute");
6716 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6717 and that isn't supported; and because it wants to add it to
6718 the list of weak decls, which isn't helpful. */
6719 DECL_WEAK (*node
) = 1;
6725 /* Handle an "visibility" attribute; arguments as in
6726 struct attribute_spec.handler. */
6729 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
6730 int ARG_UNUSED (flags
),
6731 bool *ARG_UNUSED (no_add_attrs
))
6734 tree id
= TREE_VALUE (args
);
6735 enum symbol_visibility vis
;
6739 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
6741 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
6743 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
6747 else if (TYPE_FIELDS (*node
))
6749 error ("%qE attribute ignored because %qT is already defined",
6754 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
6756 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6760 if (TREE_CODE (id
) != STRING_CST
)
6762 error ("visibility argument not a string");
6766 /* If this is a type, set the visibility on the type decl. */
6769 decl
= TYPE_NAME (decl
);
6772 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6774 warning (OPT_Wattributes
, "%qE attribute ignored on types",
6780 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
6781 vis
= VISIBILITY_DEFAULT
;
6782 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
6783 vis
= VISIBILITY_INTERNAL
;
6784 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
6785 vis
= VISIBILITY_HIDDEN
;
6786 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
6787 vis
= VISIBILITY_PROTECTED
;
6790 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6791 vis
= VISIBILITY_DEFAULT
;
6794 if (DECL_VISIBILITY_SPECIFIED (decl
)
6795 && vis
!= DECL_VISIBILITY (decl
))
6797 tree attributes
= (TYPE_P (*node
)
6798 ? TYPE_ATTRIBUTES (*node
)
6799 : DECL_ATTRIBUTES (decl
));
6800 if (lookup_attribute ("visibility", attributes
))
6801 error ("%qD redeclared with different visibility", decl
);
6802 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6803 && lookup_attribute ("dllimport", attributes
))
6804 error ("%qD was declared %qs which implies default visibility",
6806 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6807 && lookup_attribute ("dllexport", attributes
))
6808 error ("%qD was declared %qs which implies default visibility",
6812 DECL_VISIBILITY (decl
) = vis
;
6813 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
6815 /* Go ahead and attach the attribute to the node as well. This is needed
6816 so we can determine whether we have VISIBILITY_DEFAULT because the
6817 visibility was not specified, or because it was explicitly overridden
6818 from the containing scope. */
6823 /* Determine the ELF symbol visibility for DECL, which is either a
6824 variable or a function. It is an error to use this function if a
6825 definition of DECL is not available in this translation unit.
6826 Returns true if the final visibility has been determined by this
6827 function; false if the caller is free to make additional
6831 c_determine_visibility (tree decl
)
6833 gcc_assert (TREE_CODE (decl
) == VAR_DECL
6834 || TREE_CODE (decl
) == FUNCTION_DECL
);
6836 /* If the user explicitly specified the visibility with an
6837 attribute, honor that. DECL_VISIBILITY will have been set during
6838 the processing of the attribute. We check for an explicit
6839 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6840 to distinguish the use of an attribute from the use of a "#pragma
6841 GCC visibility push(...)"; in the latter case we still want other
6842 considerations to be able to overrule the #pragma. */
6843 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
6844 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6845 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
6846 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
6849 /* Set default visibility to whatever the user supplied with
6850 visibility_specified depending on #pragma GCC visibility. */
6851 if (!DECL_VISIBILITY_SPECIFIED (decl
))
6853 if (visibility_options
.inpragma
6854 || DECL_VISIBILITY (decl
) != default_visibility
)
6856 DECL_VISIBILITY (decl
) = default_visibility
;
6857 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
6858 /* If visibility changed and DECL already has DECL_RTL, ensure
6859 symbol flags are updated. */
6860 if (((TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
6861 || TREE_CODE (decl
) == FUNCTION_DECL
)
6862 && DECL_RTL_SET_P (decl
))
6863 make_decl_rtl (decl
);
6869 /* Handle an "tls_model" attribute; arguments as in
6870 struct attribute_spec.handler. */
6873 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
6874 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6878 enum tls_model kind
;
6880 *no_add_attrs
= true;
6882 if (TREE_CODE (decl
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (decl
))
6884 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6888 kind
= DECL_TLS_MODEL (decl
);
6889 id
= TREE_VALUE (args
);
6890 if (TREE_CODE (id
) != STRING_CST
)
6892 error ("tls_model argument not a string");
6896 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
6897 kind
= TLS_MODEL_LOCAL_EXEC
;
6898 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
6899 kind
= TLS_MODEL_INITIAL_EXEC
;
6900 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
6901 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
6902 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
6903 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
6905 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6907 DECL_TLS_MODEL (decl
) = kind
;
6911 /* Handle a "no_instrument_function" attribute; arguments as in
6912 struct attribute_spec.handler. */
6915 handle_no_instrument_function_attribute (tree
*node
, tree name
,
6916 tree
ARG_UNUSED (args
),
6917 int ARG_UNUSED (flags
),
6922 if (TREE_CODE (decl
) != FUNCTION_DECL
)
6924 error_at (DECL_SOURCE_LOCATION (decl
),
6925 "%qE attribute applies only to functions", name
);
6926 *no_add_attrs
= true;
6928 else if (DECL_INITIAL (decl
))
6930 error_at (DECL_SOURCE_LOCATION (decl
),
6931 "can%'t set %qE attribute after definition", name
);
6932 *no_add_attrs
= true;
6935 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
6940 /* Handle a "malloc" attribute; arguments as in
6941 struct attribute_spec.handler. */
6944 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6945 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6947 if (TREE_CODE (*node
) == FUNCTION_DECL
6948 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
6949 DECL_IS_MALLOC (*node
) = 1;
6952 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6953 *no_add_attrs
= true;
6959 /* Handle a "alloc_size" attribute; arguments as in
6960 struct attribute_spec.handler. */
6963 handle_alloc_size_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6964 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6966 unsigned arg_count
= type_num_arguments (*node
);
6967 for (; args
; args
= TREE_CHAIN (args
))
6969 tree position
= TREE_VALUE (args
);
6971 if (TREE_CODE (position
) != INTEGER_CST
6972 || TREE_INT_CST_HIGH (position
)
6973 || TREE_INT_CST_LOW (position
) < 1
6974 || TREE_INT_CST_LOW (position
) > arg_count
)
6976 warning (OPT_Wattributes
,
6977 "alloc_size parameter outside range");
6978 *no_add_attrs
= true;
6985 /* Handle a "fn spec" attribute; arguments as in
6986 struct attribute_spec.handler. */
6989 handle_fnspec_attribute (tree
*node ATTRIBUTE_UNUSED
, tree
ARG_UNUSED (name
),
6990 tree args
, int ARG_UNUSED (flags
),
6991 bool *no_add_attrs ATTRIBUTE_UNUSED
)
6994 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
6995 && !TREE_CHAIN (args
));
6999 /* Handle a "returns_twice" attribute; arguments as in
7000 struct attribute_spec.handler. */
7003 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7004 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7006 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7007 DECL_IS_RETURNS_TWICE (*node
) = 1;
7010 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7011 *no_add_attrs
= true;
7017 /* Handle a "no_limit_stack" attribute; arguments as in
7018 struct attribute_spec.handler. */
7021 handle_no_limit_stack_attribute (tree
*node
, tree name
,
7022 tree
ARG_UNUSED (args
),
7023 int ARG_UNUSED (flags
),
7028 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7030 error_at (DECL_SOURCE_LOCATION (decl
),
7031 "%qE attribute applies only to functions", name
);
7032 *no_add_attrs
= true;
7034 else if (DECL_INITIAL (decl
))
7036 error_at (DECL_SOURCE_LOCATION (decl
),
7037 "can%'t set %qE attribute after definition", name
);
7038 *no_add_attrs
= true;
7041 DECL_NO_LIMIT_STACK (decl
) = 1;
7046 /* Handle a "pure" attribute; arguments as in
7047 struct attribute_spec.handler. */
7050 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7051 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7053 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7054 DECL_PURE_P (*node
) = 1;
7055 /* ??? TODO: Support types. */
7058 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7059 *no_add_attrs
= true;
7065 /* Handle a "no vops" attribute; arguments as in
7066 struct attribute_spec.handler. */
7069 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7070 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
7071 bool *ARG_UNUSED (no_add_attrs
))
7073 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
7074 DECL_IS_NOVOPS (*node
) = 1;
7078 /* Handle a "deprecated" attribute; arguments as in
7079 struct attribute_spec.handler. */
7082 handle_deprecated_attribute (tree
*node
, tree name
,
7083 tree args
, int flags
,
7086 tree type
= NULL_TREE
;
7088 tree what
= NULL_TREE
;
7091 *no_add_attrs
= true;
7092 else if (TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
7094 error ("deprecated message is not a string");
7095 *no_add_attrs
= true;
7101 type
= TREE_TYPE (decl
);
7103 if (TREE_CODE (decl
) == TYPE_DECL
7104 || TREE_CODE (decl
) == PARM_DECL
7105 || TREE_CODE (decl
) == VAR_DECL
7106 || TREE_CODE (decl
) == FUNCTION_DECL
7107 || TREE_CODE (decl
) == FIELD_DECL
)
7108 TREE_DEPRECATED (decl
) = 1;
7112 else if (TYPE_P (*node
))
7114 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
7115 *node
= build_variant_type_copy (*node
);
7116 TREE_DEPRECATED (*node
) = 1;
7124 *no_add_attrs
= true;
7125 if (type
&& TYPE_NAME (type
))
7127 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
7128 what
= TYPE_NAME (*node
);
7129 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
7130 && DECL_NAME (TYPE_NAME (type
)))
7131 what
= DECL_NAME (TYPE_NAME (type
));
7134 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
7136 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7142 /* Handle a "vector_size" attribute; arguments as in
7143 struct attribute_spec.handler. */
7146 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
7147 int ARG_UNUSED (flags
),
7150 unsigned HOST_WIDE_INT vecsize
, nunits
;
7151 enum machine_mode orig_mode
;
7152 tree type
= *node
, new_type
, size
;
7154 *no_add_attrs
= true;
7156 size
= TREE_VALUE (args
);
7158 if (!host_integerp (size
, 1))
7160 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7164 /* Get the vector size (in bytes). */
7165 vecsize
= tree_low_cst (size
, 1);
7167 /* We need to provide for vector pointers, vector arrays, and
7168 functions returning vectors. For example:
7170 __attribute__((vector_size(16))) short *foo;
7172 In this case, the mode is SI, but the type being modified is
7173 HI, so we need to look further. */
7175 while (POINTER_TYPE_P (type
)
7176 || TREE_CODE (type
) == FUNCTION_TYPE
7177 || TREE_CODE (type
) == METHOD_TYPE
7178 || TREE_CODE (type
) == ARRAY_TYPE
7179 || TREE_CODE (type
) == OFFSET_TYPE
)
7180 type
= TREE_TYPE (type
);
7182 /* Get the mode of the type being modified. */
7183 orig_mode
= TYPE_MODE (type
);
7185 if ((!INTEGRAL_TYPE_P (type
)
7186 && !SCALAR_FLOAT_TYPE_P (type
)
7187 && !FIXED_POINT_TYPE_P (type
))
7188 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
7189 && GET_MODE_CLASS (orig_mode
) != MODE_INT
7190 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode
))
7191 || !host_integerp (TYPE_SIZE_UNIT (type
), 1)
7192 || TREE_CODE (type
) == BOOLEAN_TYPE
)
7194 error ("invalid vector type for attribute %qE", name
);
7198 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
7200 error ("vector size not an integral multiple of component size");
7206 error ("zero vector size");
7210 /* Calculate how many units fit in the vector. */
7211 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
7212 if (nunits
& (nunits
- 1))
7214 error ("number of components of the vector not a power of two");
7218 new_type
= build_vector_type (type
, nunits
);
7220 /* Build back pointers if needed. */
7221 *node
= lang_hooks
.types
.reconstruct_complex_type (*node
, new_type
);
7226 /* Handle the "nonnull" attribute. */
7228 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7229 tree args
, int ARG_UNUSED (flags
),
7233 unsigned HOST_WIDE_INT attr_arg_num
;
7235 /* If no arguments are specified, all pointer arguments should be
7236 non-null. Verify a full prototype is given so that the arguments
7237 will have the correct types when we actually check them later. */
7240 if (!TYPE_ARG_TYPES (type
))
7242 error ("nonnull attribute without arguments on a non-prototype");
7243 *no_add_attrs
= true;
7248 /* Argument list specified. Verify that each argument number references
7249 a pointer argument. */
7250 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
7253 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
7255 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
7257 error ("nonnull argument has invalid operand number (argument %lu)",
7258 (unsigned long) attr_arg_num
);
7259 *no_add_attrs
= true;
7263 argument
= TYPE_ARG_TYPES (type
);
7266 for (ck_num
= 1; ; ck_num
++)
7268 if (!argument
|| ck_num
== arg_num
)
7270 argument
= TREE_CHAIN (argument
);
7274 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
7276 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7277 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7278 *no_add_attrs
= true;
7282 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
7284 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7285 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7286 *no_add_attrs
= true;
7295 /* Check the argument list of a function call for null in argument slots
7296 that are marked as requiring a non-null pointer argument. The NARGS
7297 arguments are passed in the array ARGARRAY.
7301 check_function_nonnull (tree attrs
, int nargs
, tree
*argarray
)
7306 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
7308 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
7310 args
= TREE_VALUE (a
);
7312 /* Walk the argument list. If we encounter an argument number we
7313 should check for non-null, do it. If the attribute has no args,
7314 then every pointer argument is checked (in which case the check
7315 for pointer type is done in check_nonnull_arg). */
7316 for (i
= 0; i
< nargs
; i
++)
7318 if (!args
|| nonnull_check_p (args
, i
+ 1))
7319 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
7327 /* Check that the Nth argument of a function call (counting backwards
7328 from the end) is a (pointer)0. The NARGS arguments are passed in the
7332 check_function_sentinel (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7334 tree attr
= lookup_attribute ("sentinel", attrs
);
7342 /* Skip over the named arguments. */
7343 while (typelist
&& len
< nargs
)
7345 typelist
= TREE_CHAIN (typelist
);
7349 if (TREE_VALUE (attr
))
7351 tree p
= TREE_VALUE (TREE_VALUE (attr
));
7352 pos
= TREE_INT_CST_LOW (p
);
7355 /* The sentinel must be one of the varargs, i.e.
7356 in position >= the number of fixed arguments. */
7357 if ((nargs
- 1 - pos
) < len
)
7359 warning (OPT_Wformat
,
7360 "not enough variable arguments to fit a sentinel");
7364 /* Validate the sentinel. */
7365 sentinel
= argarray
[nargs
- 1 - pos
];
7366 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
7367 || !integer_zerop (sentinel
))
7368 /* Although __null (in C++) is only an integer we allow it
7369 nevertheless, as we are guaranteed that it's exactly
7370 as wide as a pointer, and we don't want to force
7371 users to cast the NULL they have written there.
7372 We warn with -Wstrict-null-sentinel, though. */
7373 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
7374 warning (OPT_Wformat
, "missing sentinel in function call");
7378 /* Helper for check_function_nonnull; given a list of operands which
7379 must be non-null in ARGS, determine if operand PARAM_NUM should be
7383 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
7385 unsigned HOST_WIDE_INT arg_num
= 0;
7387 for (; args
; args
= TREE_CHAIN (args
))
7389 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
7393 if (arg_num
== param_num
)
7399 /* Check that the function argument PARAM (which is operand number
7400 PARAM_NUM) is non-null. This is called by check_function_nonnull
7401 via check_function_arguments_recurse. */
7404 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
7405 unsigned HOST_WIDE_INT param_num
)
7407 /* Just skip checking the argument if it's not a pointer. This can
7408 happen if the "nonnull" attribute was given without an operand
7409 list (which means to check every pointer argument). */
7411 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
7414 if (integer_zerop (param
))
7415 warning (OPT_Wnonnull
, "null argument where non-null required "
7416 "(argument %lu)", (unsigned long) param_num
);
7419 /* Helper for nonnull attribute handling; fetch the operand number
7420 from the attribute argument list. */
7423 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
7425 /* Verify the arg number is a constant. */
7426 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
7427 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
7430 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
7434 /* Handle a "nothrow" attribute; arguments as in
7435 struct attribute_spec.handler. */
7438 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7439 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7441 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7442 TREE_NOTHROW (*node
) = 1;
7443 /* ??? TODO: Support types. */
7446 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7447 *no_add_attrs
= true;
7453 /* Handle a "cleanup" attribute; arguments as in
7454 struct attribute_spec.handler. */
7457 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
7458 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7461 tree cleanup_id
, cleanup_decl
;
7463 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7464 for global destructors in C++. This requires infrastructure that
7465 we don't have generically at the moment. It's also not a feature
7466 we'd be missing too much, since we do have attribute constructor. */
7467 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
7469 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7470 *no_add_attrs
= true;
7474 /* Verify that the argument is a function in scope. */
7475 /* ??? We could support pointers to functions here as well, if
7476 that was considered desirable. */
7477 cleanup_id
= TREE_VALUE (args
);
7478 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
7480 error ("cleanup argument not an identifier");
7481 *no_add_attrs
= true;
7484 cleanup_decl
= lookup_name (cleanup_id
);
7485 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
7487 error ("cleanup argument not a function");
7488 *no_add_attrs
= true;
7492 /* That the function has proper type is checked with the
7493 eventual call to build_function_call. */
7498 /* Handle a "warn_unused_result" attribute. No special handling. */
7501 handle_warn_unused_result_attribute (tree
*node
, tree name
,
7502 tree
ARG_UNUSED (args
),
7503 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7505 /* Ignore the attribute for functions not returning any value. */
7506 if (VOID_TYPE_P (TREE_TYPE (*node
)))
7508 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7509 *no_add_attrs
= true;
7515 /* Handle a "sentinel" attribute. */
7518 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
7519 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7521 tree params
= TYPE_ARG_TYPES (*node
);
7525 warning (OPT_Wattributes
,
7526 "%qE attribute requires prototypes with named arguments", name
);
7527 *no_add_attrs
= true;
7531 while (TREE_CHAIN (params
))
7532 params
= TREE_CHAIN (params
);
7534 if (VOID_TYPE_P (TREE_VALUE (params
)))
7536 warning (OPT_Wattributes
,
7537 "%qE attribute only applies to variadic functions", name
);
7538 *no_add_attrs
= true;
7544 tree position
= TREE_VALUE (args
);
7546 if (TREE_CODE (position
) != INTEGER_CST
)
7548 warning (OPT_Wattributes
,
7549 "requested position is not an integer constant");
7550 *no_add_attrs
= true;
7554 if (tree_int_cst_lt (position
, integer_zero_node
))
7556 warning (OPT_Wattributes
,
7557 "requested position is less than zero");
7558 *no_add_attrs
= true;
7566 /* Handle a "type_generic" attribute. */
7569 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7570 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
7571 bool * ARG_UNUSED (no_add_attrs
))
7575 /* Ensure we have a function type. */
7576 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
7578 params
= TYPE_ARG_TYPES (*node
);
7579 while (params
&& ! VOID_TYPE_P (TREE_VALUE (params
)))
7580 params
= TREE_CHAIN (params
);
7582 /* Ensure we have a variadic function. */
7583 gcc_assert (!params
);
7588 /* Handle a "target" attribute. */
7591 handle_target_attribute (tree
*node
, tree name
, tree args
, int flags
,
7594 /* Ensure we have a function type. */
7595 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7597 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7598 *no_add_attrs
= true;
7600 else if (! targetm
.target_option
.valid_attribute_p (*node
, name
, args
,
7602 *no_add_attrs
= true;
7607 /* Arguments being collected for optimization. */
7608 typedef const char *const_char_p
; /* For DEF_VEC_P. */
7609 DEF_VEC_P(const_char_p
);
7610 DEF_VEC_ALLOC_P(const_char_p
, gc
);
7611 static GTY(()) VEC(const_char_p
, gc
) *optimize_args
;
7614 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7615 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7616 false for #pragma GCC optimize. */
7619 parse_optimize_options (tree args
, bool attr_p
)
7624 int saved_flag_strict_aliasing
;
7625 const char **opt_argv
;
7626 struct cl_decoded_option
*decoded_options
;
7627 unsigned int decoded_options_count
;
7630 /* Build up argv vector. Just in case the string is stored away, use garbage
7631 collected strings. */
7632 VEC_truncate (const_char_p
, optimize_args
, 0);
7633 VEC_safe_push (const_char_p
, gc
, optimize_args
, NULL
);
7635 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
7637 tree value
= TREE_VALUE (ap
);
7639 if (TREE_CODE (value
) == INTEGER_CST
)
7642 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
7643 VEC_safe_push (const_char_p
, gc
, optimize_args
, ggc_strdup (buffer
));
7646 else if (TREE_CODE (value
) == STRING_CST
)
7648 /* Split string into multiple substrings. */
7649 size_t len
= TREE_STRING_LENGTH (value
);
7650 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
7651 char *end
= p
+ len
;
7655 while (next_p
!= NULL
)
7661 comma
= strchr (p
, ',');
7674 r
= q
= (char *) ggc_alloc_atomic (len2
+ 3);
7676 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7678 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
7682 warning (OPT_Wattributes
,
7683 "Bad option %s to optimize attribute.", p
);
7685 warning (OPT_Wpragmas
,
7686 "Bad option %s to pragma attribute", p
);
7694 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7695 itself is -Os, and any other switch begins with a -f. */
7696 if ((*p
>= '0' && *p
<= '9')
7697 || (p
[0] == 's' && p
[1] == '\0'))
7703 memcpy (r
, p
, len2
);
7705 VEC_safe_push (const_char_p
, gc
, optimize_args
, q
);
7711 opt_argc
= VEC_length (const_char_p
, optimize_args
);
7712 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
7714 for (i
= 1; i
< opt_argc
; i
++)
7715 opt_argv
[i
] = VEC_index (const_char_p
, optimize_args
, i
);
7717 saved_flag_strict_aliasing
= flag_strict_aliasing
;
7719 /* Now parse the options. */
7720 decode_options (opt_argc
, opt_argv
, &decoded_options
,
7721 &decoded_options_count
);
7723 targetm
.override_options_after_change();
7725 /* Don't allow changing -fstrict-aliasing. */
7726 flag_strict_aliasing
= saved_flag_strict_aliasing
;
7728 VEC_truncate (const_char_p
, optimize_args
, 0);
7732 /* For handling "optimize" attribute. arguments as in
7733 struct attribute_spec.handler. */
7736 handle_optimize_attribute (tree
*node
, tree name
, tree args
,
7737 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7739 /* Ensure we have a function type. */
7740 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7742 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7743 *no_add_attrs
= true;
7747 struct cl_optimization cur_opts
;
7748 tree old_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
);
7750 /* Save current options. */
7751 cl_optimization_save (&cur_opts
);
7753 /* If we previously had some optimization options, use them as the
7756 cl_optimization_restore (TREE_OPTIMIZATION (old_opts
));
7758 /* Parse options, and update the vector. */
7759 parse_optimize_options (args
, true);
7760 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
)
7761 = build_optimization_node ();
7763 /* Restore current options. */
7764 cl_optimization_restore (&cur_opts
);
7770 /* Check for valid arguments being passed to a function.
7771 ATTRS is a list of attributes. There are NARGS arguments in the array
7772 ARGARRAY. TYPELIST is the list of argument types for the function.
7775 check_function_arguments (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7777 /* Check for null being passed in a pointer argument that must be
7778 non-null. We also need to do this if format checking is enabled. */
7781 check_function_nonnull (attrs
, nargs
, argarray
);
7783 /* Check for errors in format strings. */
7785 if (warn_format
|| warn_missing_format_attribute
)
7786 check_function_format (attrs
, nargs
, argarray
);
7789 check_function_sentinel (attrs
, nargs
, argarray
, typelist
);
7792 /* Generic argument checking recursion routine. PARAM is the argument to
7793 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7794 once the argument is resolved. CTX is context for the callback. */
7796 check_function_arguments_recurse (void (*callback
)
7797 (void *, tree
, unsigned HOST_WIDE_INT
),
7798 void *ctx
, tree param
,
7799 unsigned HOST_WIDE_INT param_num
)
7801 if (CONVERT_EXPR_P (param
)
7802 && (TYPE_PRECISION (TREE_TYPE (param
))
7803 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
7805 /* Strip coercion. */
7806 check_function_arguments_recurse (callback
, ctx
,
7807 TREE_OPERAND (param
, 0), param_num
);
7811 if (TREE_CODE (param
) == CALL_EXPR
)
7813 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
7815 bool found_format_arg
= false;
7817 /* See if this is a call to a known internationalization function
7818 that modifies a format arg. Such a function may have multiple
7819 format_arg attributes (for example, ngettext). */
7821 for (attrs
= TYPE_ATTRIBUTES (type
);
7823 attrs
= TREE_CHAIN (attrs
))
7824 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
7827 tree format_num_expr
;
7830 call_expr_arg_iterator iter
;
7832 /* Extract the argument number, which was previously checked
7834 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
7836 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
7837 && !TREE_INT_CST_HIGH (format_num_expr
));
7839 format_num
= TREE_INT_CST_LOW (format_num_expr
);
7841 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
7843 inner_arg
= next_call_expr_arg (&iter
), i
++)
7844 if (i
== format_num
)
7846 check_function_arguments_recurse (callback
, ctx
,
7847 inner_arg
, param_num
);
7848 found_format_arg
= true;
7853 /* If we found a format_arg attribute and did a recursive check,
7854 we are done with checking this argument. Otherwise, we continue
7855 and this will be considered a non-literal. */
7856 if (found_format_arg
)
7860 if (TREE_CODE (param
) == COND_EXPR
)
7862 /* Check both halves of the conditional expression. */
7863 check_function_arguments_recurse (callback
, ctx
,
7864 TREE_OPERAND (param
, 1), param_num
);
7865 check_function_arguments_recurse (callback
, ctx
,
7866 TREE_OPERAND (param
, 2), param_num
);
7870 (*callback
) (ctx
, param
, param_num
);
7873 /* Checks for a builtin function FNDECL that the number of arguments
7874 NARGS against the required number REQUIRED and issues an error if
7875 there is a mismatch. Returns true if the number of arguments is
7876 correct, otherwise false. */
7879 builtin_function_validate_nargs (tree fndecl
, int nargs
, int required
)
7881 if (nargs
< required
)
7883 error_at (input_location
,
7884 "not enough arguments to function %qE", fndecl
);
7887 else if (nargs
> required
)
7889 error_at (input_location
,
7890 "too many arguments to function %qE", fndecl
);
7896 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7897 Returns false if there was an error, otherwise true. */
7900 check_builtin_function_arguments (tree fndecl
, int nargs
, tree
*args
)
7902 if (!DECL_BUILT_IN (fndecl
)
7903 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
7906 switch (DECL_FUNCTION_CODE (fndecl
))
7908 case BUILT_IN_CONSTANT_P
:
7909 return builtin_function_validate_nargs (fndecl
, nargs
, 1);
7911 case BUILT_IN_ISFINITE
:
7912 case BUILT_IN_ISINF
:
7913 case BUILT_IN_ISINF_SIGN
:
7914 case BUILT_IN_ISNAN
:
7915 case BUILT_IN_ISNORMAL
:
7916 if (builtin_function_validate_nargs (fndecl
, nargs
, 1))
7918 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
7920 error ("non-floating-point argument in call to "
7921 "function %qE", fndecl
);
7928 case BUILT_IN_ISGREATER
:
7929 case BUILT_IN_ISGREATEREQUAL
:
7930 case BUILT_IN_ISLESS
:
7931 case BUILT_IN_ISLESSEQUAL
:
7932 case BUILT_IN_ISLESSGREATER
:
7933 case BUILT_IN_ISUNORDERED
:
7934 if (builtin_function_validate_nargs (fndecl
, nargs
, 2))
7936 enum tree_code code0
, code1
;
7937 code0
= TREE_CODE (TREE_TYPE (args
[0]));
7938 code1
= TREE_CODE (TREE_TYPE (args
[1]));
7939 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
7940 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
7941 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
7943 error ("non-floating-point arguments in call to "
7944 "function %qE", fndecl
);
7951 case BUILT_IN_FPCLASSIFY
:
7952 if (builtin_function_validate_nargs (fndecl
, nargs
, 6))
7957 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
7959 error ("non-const integer argument %u in call to function %qE",
7964 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
7966 error ("non-floating-point argument in call to function %qE",
7979 /* Function to help qsort sort FIELD_DECLs by name order. */
7982 field_decl_cmp (const void *x_p
, const void *y_p
)
7984 const tree
*const x
= (const tree
*const) x_p
;
7985 const tree
*const y
= (const tree
*const) y_p
;
7987 if (DECL_NAME (*x
) == DECL_NAME (*y
))
7988 /* A nontype is "greater" than a type. */
7989 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
7990 if (DECL_NAME (*x
) == NULL_TREE
)
7992 if (DECL_NAME (*y
) == NULL_TREE
)
7994 if (DECL_NAME (*x
) < DECL_NAME (*y
))
8000 gt_pointer_operator new_value
;
8004 /* This routine compares two fields like field_decl_cmp but using the
8005 pointer operator in resort_data. */
8008 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
8010 const tree
*const x
= (const tree
*const) x_p
;
8011 const tree
*const y
= (const tree
*const) y_p
;
8013 if (DECL_NAME (*x
) == DECL_NAME (*y
))
8014 /* A nontype is "greater" than a type. */
8015 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
8016 if (DECL_NAME (*x
) == NULL_TREE
)
8018 if (DECL_NAME (*y
) == NULL_TREE
)
8021 tree d1
= DECL_NAME (*x
);
8022 tree d2
= DECL_NAME (*y
);
8023 resort_data
.new_value (&d1
, resort_data
.cookie
);
8024 resort_data
.new_value (&d2
, resort_data
.cookie
);
8031 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8034 resort_sorted_fields (void *obj
,
8035 void * ARG_UNUSED (orig_obj
),
8036 gt_pointer_operator new_value
,
8039 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
8040 resort_data
.new_value
= new_value
;
8041 resort_data
.cookie
= cookie
;
8042 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
8043 resort_field_decl_cmp
);
8046 /* Subroutine of c_parse_error.
8047 Return the result of concatenating LHS and RHS. RHS is really
8048 a string literal, its first character is indicated by RHS_START and
8049 RHS_SIZE is its length (including the terminating NUL character).
8051 The caller is responsible for deleting the returned pointer. */
8054 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
8056 const int lhs_size
= strlen (lhs
);
8057 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
8058 strncpy (result
, lhs
, lhs_size
);
8059 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
8063 /* Issue the error given by GMSGID, indicating that it occurred before
8064 TOKEN, which had the associated VALUE. */
8067 c_parse_error (const char *gmsgid
, enum cpp_ttype token_type
,
8068 tree value
, unsigned char token_flags
)
8070 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8072 char *message
= NULL
;
8074 if (token_type
== CPP_EOF
)
8075 message
= catenate_messages (gmsgid
, " at end of input");
8076 else if (token_type
== CPP_CHAR
8077 || token_type
== CPP_WCHAR
8078 || token_type
== CPP_CHAR16
8079 || token_type
== CPP_CHAR32
)
8081 unsigned int val
= TREE_INT_CST_LOW (value
);
8100 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
8101 message
= catenate_messages (gmsgid
, " before %s'%c'");
8103 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
8105 error (message
, prefix
, val
);
8109 else if (token_type
== CPP_STRING
8110 || token_type
== CPP_WSTRING
8111 || token_type
== CPP_STRING16
8112 || token_type
== CPP_STRING32
8113 || token_type
== CPP_UTF8STRING
)
8114 message
= catenate_messages (gmsgid
, " before string constant");
8115 else if (token_type
== CPP_NUMBER
)
8116 message
= catenate_messages (gmsgid
, " before numeric constant");
8117 else if (token_type
== CPP_NAME
)
8119 message
= catenate_messages (gmsgid
, " before %qE");
8120 error (message
, value
);
8124 else if (token_type
== CPP_PRAGMA
)
8125 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
8126 else if (token_type
== CPP_PRAGMA_EOL
)
8127 message
= catenate_messages (gmsgid
, " before end of line");
8128 else if (token_type
< N_TTYPES
)
8130 message
= catenate_messages (gmsgid
, " before %qs token");
8131 error (message
, cpp_type2name (token_type
, token_flags
));
8143 #undef catenate_messages
8146 /* Mapping for cpp message reasons to the options that enable them. */
8148 struct reason_option_codes_t
8150 const int reason
; /* cpplib message reason. */
8151 const int option_code
; /* gcc option that controls this message. */
8154 static const struct reason_option_codes_t option_codes
[] = {
8155 {CPP_W_DEPRECATED
, OPT_Wdeprecated
},
8156 {CPP_W_COMMENTS
, OPT_Wcomments
},
8157 {CPP_W_TRIGRAPHS
, OPT_Wtrigraphs
},
8158 {CPP_W_MULTICHAR
, OPT_Wmultichar
},
8159 {CPP_W_TRADITIONAL
, OPT_Wtraditional
},
8160 {CPP_W_LONG_LONG
, OPT_Wlong_long
},
8161 {CPP_W_ENDIF_LABELS
, OPT_Wendif_labels
},
8162 {CPP_W_VARIADIC_MACROS
, OPT_Wvariadic_macros
},
8163 {CPP_W_BUILTIN_MACRO_REDEFINED
, OPT_Wbuiltin_macro_redefined
},
8164 {CPP_W_UNDEF
, OPT_Wundef
},
8165 {CPP_W_UNUSED_MACROS
, OPT_Wunused_macros
},
8166 {CPP_W_CXX_OPERATOR_NAMES
, OPT_Wc___compat
},
8167 {CPP_W_NORMALIZE
, OPT_Wnormalized_
},
8168 {CPP_W_INVALID_PCH
, OPT_Winvalid_pch
},
8169 {CPP_W_WARNING_DIRECTIVE
, OPT_Wcpp
},
8173 /* Return the gcc option code associated with the reason for a cpp
8174 message, or 0 if none. */
8177 c_option_controlling_cpp_error (int reason
)
8179 const struct reason_option_codes_t
*entry
;
8181 for (entry
= option_codes
; entry
->reason
!= CPP_W_NONE
; entry
++)
8183 if (entry
->reason
== reason
)
8184 return entry
->option_code
;
8189 /* Callback from cpp_error for PFILE to print diagnostics from the
8190 preprocessor. The diagnostic is of type LEVEL, with REASON set
8191 to the reason code if LEVEL is represents a warning, at location
8192 LOCATION unless this is after lexing and the compiler's location
8193 should be used instead, with column number possibly overridden by
8194 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8195 the arguments. Returns true if a diagnostic was emitted, false
8199 c_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
, int reason
,
8200 location_t location
, unsigned int column_override
,
8201 const char *msg
, va_list *ap
)
8203 diagnostic_info diagnostic
;
8204 diagnostic_t dlevel
;
8205 bool save_warn_system_headers
= global_dc
->warn_system_headers
;
8210 case CPP_DL_WARNING_SYSHDR
:
8213 global_dc
->warn_system_headers
= 1;
8215 case CPP_DL_WARNING
:
8218 dlevel
= DK_WARNING
;
8220 case CPP_DL_PEDWARN
:
8221 if (flag_no_output
&& !flag_pedantic_errors
)
8223 dlevel
= DK_PEDWARN
;
8241 location
= input_location
;
8242 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
8244 if (column_override
)
8245 diagnostic_override_column (&diagnostic
, column_override
);
8246 diagnostic_override_option_index (&diagnostic
,
8247 c_option_controlling_cpp_error (reason
));
8248 ret
= report_diagnostic (&diagnostic
);
8249 if (level
== CPP_DL_WARNING_SYSHDR
)
8250 global_dc
->warn_system_headers
= save_warn_system_headers
;
8254 /* Convert a character from the host to the target execution character
8255 set. cpplib handles this, mostly. */
8258 c_common_to_target_charset (HOST_WIDE_INT c
)
8260 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8261 zero-extended under -fno-signed-char. cpplib insists that characters
8262 and character constants are always unsigned. Hence we must convert
8264 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
8266 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
8268 if (flag_signed_char
)
8269 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
8270 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
8275 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8276 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8277 NULL, at the bottom; much like the traditional rendering of offsetof as a
8278 macro. Returns the folded and properly cast result. */
8281 fold_offsetof_1 (tree expr
, tree stop_ref
)
8283 enum tree_code code
= PLUS_EXPR
;
8286 if (expr
== stop_ref
&& TREE_CODE (expr
) != ERROR_MARK
)
8287 return size_zero_node
;
8289 switch (TREE_CODE (expr
))
8295 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
8296 return error_mark_node
;
8300 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8301 return error_mark_node
;
8305 if (!integer_zerop (TREE_OPERAND (expr
, 0)))
8307 error ("cannot apply %<offsetof%> to a non constant address");
8308 return error_mark_node
;
8310 return size_zero_node
;
8313 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8314 if (base
== error_mark_node
)
8317 t
= TREE_OPERAND (expr
, 1);
8318 if (DECL_C_BIT_FIELD (t
))
8320 error ("attempt to take address of bit-field structure "
8322 return error_mark_node
;
8324 off
= size_binop_loc (input_location
, PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
8325 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
),
8331 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8332 if (base
== error_mark_node
)
8335 t
= TREE_OPERAND (expr
, 1);
8336 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) < 0)
8339 t
= fold_build1_loc (input_location
, NEGATE_EXPR
, TREE_TYPE (t
), t
);
8341 t
= convert (sizetype
, t
);
8342 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
8344 /* Check if the offset goes beyond the upper bound of the array. */
8345 if (code
== PLUS_EXPR
&& TREE_CODE (t
) == INTEGER_CST
)
8347 tree upbound
= array_ref_up_bound (expr
);
8348 if (upbound
!= NULL_TREE
8349 && TREE_CODE (upbound
) == INTEGER_CST
8350 && !tree_int_cst_equal (upbound
,
8351 TYPE_MAX_VALUE (TREE_TYPE (upbound
))))
8353 upbound
= size_binop (PLUS_EXPR
, upbound
,
8354 build_int_cst (TREE_TYPE (upbound
), 1));
8355 if (tree_int_cst_lt (upbound
, t
))
8359 for (v
= TREE_OPERAND (expr
, 0);
8360 TREE_CODE (v
) == COMPONENT_REF
;
8361 v
= TREE_OPERAND (v
, 0))
8362 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v
, 0)))
8365 tree fld_chain
= TREE_CHAIN (TREE_OPERAND (v
, 1));
8366 for (; fld_chain
; fld_chain
= TREE_CHAIN (fld_chain
))
8367 if (TREE_CODE (fld_chain
) == FIELD_DECL
)
8373 /* Don't warn if the array might be considered a poor
8374 man's flexible array member with a very permissive
8375 definition thereof. */
8376 if (TREE_CODE (v
) == ARRAY_REF
8377 || TREE_CODE (v
) == COMPONENT_REF
)
8378 warning (OPT_Warray_bounds
,
8379 "index %E denotes an offset "
8380 "greater than size of %qT",
8381 t
, TREE_TYPE (TREE_OPERAND (expr
, 0)));
8388 /* Handle static members of volatile structs. */
8389 t
= TREE_OPERAND (expr
, 1);
8390 gcc_assert (TREE_CODE (t
) == VAR_DECL
);
8391 return fold_offsetof_1 (t
, stop_ref
);
8397 return size_binop (code
, base
, off
);
8401 fold_offsetof (tree expr
, tree stop_ref
)
8403 /* Convert back from the internal sizetype to size_t. */
8404 return convert (size_type_node
, fold_offsetof_1 (expr
, stop_ref
));
8407 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
8408 expression, because B will always be true. */
8411 warn_for_omitted_condop (location_t location
, tree cond
)
8413 if (truth_value_p (TREE_CODE (cond
)))
8414 warning_at (location
, OPT_Wparentheses
,
8415 "the omitted middle operand in ?: will always be %<true%>, "
8416 "suggest explicit middle operand");
8419 /* Print an error message for an invalid lvalue. USE says
8420 how the lvalue is being used and so selects the error message. */
8423 lvalue_error (enum lvalue_use use
)
8428 error ("lvalue required as left operand of assignment");
8431 error ("lvalue required as increment operand");
8434 error ("lvalue required as decrement operand");
8437 error ("lvalue required as unary %<&%> operand");
8440 error ("lvalue required in asm statement");
8447 /* *PTYPE is an incomplete array. Complete it with a domain based on
8448 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8449 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8450 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8453 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8455 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
8456 int failure
= 0, quals
;
8457 hashval_t hashcode
= 0;
8459 maxindex
= size_zero_node
;
8462 if (TREE_CODE (initial_value
) == STRING_CST
)
8465 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8466 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
8468 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8470 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
8472 if (VEC_empty (constructor_elt
, v
))
8476 maxindex
= integer_minus_one_node
;
8481 unsigned HOST_WIDE_INT cnt
;
8482 constructor_elt
*ce
;
8483 bool fold_p
= false;
8485 if (VEC_index (constructor_elt
, v
, 0)->index
)
8486 maxindex
= fold_convert_loc (input_location
, sizetype
,
8487 VEC_index (constructor_elt
,
8489 curindex
= maxindex
;
8492 VEC_iterate (constructor_elt
, v
, cnt
, ce
);
8495 bool curfold_p
= false;
8497 curindex
= ce
->index
, curfold_p
= true;
8501 curindex
= fold_convert (sizetype
, curindex
);
8502 curindex
= size_binop (PLUS_EXPR
, curindex
,
8505 if (tree_int_cst_lt (maxindex
, curindex
))
8506 maxindex
= curindex
, fold_p
= curfold_p
;
8509 maxindex
= fold_convert (sizetype
, maxindex
);
8514 /* Make an error message unless that happened already. */
8515 if (initial_value
!= error_mark_node
)
8527 elt
= TREE_TYPE (type
);
8528 quals
= TYPE_QUALS (strip_array_types (elt
));
8532 unqual_elt
= c_build_qualified_type (elt
, KEEP_QUAL_ADDR_SPACE (quals
));
8534 /* Using build_distinct_type_copy and modifying things afterward instead
8535 of using build_array_type to create a new type preserves all of the
8536 TYPE_LANG_FLAG_? bits that the front end may have set. */
8537 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
8538 TREE_TYPE (main_type
) = unqual_elt
;
8539 TYPE_DOMAIN (main_type
) = build_index_type (maxindex
);
8540 layout_type (main_type
);
8542 /* Make sure we have the canonical MAIN_TYPE. */
8543 hashcode
= iterative_hash_object (TYPE_HASH (unqual_elt
), hashcode
);
8544 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type
)),
8546 main_type
= type_hash_canon (hashcode
, main_type
);
8548 /* Fix the canonical type. */
8549 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
8550 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
8551 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
8552 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
8553 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
8554 != TYPE_DOMAIN (main_type
)))
8555 TYPE_CANONICAL (main_type
)
8556 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
8557 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)));
8559 TYPE_CANONICAL (main_type
) = main_type
;
8564 type
= c_build_qualified_type (main_type
, quals
);
8566 if (COMPLETE_TYPE_P (type
)
8567 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
8568 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
8570 error ("size of array is too large");
8571 /* If we proceed with the array type as it is, we'll eventually
8572 crash in tree_low_cst(). */
8573 type
= error_mark_node
;
8581 /* Used to help initialize the builtin-types.def table. When a type of
8582 the correct size doesn't exist, use error_mark_node instead of NULL.
8583 The later results in segfaults even when a decl using the type doesn't
8587 builtin_type_for_size (int size
, bool unsignedp
)
8589 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
8590 return type
? type
: error_mark_node
;
8593 /* A helper function for resolve_overloaded_builtin in resolving the
8594 overloaded __sync_ builtins. Returns a positive power of 2 if the
8595 first operand of PARAMS is a pointer to a supported data type.
8596 Returns 0 if an error is encountered. */
8599 sync_resolve_size (tree function
, VEC(tree
,gc
) *params
)
8604 if (VEC_empty (tree
, params
))
8606 error ("too few arguments to function %qE", function
);
8610 type
= TREE_TYPE (VEC_index (tree
, params
, 0));
8611 if (TREE_CODE (type
) != POINTER_TYPE
)
8614 type
= TREE_TYPE (type
);
8615 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
8618 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
8619 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
8623 error ("incompatible type for argument %d of %qE", 1, function
);
8627 /* A helper function for resolve_overloaded_builtin. Adds casts to
8628 PARAMS to make arguments match up with those of FUNCTION. Drops
8629 the variadic arguments at the end. Returns false if some error
8630 was encountered; true on success. */
8633 sync_resolve_params (tree orig_function
, tree function
, VEC(tree
, gc
) *params
)
8635 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
8637 unsigned int parmnum
;
8639 /* We've declared the implementation functions to use "volatile void *"
8640 as the pointer parameter, so we shouldn't get any complaints from the
8641 call to check_function_arguments what ever type the user used. */
8642 arg_types
= TREE_CHAIN (arg_types
);
8643 ptype
= TREE_TYPE (TREE_TYPE (VEC_index (tree
, params
, 0)));
8645 /* For the rest of the values, we need to cast these to FTYPE, so that we
8646 don't get warnings for passing pointer types, etc. */
8648 while (arg_types
!= void_list_node
)
8653 if (VEC_length (tree
, params
) <= parmnum
)
8655 error ("too few arguments to function %qE", orig_function
);
8659 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8660 so that we get warnings for anything that doesn't match the pointer
8661 type. This isn't portable across the C and C++ front ends atm. */
8662 val
= VEC_index (tree
, params
, parmnum
);
8663 val
= convert (ptype
, val
);
8664 val
= convert (TREE_VALUE (arg_types
), val
);
8665 VEC_replace (tree
, params
, parmnum
, val
);
8667 arg_types
= TREE_CHAIN (arg_types
);
8670 /* The definition of these primitives is variadic, with the remaining
8671 being "an optional list of variables protected by the memory barrier".
8672 No clue what that's supposed to mean, precisely, but we consider all
8673 call-clobbered variables to be protected so we're safe. */
8674 VEC_truncate (tree
, params
, parmnum
+ 1);
8679 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8680 RESULT to make it match the type of the first pointer argument in
8684 sync_resolve_return (tree first_param
, tree result
)
8686 tree ptype
= TREE_TYPE (TREE_TYPE (first_param
));
8687 ptype
= TYPE_MAIN_VARIANT (ptype
);
8688 return convert (ptype
, result
);
8691 /* Some builtin functions are placeholders for other expressions. This
8692 function should be called immediately after parsing the call expression
8693 before surrounding code has committed to the type of the expression.
8695 LOC is the location of the builtin call.
8697 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8698 PARAMS is the argument list for the call. The return value is non-null
8699 when expansion is complete, and null if normal processing should
8703 resolve_overloaded_builtin (location_t loc
, tree function
, VEC(tree
,gc
) *params
)
8705 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
8706 switch (DECL_BUILT_IN_CLASS (function
))
8708 case BUILT_IN_NORMAL
:
8711 if (targetm
.resolve_overloaded_builtin
)
8712 return targetm
.resolve_overloaded_builtin (loc
, function
, params
);
8719 /* Handle BUILT_IN_NORMAL here. */
8722 case BUILT_IN_FETCH_AND_ADD_N
:
8723 case BUILT_IN_FETCH_AND_SUB_N
:
8724 case BUILT_IN_FETCH_AND_OR_N
:
8725 case BUILT_IN_FETCH_AND_AND_N
:
8726 case BUILT_IN_FETCH_AND_XOR_N
:
8727 case BUILT_IN_FETCH_AND_NAND_N
:
8728 case BUILT_IN_ADD_AND_FETCH_N
:
8729 case BUILT_IN_SUB_AND_FETCH_N
:
8730 case BUILT_IN_OR_AND_FETCH_N
:
8731 case BUILT_IN_AND_AND_FETCH_N
:
8732 case BUILT_IN_XOR_AND_FETCH_N
:
8733 case BUILT_IN_NAND_AND_FETCH_N
:
8734 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N
:
8735 case BUILT_IN_VAL_COMPARE_AND_SWAP_N
:
8736 case BUILT_IN_LOCK_TEST_AND_SET_N
:
8737 case BUILT_IN_LOCK_RELEASE_N
:
8739 int n
= sync_resolve_size (function
, params
);
8740 tree new_function
, first_param
, result
;
8743 return error_mark_node
;
8745 new_function
= built_in_decls
[orig_code
+ exact_log2 (n
) + 1];
8746 if (!sync_resolve_params (function
, new_function
, params
))
8747 return error_mark_node
;
8749 first_param
= VEC_index (tree
, params
, 0);
8750 result
= build_function_call_vec (loc
, new_function
, params
, NULL
);
8751 if (orig_code
!= BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8752 && orig_code
!= BUILT_IN_LOCK_RELEASE_N
)
8753 result
= sync_resolve_return (first_param
, result
);
8763 /* Ignoring their sign, return true if two scalar types are the same. */
8765 same_scalar_type_ignoring_signedness (tree t1
, tree t2
)
8767 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
8769 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
|| c1
== FIXED_POINT_TYPE
)
8770 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
8771 || c2
== FIXED_POINT_TYPE
));
8773 /* Equality works here because c_common_signed_type uses
8774 TYPE_MAIN_VARIANT. */
8775 return c_common_signed_type (t1
)
8776 == c_common_signed_type (t2
);
8779 /* Check for missing format attributes on function pointers. LTYPE is
8780 the new type or left-hand side type. RTYPE is the old type or
8781 right-hand side type. Returns TRUE if LTYPE is missing the desired
8785 check_missing_format_attribute (tree ltype
, tree rtype
)
8787 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
8790 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
8791 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
8796 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
8797 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
8805 /* Subscripting with type char is likely to lose on a machine where
8806 chars are signed. So warn on any machine, but optionally. Don't
8807 warn for unsigned char since that type is safe. Don't warn for
8808 signed char because anyone who uses that must have done so
8809 deliberately. Furthermore, we reduce the false positive load by
8810 warning only for non-constant value of type char. */
8813 warn_array_subscript_with_type_char (tree index
)
8815 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
8816 && TREE_CODE (index
) != INTEGER_CST
)
8817 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
8820 /* Implement -Wparentheses for the unexpected C precedence rules, to
8821 cover cases like x + y << z which readers are likely to
8822 misinterpret. We have seen an expression in which CODE is a binary
8823 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8824 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8825 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8826 expression was not formed using a binary or unary operator, or it
8827 was enclosed in parentheses. */
8830 warn_about_parentheses (enum tree_code code
,
8831 enum tree_code code_left
, tree arg_left
,
8832 enum tree_code code_right
, tree arg_right
)
8834 if (!warn_parentheses
)
8837 /* This macro tests that the expression ARG with original tree code
8838 CODE appears to be a boolean expression. or the result of folding a
8839 boolean expression. */
8840 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8841 (truth_value_p (TREE_CODE (ARG)) \
8842 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8843 /* Folding may create 0 or 1 integers from other expressions. */ \
8844 || ((CODE) != INTEGER_CST \
8845 && (integer_onep (ARG) || integer_zerop (ARG))))
8850 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8851 warning (OPT_Wparentheses
,
8852 "suggest parentheses around %<+%> inside %<<<%>");
8853 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8854 warning (OPT_Wparentheses
,
8855 "suggest parentheses around %<-%> inside %<<<%>");
8859 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8860 warning (OPT_Wparentheses
,
8861 "suggest parentheses around %<+%> inside %<>>%>");
8862 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8863 warning (OPT_Wparentheses
,
8864 "suggest parentheses around %<-%> inside %<>>%>");
8867 case TRUTH_ORIF_EXPR
:
8868 if (code_left
== TRUTH_ANDIF_EXPR
|| code_right
== TRUTH_ANDIF_EXPR
)
8869 warning (OPT_Wparentheses
,
8870 "suggest parentheses around %<&&%> within %<||%>");
8874 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
8875 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8876 || code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
8877 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8878 warning (OPT_Wparentheses
,
8879 "suggest parentheses around arithmetic in operand of %<|%>");
8880 /* Check cases like x|y==z */
8881 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8882 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8883 warning (OPT_Wparentheses
,
8884 "suggest parentheses around comparison in operand of %<|%>");
8885 /* Check cases like !x | y */
8886 else if (code_left
== TRUTH_NOT_EXPR
8887 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
8888 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
8889 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8893 if (code_left
== BIT_AND_EXPR
8894 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8895 || code_right
== BIT_AND_EXPR
8896 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8897 warning (OPT_Wparentheses
,
8898 "suggest parentheses around arithmetic in operand of %<^%>");
8899 /* Check cases like x^y==z */
8900 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8901 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8902 warning (OPT_Wparentheses
,
8903 "suggest parentheses around comparison in operand of %<^%>");
8907 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8908 warning (OPT_Wparentheses
,
8909 "suggest parentheses around %<+%> in operand of %<&%>");
8910 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8911 warning (OPT_Wparentheses
,
8912 "suggest parentheses around %<-%> in operand of %<&%>");
8913 /* Check cases like x&y==z */
8914 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8915 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8916 warning (OPT_Wparentheses
,
8917 "suggest parentheses around comparison in operand of %<&%>");
8918 /* Check cases like !x & y */
8919 else if (code_left
== TRUTH_NOT_EXPR
8920 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
8921 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
8922 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8926 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8927 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8928 warning (OPT_Wparentheses
,
8929 "suggest parentheses around comparison in operand of %<==%>");
8932 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8933 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8934 warning (OPT_Wparentheses
,
8935 "suggest parentheses around comparison in operand of %<!=%>");
8939 if (TREE_CODE_CLASS (code
) == tcc_comparison
8940 && ((TREE_CODE_CLASS (code_left
) == tcc_comparison
8941 && code_left
!= NE_EXPR
&& code_left
!= EQ_EXPR
8942 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left
)))
8943 || (TREE_CODE_CLASS (code_right
) == tcc_comparison
8944 && code_right
!= NE_EXPR
&& code_right
!= EQ_EXPR
8945 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right
)))))
8946 warning (OPT_Wparentheses
, "comparisons like %<X<=Y<=Z%> do not "
8947 "have their mathematical meaning");
8950 #undef NOT_A_BOOLEAN_EXPR_P
8953 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8956 warn_for_unused_label (tree label
)
8958 if (!TREE_USED (label
))
8960 if (DECL_INITIAL (label
))
8961 warning (OPT_Wunused_label
, "label %q+D defined but not used", label
);
8963 warning (OPT_Wunused_label
, "label %q+D declared but not defined", label
);
8967 #ifndef TARGET_HAS_TARGETCM
8968 struct gcc_targetcm targetcm
= TARGETCM_INITIALIZER
;
8971 /* Warn for division by zero according to the value of DIVISOR. LOC
8972 is the location of the division operator. */
8975 warn_for_div_by_zero (location_t loc
, tree divisor
)
8977 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8978 about division by zero. Do not issue a warning if DIVISOR has a
8979 floating-point type, since we consider 0.0/0.0 a valid way of
8980 generating a NaN. */
8981 if (c_inhibit_evaluation_warnings
== 0
8982 && (integer_zerop (divisor
) || fixed_zerop (divisor
)))
8983 warning_at (loc
, OPT_Wdiv_by_zero
, "division by zero");
8986 /* Subroutine of build_binary_op. Give warnings for comparisons
8987 between signed and unsigned quantities that may fail. Do the
8988 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8989 so that casts will be considered, but default promotions won't
8992 LOCATION is the location of the comparison operator.
8994 The arguments of this function map directly to local variables
8995 of build_binary_op. */
8998 warn_for_sign_compare (location_t location
,
8999 tree orig_op0
, tree orig_op1
,
9001 tree result_type
, enum tree_code resultcode
)
9003 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
9004 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
9005 int unsignedp0
, unsignedp1
;
9007 /* In C++, check for comparison of different enum types. */
9009 && TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
9010 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
9011 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
9012 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
9014 warning_at (location
,
9015 OPT_Wsign_compare
, "comparison between types %qT and %qT",
9016 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
9019 /* Do not warn if the comparison is being done in a signed type,
9020 since the signed type will only be chosen if it can represent
9021 all the values of the unsigned type. */
9022 if (!TYPE_UNSIGNED (result_type
))
9024 /* Do not warn if both operands are unsigned. */
9025 else if (op0_signed
== op1_signed
)
9029 tree sop
, uop
, base_type
;
9033 sop
= orig_op0
, uop
= orig_op1
;
9035 sop
= orig_op1
, uop
= orig_op0
;
9037 STRIP_TYPE_NOPS (sop
);
9038 STRIP_TYPE_NOPS (uop
);
9039 base_type
= (TREE_CODE (result_type
) == COMPLEX_TYPE
9040 ? TREE_TYPE (result_type
) : result_type
);
9042 /* Do not warn if the signed quantity is an unsuffixed integer
9043 literal (or some static constant expression involving such
9044 literals or a conditional expression involving such literals)
9045 and it is non-negative. */
9046 if (tree_expr_nonnegative_warnv_p (sop
, &ovf
))
9048 /* Do not warn if the comparison is an equality operation, the
9049 unsigned quantity is an integral constant, and it would fit
9050 in the result if the result were signed. */
9051 else if (TREE_CODE (uop
) == INTEGER_CST
9052 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
9053 && int_fits_type_p (uop
, c_common_signed_type (base_type
)))
9055 /* In C, do not warn if the unsigned quantity is an enumeration
9056 constant and its maximum value would fit in the result if the
9057 result were signed. */
9058 else if (!c_dialect_cxx() && TREE_CODE (uop
) == INTEGER_CST
9059 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
9060 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
9061 c_common_signed_type (base_type
)))
9064 warning_at (location
,
9066 "comparison between signed and unsigned integer expressions");
9069 /* Warn if two unsigned values are being compared in a size larger
9070 than their original size, and one (and only one) is the result of
9071 a `~' operator. This comparison will always fail.
9073 Also warn if one operand is a constant, and the constant does not
9074 have all bits set that are set in the ~ operand when it is
9077 op0
= get_narrower (op0
, &unsignedp0
);
9078 op1
= get_narrower (op1
, &unsignedp1
);
9080 if ((TREE_CODE (op0
) == BIT_NOT_EXPR
)
9081 ^ (TREE_CODE (op1
) == BIT_NOT_EXPR
))
9083 if (TREE_CODE (op0
) == BIT_NOT_EXPR
)
9084 op0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
9085 if (TREE_CODE (op1
) == BIT_NOT_EXPR
)
9086 op1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
9088 if (host_integerp (op0
, 0) || host_integerp (op1
, 0))
9091 HOST_WIDE_INT constant
, mask
;
9095 if (host_integerp (op0
, 0))
9098 unsignedp
= unsignedp1
;
9099 constant
= tree_low_cst (op0
, 0);
9104 unsignedp
= unsignedp0
;
9105 constant
= tree_low_cst (op1
, 0);
9108 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
9109 if (bits
< TYPE_PRECISION (result_type
)
9110 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
9112 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
9113 if ((mask
& constant
) != mask
)
9116 warning (OPT_Wsign_compare
,
9117 "promoted ~unsigned is always non-zero");
9119 warning_at (location
, OPT_Wsign_compare
,
9120 "comparison of promoted ~unsigned with constant");
9124 else if (unsignedp0
&& unsignedp1
9125 && (TYPE_PRECISION (TREE_TYPE (op0
))
9126 < TYPE_PRECISION (result_type
))
9127 && (TYPE_PRECISION (TREE_TYPE (op1
))
9128 < TYPE_PRECISION (result_type
)))
9129 warning_at (location
, OPT_Wsign_compare
,
9130 "comparison of promoted ~unsigned with unsigned");
9134 /* Setup a TYPE_DECL node as a typedef representation.
9136 X is a TYPE_DECL for a typedef statement. Create a brand new
9137 ..._TYPE node (which will be just a variant of the existing
9138 ..._TYPE node with identical properties) and then install X
9139 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9141 The whole point here is to end up with a situation where each
9142 and every ..._TYPE node the compiler creates will be uniquely
9143 associated with AT MOST one node representing a typedef name.
9144 This way, even though the compiler substitutes corresponding
9145 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9146 early on, later parts of the compiler can always do the reverse
9147 translation and get back the corresponding typedef name. For
9150 typedef struct S MY_TYPE;
9153 Later parts of the compiler might only know that `object' was of
9154 type `struct S' if it were not for code just below. With this
9155 code however, later parts of the compiler see something like:
9157 struct S' == struct S
9158 typedef struct S' MY_TYPE;
9161 And they can then deduce (from the node for type struct S') that
9162 the original object declaration was:
9166 Being able to do this is important for proper support of protoize,
9167 and also for generating precise symbolic debugging information
9168 which takes full account of the programmer's (typedef) vocabulary.
9170 Obviously, we don't want to generate a duplicate ..._TYPE node if
9171 the TYPE_DECL node that we are now processing really represents a
9172 standard built-in type. */
9175 set_underlying_type (tree x
)
9177 if (x
== error_mark_node
)
9179 if (DECL_IS_BUILTIN (x
))
9181 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
9182 TYPE_NAME (TREE_TYPE (x
)) = x
;
9184 else if (TREE_TYPE (x
) != error_mark_node
9185 && DECL_ORIGINAL_TYPE (x
) == NULL_TREE
)
9187 tree tt
= TREE_TYPE (x
);
9188 DECL_ORIGINAL_TYPE (x
) = tt
;
9189 tt
= build_variant_type_copy (tt
);
9190 TYPE_STUB_DECL (tt
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
9192 TREE_USED (tt
) = TREE_USED (x
);
9197 /* Record the types used by the current global variable declaration
9198 being parsed, so that we can decide later to emit their debug info.
9199 Those types are in types_used_by_cur_var_decl, and we are going to
9200 store them in the types_used_by_vars_hash hash table.
9201 DECL is the declaration of the global variable that has been parsed. */
9204 record_types_used_by_current_var_decl (tree decl
)
9206 gcc_assert (decl
&& DECL_P (decl
) && TREE_STATIC (decl
));
9208 while (!VEC_empty (tree
, types_used_by_cur_var_decl
))
9210 tree type
= VEC_pop (tree
, types_used_by_cur_var_decl
);
9211 types_used_by_var_decl_insert (type
, decl
);
9215 /* The C and C++ parsers both use vectors to hold function arguments.
9216 For efficiency, we keep a cache of unused vectors. This is the
9219 typedef VEC(tree
,gc
)* tree_gc_vec
;
9220 DEF_VEC_P(tree_gc_vec
);
9221 DEF_VEC_ALLOC_P(tree_gc_vec
,gc
);
9222 static GTY((deletable
)) VEC(tree_gc_vec
,gc
) *tree_vector_cache
;
9224 /* Return a new vector from the cache. If the cache is empty,
9225 allocate a new vector. These vectors are GC'ed, so it is OK if the
9226 pointer is not released.. */
9229 make_tree_vector (void)
9231 if (!VEC_empty (tree_gc_vec
, tree_vector_cache
))
9232 return VEC_pop (tree_gc_vec
, tree_vector_cache
);
9235 /* Passing 0 to VEC_alloc returns NULL, and our callers require
9236 that we always return a non-NULL value. The vector code uses
9237 4 when growing a NULL vector, so we do too. */
9238 return VEC_alloc (tree
, gc
, 4);
9242 /* Release a vector of trees back to the cache. */
9245 release_tree_vector (VEC(tree
,gc
) *vec
)
9249 VEC_truncate (tree
, vec
, 0);
9250 VEC_safe_push (tree_gc_vec
, gc
, tree_vector_cache
, vec
);
9254 /* Get a new tree vector holding a single tree. */
9257 make_tree_vector_single (tree t
)
9259 VEC(tree
,gc
) *ret
= make_tree_vector ();
9260 VEC_quick_push (tree
, ret
, t
);
9264 /* Get a new tree vector which is a copy of an existing one. */
9267 make_tree_vector_copy (const VEC(tree
,gc
) *orig
)
9273 ret
= make_tree_vector ();
9274 VEC_reserve (tree
, gc
, ret
, VEC_length (tree
, orig
));
9275 for (ix
= 0; VEC_iterate (tree
, orig
, ix
, t
); ++ix
)
9276 VEC_quick_push (tree
, ret
, t
);
9280 #include "gt-c-family-c-common.h"