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
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
40 #include "langhooks.h"
41 #include "tree-inline.h"
44 #include "diagnostic.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
51 #include "target-def.h"
53 #include "fixed-value.h"
56 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
58 /* We let tm.h override the types used here, to handle trivial differences
59 such as the choice of unsigned int or long unsigned int for size_t.
60 When machines start needing nontrivial differences in the size type,
61 it would be best to do something here to figure out automatically
62 from other information what type to use. */
65 #define SIZE_TYPE "long unsigned int"
69 #define PID_TYPE "int"
73 #define CHAR16_TYPE "short unsigned int"
77 #define CHAR32_TYPE "unsigned int"
81 #define WCHAR_TYPE "int"
84 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
85 #define MODIFIED_WCHAR_TYPE \
86 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
89 #define PTRDIFF_TYPE "long int"
93 #define WINT_TYPE "unsigned int"
97 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
99 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
105 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
107 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
108 ? "long unsigned int" \
109 : "long long unsigned int"))
112 /* The following symbols are subsumed in the c_global_trees array, and
113 listed here individually for documentation purposes.
115 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
117 tree short_integer_type_node;
118 tree long_integer_type_node;
119 tree long_long_integer_type_node;
121 tree short_unsigned_type_node;
122 tree long_unsigned_type_node;
123 tree long_long_unsigned_type_node;
125 tree truthvalue_type_node;
126 tree truthvalue_false_node;
127 tree truthvalue_true_node;
129 tree ptrdiff_type_node;
131 tree unsigned_char_type_node;
132 tree signed_char_type_node;
133 tree wchar_type_node;
134 tree signed_wchar_type_node;
135 tree unsigned_wchar_type_node;
137 tree char16_type_node;
138 tree char32_type_node;
140 tree float_type_node;
141 tree double_type_node;
142 tree long_double_type_node;
144 tree complex_integer_type_node;
145 tree complex_float_type_node;
146 tree complex_double_type_node;
147 tree complex_long_double_type_node;
149 tree dfloat32_type_node;
150 tree dfloat64_type_node;
151 tree_dfloat128_type_node;
153 tree intQI_type_node;
154 tree intHI_type_node;
155 tree intSI_type_node;
156 tree intDI_type_node;
157 tree intTI_type_node;
159 tree unsigned_intQI_type_node;
160 tree unsigned_intHI_type_node;
161 tree unsigned_intSI_type_node;
162 tree unsigned_intDI_type_node;
163 tree unsigned_intTI_type_node;
165 tree widest_integer_literal_type_node;
166 tree widest_unsigned_literal_type_node;
168 Nodes for types `void *' and `const void *'.
170 tree ptr_type_node, const_ptr_type_node;
172 Nodes for types `char *' and `const char *'.
174 tree string_type_node, const_string_type_node;
176 Type `char[SOMENUMBER]'.
177 Used when an array of char is needed and the size is irrelevant.
179 tree char_array_type_node;
181 Type `int[SOMENUMBER]' or something like it.
182 Used when an array of int needed and the size is irrelevant.
184 tree int_array_type_node;
186 Type `wchar_t[SOMENUMBER]' or something like it.
187 Used when a wide string literal is created.
189 tree wchar_array_type_node;
191 Type `char16_t[SOMENUMBER]' or something like it.
192 Used when a UTF-16 string literal is created.
194 tree char16_array_type_node;
196 Type `char32_t[SOMENUMBER]' or something like it.
197 Used when a UTF-32 string literal is created.
199 tree char32_array_type_node;
201 Type `int ()' -- used for implicit declaration of functions.
203 tree default_function_type;
205 A VOID_TYPE node, packaged in a TREE_LIST.
209 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
210 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
211 VAR_DECLS, but C++ does.)
213 tree function_name_decl_node;
214 tree pretty_function_name_decl_node;
215 tree c99_function_name_decl_node;
217 Stack of nested function name VAR_DECLs.
219 tree saved_function_name_decls;
223 tree c_global_trees
[CTI_MAX
];
225 /* Switches common to the C front ends. */
227 /* Nonzero if preprocessing only. */
229 int flag_preprocess_only
;
231 /* Nonzero means don't output line number information. */
233 char flag_no_line_commands
;
235 /* Nonzero causes -E output not to be done, but directives such as
236 #define that have side effects are still obeyed. */
240 /* Nonzero means dump macros in some fashion. */
242 char flag_dump_macros
;
244 /* Nonzero means pass #include lines through to the output. */
246 char flag_dump_includes
;
248 /* Nonzero means process PCH files while preprocessing. */
250 bool flag_pch_preprocess
;
252 /* The file name to which we should write a precompiled header, or
253 NULL if no header will be written in this compile. */
255 const char *pch_file
;
257 /* Nonzero if an ISO standard was selected. It rejects macros in the
261 /* Nonzero if -undef was given. It suppresses target built-in macros
265 /* Nonzero means don't recognize the non-ANSI builtin functions. */
269 /* Nonzero means don't recognize the non-ANSI builtin functions.
272 int flag_no_nonansi_builtin
;
274 /* Nonzero means give `double' the same size as `float'. */
276 int flag_short_double
;
278 /* Nonzero means give `wchar_t' the same size as `short'. */
280 int flag_short_wchar
;
282 /* Nonzero means allow implicit conversions between vectors with
283 differing numbers of subparts and/or differing element types. */
284 int flag_lax_vector_conversions
;
286 /* Nonzero means allow Microsoft extensions without warnings or errors. */
287 int flag_ms_extensions
;
289 /* Nonzero means don't recognize the keyword `asm'. */
293 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
295 int flag_signed_bitfields
= 1;
297 /* Warn about #pragma directives that are not recognized. */
299 int warn_unknown_pragmas
; /* Tri state variable. */
301 /* Warn about format/argument anomalies in calls to formatted I/O functions
302 (*printf, *scanf, strftime, strfmon, etc.). */
306 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
307 with GCC this doesn't matter as __null is guaranteed to have the right
310 int warn_strict_null_sentinel
;
312 /* Zero means that faster, ...NonNil variants of objc_msgSend...
313 calls will be used in ObjC; passing nil receivers to such calls
314 will most likely result in crashes. */
315 int flag_nil_receivers
= 1;
317 /* Nonzero means that code generation will be altered to support
318 "zero-link" execution. This currently affects ObjC only, but may
319 affect other languages in the future. */
320 int flag_zero_link
= 0;
322 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
323 unit. It will inform the ObjC runtime that class definition(s) herein
324 contained are to replace one(s) previously loaded. */
325 int flag_replace_objc_classes
= 0;
327 /* C/ObjC language option variables. */
330 /* Nonzero means allow type mismatches in conditional expressions;
331 just make their values `void'. */
333 int flag_cond_mismatch
;
335 /* Nonzero means enable C89 Amendment 1 features. */
339 /* Nonzero means use the ISO C99 dialect of C. */
343 /* Nonzero means that we have builtin functions, and main is an int. */
348 /* ObjC language option variables. */
351 /* Open and close the file for outputting class declarations, if
354 int flag_gen_declaration
;
356 /* Tells the compiler that this is a special run. Do not perform any
357 compiling, instead we are to test some platform dependent features
358 and output a C header file with appropriate definitions. */
360 int print_struct_values
;
362 /* Tells the compiler what is the constant string class for ObjC. */
364 const char *constant_string_class_name
;
367 /* C++ language option variables. */
370 /* Nonzero means don't recognize any extension keywords. */
372 int flag_no_gnu_keywords
;
374 /* Nonzero means do emit exported implementations of functions even if
375 they can be inlined. */
377 int flag_implement_inlines
= 1;
379 /* Nonzero means that implicit instantiations will be emitted if needed. */
381 int flag_implicit_templates
= 1;
383 /* Nonzero means that implicit instantiations of inline templates will be
384 emitted if needed, even if instantiations of non-inline templates
387 int flag_implicit_inline_templates
= 1;
389 /* Nonzero means generate separate instantiation control files and
390 juggle them at link time. */
392 int flag_use_repository
;
394 /* Nonzero if we want to issue diagnostics that the standard says are not
397 int flag_optional_diags
= 1;
399 /* Nonzero means we should attempt to elide constructors when possible. */
401 int flag_elide_constructors
= 1;
403 /* Nonzero means that member functions defined in class scope are
404 inline by default. */
406 int flag_default_inline
= 1;
408 /* Controls whether compiler generates 'type descriptor' that give
409 run-time type information. */
413 /* Nonzero if we want to conserve space in the .o files. We do this
414 by putting uninitialized data and runtime initialized data into
415 .common instead of .data at the expense of not flagging multiple
418 int flag_conserve_space
;
420 /* Nonzero if we want to obey access control semantics. */
422 int flag_access_control
= 1;
424 /* Nonzero if we want to check the return value of new and avoid calling
425 constructors if it is a null pointer. */
429 /* The C++ dialect being used. C++98 is the default. */
431 enum cxx_dialect cxx_dialect
= cxx98
;
433 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
434 initialization variables.
435 0: Old rules, set by -fno-for-scope.
436 2: New ISO rules, set by -ffor-scope.
437 1: Try to implement new ISO rules, but with backup compatibility
438 (and warnings). This is the default, for now. */
440 int flag_new_for_scope
= 1;
442 /* Nonzero if we want to emit defined symbols with common-like linkage as
443 weak symbols where possible, in order to conform to C++ semantics.
444 Otherwise, emit them as local symbols. */
448 /* 0 means we want the preprocessor to not emit line directives for
449 the current working directory. 1 means we want it to do it. -1
450 means we should decide depending on whether debugging information
451 is being emitted or not. */
453 int flag_working_directory
= -1;
455 /* Nonzero to use __cxa_atexit, rather than atexit, to register
456 destructors for local statics and global objects. '2' means it has been
457 set nonzero as a default, not by a command-line flag. */
459 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
461 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
462 code. '2' means it has not been set explicitly on the command line. */
464 int flag_use_cxa_get_exception_ptr
= 2;
466 /* Nonzero means to implement standard semantics for exception
467 specifications, calling unexpected if an exception is thrown that
468 doesn't match the specification. Zero means to treat them as
469 assertions and optimize accordingly, but not check them. */
471 int flag_enforce_eh_specs
= 1;
473 /* Nonzero means to generate thread-safe code for initializing local
476 int flag_threadsafe_statics
= 1;
478 /* Nonzero means warn about implicit declarations. */
480 int warn_implicit
= 1;
482 /* Maximum template instantiation depth. This limit is rather
483 arbitrary, but it exists to limit the time it takes to notice
484 infinite template instantiations. */
486 int max_tinst_depth
= 500;
490 /* The elements of `ridpointers' are identifier nodes for the reserved
491 type names and storage classes. It is indexed by a RID_... value. */
494 tree (*make_fname_decl
) (tree
, int);
496 /* Nonzero means the expression being parsed will never be evaluated.
497 This is a count, since unevaluated expressions can nest. */
500 /* Whether lexing has been completed, so subsequent preprocessor
501 errors should use the compiler's input_location. */
502 bool done_lexing
= false;
504 /* Information about how a function name is generated. */
507 tree
*const decl
; /* pointer to the VAR_DECL. */
508 const unsigned rid
; /* RID number for the identifier. */
509 const int pretty
; /* How pretty is it? */
512 /* The three ways of getting then name of the current function. */
514 const struct fname_var_t fname_vars
[] =
516 /* C99 compliant __func__, must be first. */
517 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
518 /* GCC __FUNCTION__ compliant. */
519 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
520 /* GCC __PRETTY_FUNCTION__ compliant. */
521 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
525 static tree
c_fully_fold_internal (tree expr
, bool, bool *, bool *);
526 static tree
check_case_value (tree
);
527 static bool check_case_bounds (tree
, tree
, tree
*, tree
*);
529 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
530 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
531 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
532 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
533 static tree
handle_hot_attribute (tree
*, tree
, tree
, int, bool *);
534 static tree
handle_cold_attribute (tree
*, tree
, tree
, int, bool *);
535 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
536 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
538 static tree
handle_gnu_inline_attribute (tree
*, tree
, tree
, int, bool *);
539 static tree
handle_artificial_attribute (tree
*, tree
, tree
, int, bool *);
540 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
541 static tree
handle_error_attribute (tree
*, tree
, tree
, int, bool *);
542 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
543 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
544 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
546 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
547 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
549 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
550 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
551 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
552 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
553 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
554 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
555 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
556 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
557 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
559 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
561 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
563 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
564 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
565 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
567 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
568 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
569 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
571 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
573 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
574 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
575 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
576 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
578 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
579 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
580 static tree
handle_alloc_size_attribute (tree
*, tree
, tree
, int, bool *);
581 static tree
handle_target_attribute (tree
*, tree
, tree
, int, bool *);
582 static tree
handle_optimize_attribute (tree
*, tree
, tree
, int, bool *);
584 static void check_function_nonnull (tree
, int, tree
*);
585 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
586 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
587 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
588 static int resort_field_decl_cmp (const void *, const void *);
590 /* Reserved words. The third field is a mask: keywords are disabled
591 if they match the mask.
594 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
595 C --std=c99: D_CXXONLY | D_OBJC
596 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
597 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
598 C++ --std=c0x: D_CONLY | D_OBJC
599 ObjC++ is like C++ except that D_OBJC is not set
601 If -fno-asm is used, D_ASM is added to the mask. If
602 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
603 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
604 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
606 const struct c_common_resword c_common_reswords
[] =
608 { "_Bool", RID_BOOL
, D_CONLY
},
609 { "_Complex", RID_COMPLEX
, 0 },
610 { "_Decimal32", RID_DFLOAT32
, D_CONLY
| D_EXT
},
611 { "_Decimal64", RID_DFLOAT64
, D_CONLY
| D_EXT
},
612 { "_Decimal128", RID_DFLOAT128
, D_CONLY
| D_EXT
},
613 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
614 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
615 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
616 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
617 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
618 { "__alignof", RID_ALIGNOF
, 0 },
619 { "__alignof__", RID_ALIGNOF
, 0 },
620 { "__asm", RID_ASM
, 0 },
621 { "__asm__", RID_ASM
, 0 },
622 { "__attribute", RID_ATTRIBUTE
, 0 },
623 { "__attribute__", RID_ATTRIBUTE
, 0 },
624 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
625 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
626 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
627 { "__builtin_va_arg", RID_VA_ARG
, 0 },
628 { "__complex", RID_COMPLEX
, 0 },
629 { "__complex__", RID_COMPLEX
, 0 },
630 { "__const", RID_CONST
, 0 },
631 { "__const__", RID_CONST
, 0 },
632 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
633 { "__extension__", RID_EXTENSION
, 0 },
634 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
635 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
636 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
637 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
638 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
639 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
640 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
641 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
642 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
643 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
644 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
645 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
646 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO
, D_CXXONLY
},
647 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
648 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
649 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
650 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
651 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
652 { "__imag", RID_IMAGPART
, 0 },
653 { "__imag__", RID_IMAGPART
, 0 },
654 { "__inline", RID_INLINE
, 0 },
655 { "__inline__", RID_INLINE
, 0 },
656 { "__label__", RID_LABEL
, 0 },
657 { "__null", RID_NULL
, 0 },
658 { "__real", RID_REALPART
, 0 },
659 { "__real__", RID_REALPART
, 0 },
660 { "__restrict", RID_RESTRICT
, 0 },
661 { "__restrict__", RID_RESTRICT
, 0 },
662 { "__signed", RID_SIGNED
, 0 },
663 { "__signed__", RID_SIGNED
, 0 },
664 { "__thread", RID_THREAD
, 0 },
665 { "__typeof", RID_TYPEOF
, 0 },
666 { "__typeof__", RID_TYPEOF
, 0 },
667 { "__volatile", RID_VOLATILE
, 0 },
668 { "__volatile__", RID_VOLATILE
, 0 },
669 { "asm", RID_ASM
, D_ASM
},
670 { "auto", RID_AUTO
, 0 },
671 { "bool", RID_BOOL
, D_CXXONLY
| D_CXXWARN
},
672 { "break", RID_BREAK
, 0 },
673 { "case", RID_CASE
, 0 },
674 { "catch", RID_CATCH
, D_CXX_OBJC
| D_CXXWARN
},
675 { "char", RID_CHAR
, 0 },
676 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
677 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
678 { "class", RID_CLASS
, D_CXX_OBJC
| D_CXXWARN
},
679 { "const", RID_CONST
, 0 },
680 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
681 { "continue", RID_CONTINUE
, 0 },
682 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
683 { "default", RID_DEFAULT
, 0 },
684 { "delete", RID_DELETE
, D_CXXONLY
| D_CXXWARN
},
686 { "double", RID_DOUBLE
, 0 },
687 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
688 { "else", RID_ELSE
, 0 },
689 { "enum", RID_ENUM
, 0 },
690 { "explicit", RID_EXPLICIT
, D_CXXONLY
| D_CXXWARN
},
691 { "export", RID_EXPORT
, D_CXXONLY
| D_CXXWARN
},
692 { "extern", RID_EXTERN
, 0 },
693 { "false", RID_FALSE
, D_CXXONLY
| D_CXXWARN
},
694 { "float", RID_FLOAT
, 0 },
695 { "for", RID_FOR
, 0 },
696 { "friend", RID_FRIEND
, D_CXXONLY
| D_CXXWARN
},
697 { "goto", RID_GOTO
, 0 },
699 { "inline", RID_INLINE
, D_EXT89
},
700 { "int", RID_INT
, 0 },
701 { "long", RID_LONG
, 0 },
702 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
703 { "namespace", RID_NAMESPACE
, D_CXXONLY
| D_CXXWARN
},
704 { "new", RID_NEW
, D_CXXONLY
| D_CXXWARN
},
705 { "operator", RID_OPERATOR
, D_CXXONLY
| D_CXXWARN
},
706 { "private", RID_PRIVATE
, D_CXX_OBJC
| D_CXXWARN
},
707 { "protected", RID_PROTECTED
, D_CXX_OBJC
| D_CXXWARN
},
708 { "public", RID_PUBLIC
, D_CXX_OBJC
| D_CXXWARN
},
709 { "register", RID_REGISTER
, 0 },
710 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
711 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
712 { "return", RID_RETURN
, 0 },
713 { "short", RID_SHORT
, 0 },
714 { "signed", RID_SIGNED
, 0 },
715 { "sizeof", RID_SIZEOF
, 0 },
716 { "static", RID_STATIC
, 0 },
717 { "static_assert", RID_STATIC_ASSERT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
718 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
719 { "struct", RID_STRUCT
, 0 },
720 { "switch", RID_SWITCH
, 0 },
721 { "template", RID_TEMPLATE
, D_CXXONLY
| D_CXXWARN
},
722 { "this", RID_THIS
, D_CXXONLY
| D_CXXWARN
},
723 { "throw", RID_THROW
, D_CXX_OBJC
| D_CXXWARN
},
724 { "true", RID_TRUE
, D_CXXONLY
| D_CXXWARN
},
725 { "try", RID_TRY
, D_CXX_OBJC
| D_CXXWARN
},
726 { "typedef", RID_TYPEDEF
, 0 },
727 { "typename", RID_TYPENAME
, D_CXXONLY
| D_CXXWARN
},
728 { "typeid", RID_TYPEID
, D_CXXONLY
| D_CXXWARN
},
729 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
730 { "union", RID_UNION
, 0 },
731 { "unsigned", RID_UNSIGNED
, 0 },
732 { "using", RID_USING
, D_CXXONLY
| D_CXXWARN
},
733 { "virtual", RID_VIRTUAL
, D_CXXONLY
| D_CXXWARN
},
734 { "void", RID_VOID
, 0 },
735 { "volatile", RID_VOLATILE
, 0 },
736 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
737 { "while", RID_WHILE
, 0 },
738 /* These Objective-C keywords are recognized only immediately after
740 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
741 { "defs", RID_AT_DEFS
, D_OBJC
},
742 { "encode", RID_AT_ENCODE
, D_OBJC
},
743 { "end", RID_AT_END
, D_OBJC
},
744 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
745 { "interface", RID_AT_INTERFACE
, D_OBJC
},
746 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
747 { "selector", RID_AT_SELECTOR
, D_OBJC
},
748 { "finally", RID_AT_FINALLY
, D_OBJC
},
749 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
750 /* These are recognized only in protocol-qualifier context
752 { "bycopy", RID_BYCOPY
, D_OBJC
},
753 { "byref", RID_BYREF
, D_OBJC
},
754 { "in", RID_IN
, D_OBJC
},
755 { "inout", RID_INOUT
, D_OBJC
},
756 { "oneway", RID_ONEWAY
, D_OBJC
},
757 { "out", RID_OUT
, D_OBJC
},
760 const unsigned int num_c_common_reswords
=
761 sizeof c_common_reswords
/ sizeof (struct c_common_resword
);
763 /* Table of machine-independent attributes common to all C-like languages. */
764 const struct attribute_spec c_common_attribute_table
[] =
766 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
767 { "packed", 0, 0, false, false, false,
768 handle_packed_attribute
},
769 { "nocommon", 0, 0, true, false, false,
770 handle_nocommon_attribute
},
771 { "common", 0, 0, true, false, false,
772 handle_common_attribute
},
773 /* FIXME: logically, noreturn attributes should be listed as
774 "false, true, true" and apply to function types. But implementing this
775 would require all the places in the compiler that use TREE_THIS_VOLATILE
776 on a decl to identify non-returning functions to be located and fixed
777 to check the function type instead. */
778 { "noreturn", 0, 0, true, false, false,
779 handle_noreturn_attribute
},
780 { "volatile", 0, 0, true, false, false,
781 handle_noreturn_attribute
},
782 { "noinline", 0, 0, true, false, false,
783 handle_noinline_attribute
},
784 { "always_inline", 0, 0, true, false, false,
785 handle_always_inline_attribute
},
786 { "gnu_inline", 0, 0, true, false, false,
787 handle_gnu_inline_attribute
},
788 { "artificial", 0, 0, true, false, false,
789 handle_artificial_attribute
},
790 { "flatten", 0, 0, true, false, false,
791 handle_flatten_attribute
},
792 { "used", 0, 0, true, false, false,
793 handle_used_attribute
},
794 { "unused", 0, 0, false, false, false,
795 handle_unused_attribute
},
796 { "externally_visible", 0, 0, true, false, false,
797 handle_externally_visible_attribute
},
798 /* The same comments as for noreturn attributes apply to const ones. */
799 { "const", 0, 0, true, false, false,
800 handle_const_attribute
},
801 { "transparent_union", 0, 0, false, false, false,
802 handle_transparent_union_attribute
},
803 { "constructor", 0, 1, true, false, false,
804 handle_constructor_attribute
},
805 { "destructor", 0, 1, true, false, false,
806 handle_destructor_attribute
},
807 { "mode", 1, 1, false, true, false,
808 handle_mode_attribute
},
809 { "section", 1, 1, true, false, false,
810 handle_section_attribute
},
811 { "aligned", 0, 1, false, false, false,
812 handle_aligned_attribute
},
813 { "weak", 0, 0, true, false, false,
814 handle_weak_attribute
},
815 { "alias", 1, 1, true, false, false,
816 handle_alias_attribute
},
817 { "weakref", 0, 1, true, false, false,
818 handle_weakref_attribute
},
819 { "no_instrument_function", 0, 0, true, false, false,
820 handle_no_instrument_function_attribute
},
821 { "malloc", 0, 0, true, false, false,
822 handle_malloc_attribute
},
823 { "returns_twice", 0, 0, true, false, false,
824 handle_returns_twice_attribute
},
825 { "no_stack_limit", 0, 0, true, false, false,
826 handle_no_limit_stack_attribute
},
827 { "pure", 0, 0, true, false, false,
828 handle_pure_attribute
},
829 /* For internal use (marking of builtins) only. The name contains space
830 to prevent its usage in source code. */
831 { "no vops", 0, 0, true, false, false,
832 handle_novops_attribute
},
833 { "deprecated", 0, 0, false, false, false,
834 handle_deprecated_attribute
},
835 { "vector_size", 1, 1, false, true, false,
836 handle_vector_size_attribute
},
837 { "visibility", 1, 1, false, false, false,
838 handle_visibility_attribute
},
839 { "tls_model", 1, 1, true, false, false,
840 handle_tls_model_attribute
},
841 { "nonnull", 0, -1, false, true, true,
842 handle_nonnull_attribute
},
843 { "nothrow", 0, 0, true, false, false,
844 handle_nothrow_attribute
},
845 { "may_alias", 0, 0, false, true, false, NULL
},
846 { "cleanup", 1, 1, true, false, false,
847 handle_cleanup_attribute
},
848 { "warn_unused_result", 0, 0, false, true, true,
849 handle_warn_unused_result_attribute
},
850 { "sentinel", 0, 1, false, true, true,
851 handle_sentinel_attribute
},
852 /* For internal use (marking of builtins) only. The name contains space
853 to prevent its usage in source code. */
854 { "type generic", 0, 0, false, true, true,
855 handle_type_generic_attribute
},
856 { "alloc_size", 1, 2, false, true, true,
857 handle_alloc_size_attribute
},
858 { "cold", 0, 0, true, false, false,
859 handle_cold_attribute
},
860 { "hot", 0, 0, true, false, false,
861 handle_hot_attribute
},
862 { "warning", 1, 1, true, false, false,
863 handle_error_attribute
},
864 { "error", 1, 1, true, false, false,
865 handle_error_attribute
},
866 { "target", 1, -1, true, false, false,
867 handle_target_attribute
},
868 { "optimize", 1, -1, true, false, false,
869 handle_optimize_attribute
},
870 { NULL
, 0, 0, false, false, false, NULL
}
873 /* Give the specifications for the format attributes, used by C and all
876 const struct attribute_spec c_common_format_attribute_table
[] =
878 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
879 { "format", 3, 3, false, true, true,
880 handle_format_attribute
},
881 { "format_arg", 1, 1, false, true, true,
882 handle_format_arg_attribute
},
883 { NULL
, 0, 0, false, false, false, NULL
}
886 /* Push current bindings for the function name VAR_DECLS. */
889 start_fname_decls (void)
892 tree saved
= NULL_TREE
;
894 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
896 tree decl
= *fname_vars
[ix
].decl
;
900 saved
= tree_cons (decl
, build_int_cst (NULL_TREE
, ix
), saved
);
901 *fname_vars
[ix
].decl
= NULL_TREE
;
904 if (saved
|| saved_function_name_decls
)
905 /* Normally they'll have been NULL, so only push if we've got a
906 stack, or they are non-NULL. */
907 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
908 saved_function_name_decls
);
911 /* Finish up the current bindings, adding them into the current function's
912 statement tree. This must be done _before_ finish_stmt_tree is called.
913 If there is no current function, we must be at file scope and no statements
914 are involved. Pop the previous bindings. */
917 finish_fname_decls (void)
920 tree stmts
= NULL_TREE
;
921 tree stack
= saved_function_name_decls
;
923 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
924 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
928 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
930 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
931 bodyp
= &BIND_EXPR_BODY (*bodyp
);
933 append_to_statement_list_force (*bodyp
, &stmts
);
937 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
938 *fname_vars
[ix
].decl
= NULL_TREE
;
942 /* We had saved values, restore them. */
945 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
947 tree decl
= TREE_PURPOSE (saved
);
948 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
950 *fname_vars
[ix
].decl
= decl
;
952 stack
= TREE_CHAIN (stack
);
954 saved_function_name_decls
= stack
;
957 /* Return the text name of the current function, suitably prettified
958 by PRETTY_P. Return string must be freed by caller. */
961 fname_as_string (int pretty_p
)
963 const char *name
= "top level";
966 cpp_string cstr
= { 0, 0 }, strname
;
974 if (current_function_decl
)
975 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
977 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
979 namep
= XNEWVEC (char, len
);
980 snprintf (namep
, len
, "\"%s\"", name
);
981 strname
.text
= (unsigned char *) namep
;
982 strname
.len
= len
- 1;
984 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
987 return (const char *) cstr
.text
;
993 /* Return the VAR_DECL for a const char array naming the current
994 function. If the VAR_DECL has not yet been created, create it
995 now. RID indicates how it should be formatted and IDENTIFIER_NODE
996 ID is its name (unfortunately C and C++ hold the RID values of
997 keywords in different places, so we can't derive RID from ID in
998 this language independent code. LOC is the location of the
1002 fname_decl (location_t loc
, unsigned int rid
, tree id
)
1005 tree decl
= NULL_TREE
;
1007 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1008 if (fname_vars
[ix
].rid
== rid
)
1011 decl
= *fname_vars
[ix
].decl
;
1014 /* If a tree is built here, it would normally have the lineno of
1015 the current statement. Later this tree will be moved to the
1016 beginning of the function and this line number will be wrong.
1017 To avoid this problem set the lineno to 0 here; that prevents
1018 it from appearing in the RTL. */
1020 location_t saved_location
= input_location
;
1021 input_location
= UNKNOWN_LOCATION
;
1023 stmts
= push_stmt_list ();
1024 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
1025 stmts
= pop_stmt_list (stmts
);
1026 if (!IS_EMPTY_STMT (stmts
))
1027 saved_function_name_decls
1028 = tree_cons (decl
, stmts
, saved_function_name_decls
);
1029 *fname_vars
[ix
].decl
= decl
;
1030 input_location
= saved_location
;
1032 if (!ix
&& !current_function_decl
)
1033 pedwarn (loc
, 0, "%qD is not defined outside of function scope", decl
);
1038 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1041 fix_string_type (tree value
)
1043 int length
= TREE_STRING_LENGTH (value
);
1045 tree e_type
, i_type
, a_type
;
1047 /* Compute the number of elements, for the array type. */
1048 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
1051 e_type
= char_type_node
;
1053 else if (TREE_TYPE (value
) == char16_array_type_node
)
1055 nchars
= length
/ (TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
);
1056 e_type
= char16_type_node
;
1058 else if (TREE_TYPE (value
) == char32_array_type_node
)
1060 nchars
= length
/ (TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
);
1061 e_type
= char32_type_node
;
1065 nchars
= length
/ (TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
);
1066 e_type
= wchar_type_node
;
1069 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1070 limit in C++98 Annex B is very large (65536) and is not normative,
1071 so we do not diagnose it (warn_overlength_strings is forced off
1072 in c_common_post_options). */
1073 if (warn_overlength_strings
)
1075 const int nchars_max
= flag_isoc99
? 4095 : 509;
1076 const int relevant_std
= flag_isoc99
? 99 : 90;
1077 if (nchars
- 1 > nchars_max
)
1078 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1079 separate the %d from the 'C'. 'ISO' should not be
1080 translated, but it may be moved after 'C%d' in languages
1081 where modifiers follow nouns. */
1082 pedwarn (input_location
, OPT_Woverlength_strings
,
1083 "string length %qd is greater than the length %qd "
1084 "ISO C%d compilers are required to support",
1085 nchars
- 1, nchars_max
, relevant_std
);
1088 /* Create the array type for the string constant. The ISO C++
1089 standard says that a string literal has type `const char[N]' or
1090 `const wchar_t[N]'. We use the same logic when invoked as a C
1091 front-end with -Wwrite-strings.
1092 ??? We should change the type of an expression depending on the
1093 state of a warning flag. We should just be warning -- see how
1094 this is handled in the C++ front-end for the deprecated implicit
1095 conversion from string literals to `char*' or `wchar_t*'.
1097 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1098 array type being the unqualified version of that type.
1099 Therefore, if we are constructing an array of const char, we must
1100 construct the matching unqualified array type first. The C front
1101 end does not require this, but it does no harm, so we do it
1103 i_type
= build_index_type (build_int_cst (NULL_TREE
, nchars
- 1));
1104 a_type
= build_array_type (e_type
, i_type
);
1105 if (c_dialect_cxx() || warn_write_strings
)
1106 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
1108 TREE_TYPE (value
) = a_type
;
1109 TREE_CONSTANT (value
) = 1;
1110 TREE_READONLY (value
) = 1;
1111 TREE_STATIC (value
) = 1;
1115 /* Fully fold EXPR, an expression that was not folded (beyond integer
1116 constant expressions and null pointer constants) when being built
1117 up. If IN_INIT, this is in a static initializer and certain
1118 changes are made to the folding done. Clear *MAYBE_CONST if
1119 MAYBE_CONST is not NULL and EXPR is definitely not a constant
1120 expression because it contains an evaluated operator (in C99) or an
1121 operator outside of sizeof returning an integer constant (in C90)
1122 not permitted in constant expressions, or because it contains an
1123 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
1124 set to true by callers before calling this function.) Return the
1125 folded expression. Function arguments have already been folded
1126 before calling this function, as have the contents of SAVE_EXPR,
1127 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1128 C_MAYBE_CONST_EXPR. */
1131 c_fully_fold (tree expr
, bool in_init
, bool *maybe_const
)
1134 tree eptype
= NULL_TREE
;
1136 bool maybe_const_itself
= true;
1138 /* This function is not relevant to C++ because C++ folds while
1139 parsing, and may need changes to be correct for C++ when C++
1140 stops folding while parsing. */
1141 if (c_dialect_cxx ())
1145 maybe_const
= &dummy
;
1146 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
1148 eptype
= TREE_TYPE (expr
);
1149 expr
= TREE_OPERAND (expr
, 0);
1151 ret
= c_fully_fold_internal (expr
, in_init
, maybe_const
,
1152 &maybe_const_itself
);
1154 ret
= fold_convert (eptype
, ret
);
1155 *maybe_const
&= maybe_const_itself
;
1159 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1160 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1161 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1162 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1163 both evaluated and unevaluated subexpressions while
1164 *MAYBE_CONST_ITSELF is carried from only evaluated
1168 c_fully_fold_internal (tree expr
, bool in_init
, bool *maybe_const_operands
,
1169 bool *maybe_const_itself
)
1172 enum tree_code code
= TREE_CODE (expr
);
1173 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
1174 location_t loc
= EXPR_LOCATION (expr
);
1175 tree op0
, op1
, op2
, op3
;
1176 tree orig_op0
, orig_op1
, orig_op2
;
1177 bool op0_const
= true, op1_const
= true, op2_const
= true;
1178 bool op0_const_self
= true, op1_const_self
= true, op2_const_self
= true;
1179 bool nowarning
= TREE_NO_WARNING (expr
);
1181 /* This function is not relevant to C++ because C++ folds while
1182 parsing, and may need changes to be correct for C++ when C++
1183 stops folding while parsing. */
1184 if (c_dialect_cxx ())
1187 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1188 anything else not counted as an expression cannot usefully be
1189 folded further at this point. */
1190 if (!IS_EXPR_CODE_CLASS (kind
)
1191 || kind
== tcc_statement
1192 || code
== SAVE_EXPR
)
1195 /* Operands of variable-length expressions (function calls) have
1196 already been folded, as have __builtin_* function calls, and such
1197 expressions cannot occur in constant expressions. */
1198 if (kind
== tcc_vl_exp
)
1200 *maybe_const_operands
= false;
1205 if (code
== C_MAYBE_CONST_EXPR
)
1207 tree pre
= C_MAYBE_CONST_EXPR_PRE (expr
);
1208 tree inner
= C_MAYBE_CONST_EXPR_EXPR (expr
);
1209 if (C_MAYBE_CONST_EXPR_NON_CONST (expr
))
1210 *maybe_const_operands
= false;
1211 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr
))
1212 *maybe_const_itself
= false;
1213 if (pre
&& !in_init
)
1214 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), pre
, inner
);
1220 /* Assignment, increment, decrement, function call and comma
1221 operators, and statement expressions, cannot occur in constant
1222 expressions if evaluated / outside of sizeof. (Function calls
1223 were handled above, though VA_ARG_EXPR is treated like a function
1224 call here, and statement expressions are handled through
1225 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1229 case PREDECREMENT_EXPR
:
1230 case PREINCREMENT_EXPR
:
1231 case POSTDECREMENT_EXPR
:
1232 case POSTINCREMENT_EXPR
:
1234 *maybe_const_operands
= false;
1241 *maybe_const_operands
= false;
1249 /* Fold individual tree codes as appropriate. */
1252 case COMPOUND_LITERAL_EXPR
:
1253 /* Any non-constancy will have been marked in a containing
1254 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1258 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1259 op1
= TREE_OPERAND (expr
, 1);
1260 op2
= TREE_OPERAND (expr
, 2);
1261 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1262 maybe_const_itself
);
1263 if (op0
!= orig_op0
)
1264 ret
= build3 (COMPONENT_REF
, TREE_TYPE (expr
), op0
, op1
, op2
);
1267 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1268 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1273 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1274 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1275 op2
= TREE_OPERAND (expr
, 2);
1276 op3
= TREE_OPERAND (expr
, 3);
1277 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1278 maybe_const_itself
);
1279 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1280 maybe_const_itself
);
1281 op1
= decl_constant_value_for_optimization (op1
);
1282 if (op0
!= orig_op0
|| op1
!= orig_op1
)
1283 ret
= build4 (ARRAY_REF
, TREE_TYPE (expr
), op0
, op1
, op2
, op3
);
1286 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1287 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1288 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1295 case PREDECREMENT_EXPR
:
1296 case PREINCREMENT_EXPR
:
1297 case POSTDECREMENT_EXPR
:
1298 case POSTINCREMENT_EXPR
:
1302 case POINTER_PLUS_EXPR
:
1303 case TRUNC_DIV_EXPR
:
1305 case FLOOR_DIV_EXPR
:
1306 case TRUNC_MOD_EXPR
:
1308 case EXACT_DIV_EXPR
:
1321 case TRUTH_AND_EXPR
:
1323 case TRUTH_XOR_EXPR
:
1324 case UNORDERED_EXPR
:
1331 /* Binary operations evaluating both arguments (increment and
1332 decrement are binary internally in GCC). */
1333 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1334 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1335 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1336 maybe_const_itself
);
1337 if (code
!= MODIFY_EXPR
1338 && code
!= PREDECREMENT_EXPR
1339 && code
!= PREINCREMENT_EXPR
1340 && code
!= POSTDECREMENT_EXPR
1341 && code
!= POSTINCREMENT_EXPR
)
1342 op0
= decl_constant_value_for_optimization (op0
);
1343 /* The RHS of a MODIFY_EXPR was fully folded when building that
1344 expression for the sake of conversion warnings. */
1345 if (code
!= MODIFY_EXPR
)
1346 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1347 maybe_const_itself
);
1348 op1
= decl_constant_value_for_optimization (op1
);
1349 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1351 ? fold_build2_initializer (code
, TREE_TYPE (expr
), op0
, op1
)
1352 : fold_build2 (code
, TREE_TYPE (expr
), op0
, op1
);
1358 case FIX_TRUNC_EXPR
:
1361 case NON_LVALUE_EXPR
:
1364 case TRUTH_NOT_EXPR
:
1369 /* Unary operations. */
1370 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1371 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1372 maybe_const_itself
);
1373 if (code
!= ADDR_EXPR
&& code
!= REALPART_EXPR
&& code
!= IMAGPART_EXPR
)
1374 op0
= decl_constant_value_for_optimization (op0
);
1375 if (op0
!= orig_op0
|| in_init
)
1377 ? fold_build1_initializer (code
, TREE_TYPE (expr
), op0
)
1378 : fold_build1 (code
, TREE_TYPE (expr
), op0
);
1381 if (code
== INDIRECT_REF
1383 && TREE_CODE (ret
) == INDIRECT_REF
)
1385 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1386 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1387 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1391 case TRUTH_ANDIF_EXPR
:
1392 case TRUTH_ORIF_EXPR
:
1393 /* Binary operations not necessarily evaluating both
1395 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1396 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1397 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1398 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1399 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1401 ? fold_build2_initializer (code
, TREE_TYPE (expr
), op0
, op1
)
1402 : fold_build2 (code
, TREE_TYPE (expr
), op0
, op1
);
1405 *maybe_const_operands
&= op0_const
;
1406 *maybe_const_itself
&= op0_const_self
;
1410 && (code
== TRUTH_ANDIF_EXPR
1411 ? op0
== truthvalue_false_node
1412 : op0
== truthvalue_true_node
)))
1413 *maybe_const_operands
&= op1_const
;
1416 && (code
== TRUTH_ANDIF_EXPR
1417 ? op0
== truthvalue_false_node
1418 : op0
== truthvalue_true_node
)))
1419 *maybe_const_itself
&= op1_const_self
;
1423 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1424 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1425 orig_op2
= op2
= TREE_OPERAND (expr
, 2);
1426 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1427 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1428 op2
= c_fully_fold_internal (op2
, in_init
, &op2_const
, &op2_const_self
);
1429 if (op0
!= orig_op0
|| op1
!= orig_op1
|| op2
!= orig_op2
)
1430 ret
= fold_build3 (code
, TREE_TYPE (expr
), op0
, op1
, op2
);
1433 *maybe_const_operands
&= op0_const
;
1434 *maybe_const_itself
&= op0_const_self
;
1438 && op0
== truthvalue_false_node
))
1439 *maybe_const_operands
&= op1_const
;
1442 && op0
== truthvalue_false_node
))
1443 *maybe_const_itself
&= op1_const_self
;
1447 && op0
== truthvalue_true_node
))
1448 *maybe_const_operands
&= op2_const
;
1451 && op0
== truthvalue_true_node
))
1452 *maybe_const_itself
&= op2_const_self
;
1455 case EXCESS_PRECISION_EXPR
:
1456 /* Each case where an operand with excess precision may be
1457 encountered must remove the EXCESS_PRECISION_EXPR around
1458 inner operands and possibly put one around the whole
1459 expression or possibly convert to the semantic type (which
1460 c_fully_fold does); we cannot tell at this stage which is
1461 appropriate in any particular case. */
1465 /* Various codes may appear through folding built-in functions
1466 and their arguments. */
1471 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1472 have been done by this point, so remove them again. */
1473 nowarning
|= TREE_NO_WARNING (ret
);
1474 STRIP_TYPE_NOPS (ret
);
1475 if (nowarning
&& !TREE_NO_WARNING (ret
))
1477 if (!CAN_HAVE_LOCATION_P (ret
))
1478 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
1479 TREE_NO_WARNING (ret
) = 1;
1482 protected_set_expr_location (ret
, loc
);
1486 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1487 return EXP. Otherwise, return either EXP or its known constant
1488 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1489 Is the BLKmode test appropriate? */
1492 decl_constant_value_for_optimization (tree exp
)
1496 /* This function is only used by C, for c_fully_fold and other
1497 optimization, and may not be correct for C++. */
1498 if (c_dialect_cxx ())
1502 || TREE_CODE (exp
) != VAR_DECL
1503 || TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1504 || DECL_MODE (exp
) == BLKmode
)
1507 ret
= decl_constant_value (exp
);
1508 /* Avoid unwanted tree sharing between the initializer and current
1509 function's body where the tree can be modified e.g. by the
1511 if (ret
!= exp
&& TREE_STATIC (exp
))
1512 ret
= unshare_expr (ret
);
1516 /* Print a warning if a constant expression had overflow in folding.
1517 Invoke this function on every expression that the language
1518 requires to be a constant expression.
1519 Note the ANSI C standard says it is erroneous for a
1520 constant expression to overflow. */
1523 constant_expression_warning (tree value
)
1525 if (warn_overflow
&& pedantic
1526 && (TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1527 || TREE_CODE (value
) == FIXED_CST
1528 || TREE_CODE (value
) == VECTOR_CST
1529 || TREE_CODE (value
) == COMPLEX_CST
)
1530 && TREE_OVERFLOW (value
))
1531 pedwarn (input_location
, OPT_Woverflow
, "overflow in constant expression");
1534 /* The same as above but print an unconditional error. */
1536 constant_expression_error (tree value
)
1538 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1539 || TREE_CODE (value
) == FIXED_CST
1540 || TREE_CODE (value
) == VECTOR_CST
1541 || TREE_CODE (value
) == COMPLEX_CST
)
1542 && TREE_OVERFLOW (value
))
1543 error ("overflow in constant expression");
1546 /* Print a warning if an expression had overflow in folding and its
1549 Invoke this function on every expression that
1550 (1) appears in the source code, and
1551 (2) is a constant expression that overflowed, and
1552 (3) is not already checked by convert_and_check;
1553 however, do not invoke this function on operands of explicit casts
1554 or when the expression is the result of an operator and any operand
1555 already overflowed. */
1558 overflow_warning (tree value
)
1560 if (skip_evaluation
) return;
1562 switch (TREE_CODE (value
))
1565 warning (OPT_Woverflow
, "integer overflow in expression");
1569 warning (OPT_Woverflow
, "floating point overflow in expression");
1573 warning (OPT_Woverflow
, "fixed-point overflow in expression");
1577 warning (OPT_Woverflow
, "vector overflow in expression");
1581 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
1582 warning (OPT_Woverflow
, "complex integer overflow in expression");
1583 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
1584 warning (OPT_Woverflow
, "complex floating point overflow in expression");
1593 /* Warn about use of a logical || / && operator being used in a
1594 context where it is likely that the bitwise equivalent was intended
1595 by the programmer. CODE is the TREE_CODE of the operator, ARG1
1596 and ARG2 the arguments. */
1599 warn_logical_operator (enum tree_code code
, tree arg1
, tree
1604 case TRUTH_ANDIF_EXPR
:
1605 case TRUTH_ORIF_EXPR
:
1607 case TRUTH_AND_EXPR
:
1608 if (!TREE_NO_WARNING (arg1
)
1609 && INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
1610 && !CONSTANT_CLASS_P (arg1
)
1611 && TREE_CODE (arg2
) == INTEGER_CST
1612 && !integer_zerop (arg2
))
1614 warning (OPT_Wlogical_op
,
1615 "logical %<%s%> with non-zero constant "
1616 "will always evaluate as true",
1617 ((code
== TRUTH_ANDIF_EXPR
)
1618 || (code
== TRUTH_AND_EXPR
)) ? "&&" : "||");
1619 TREE_NO_WARNING (arg1
) = true;
1628 /* Print a warning about casts that might indicate violation
1629 of strict aliasing rules if -Wstrict-aliasing is used and
1630 strict aliasing mode is in effect. OTYPE is the original
1631 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1634 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
1636 if (!(flag_strict_aliasing
1637 && POINTER_TYPE_P (type
)
1638 && POINTER_TYPE_P (otype
)
1639 && !VOID_TYPE_P (TREE_TYPE (type
)))
1640 /* If the type we are casting to is a ref-all pointer
1641 dereferencing it is always valid. */
1642 || TYPE_REF_CAN_ALIAS_ALL (type
))
1645 if ((warn_strict_aliasing
> 1) && TREE_CODE (expr
) == ADDR_EXPR
1646 && (DECL_P (TREE_OPERAND (expr
, 0))
1647 || handled_component_p (TREE_OPERAND (expr
, 0))))
1649 /* Casting the address of an object to non void pointer. Warn
1650 if the cast breaks type based aliasing. */
1651 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)) && warn_strict_aliasing
== 2)
1653 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
1654 "might break strict-aliasing rules");
1659 /* warn_strict_aliasing >= 3. This includes the default (3).
1660 Only warn if the cast is dereferenced immediately. */
1661 alias_set_type set1
=
1662 get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1663 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1665 if (set1
!= set2
&& set2
!= 0
1666 && (set1
== 0 || !alias_sets_conflict_p (set1
, set2
)))
1668 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1669 "pointer will break strict-aliasing rules");
1672 else if (warn_strict_aliasing
== 2
1673 && !alias_sets_must_conflict_p (set1
, set2
))
1675 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1676 "pointer might break strict-aliasing rules");
1682 if ((warn_strict_aliasing
== 1) && !VOID_TYPE_P (TREE_TYPE (otype
)))
1684 /* At this level, warn for any conversions, even if an address is
1685 not taken in the same statement. This will likely produce many
1686 false positives, but could be useful to pinpoint problems that
1687 are not revealed at higher levels. */
1688 alias_set_type set1
= get_alias_set (TREE_TYPE (otype
));
1689 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1690 if (!COMPLETE_TYPE_P (type
)
1691 || !alias_sets_must_conflict_p (set1
, set2
))
1693 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1694 "pointer might break strict-aliasing rules");
1702 /* Warn for unlikely, improbable, or stupid DECL declarations
1706 check_main_parameter_types (tree decl
)
1711 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); args
;
1712 args
= TREE_CHAIN (args
))
1714 tree type
= args
? TREE_VALUE (args
) : 0;
1716 if (type
== void_type_node
|| type
== error_mark_node
)
1723 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
1724 pedwarn (input_location
, OPT_Wmain
, "first argument of %q+D should be %<int%>",
1729 if (TREE_CODE (type
) != POINTER_TYPE
1730 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1731 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1733 pedwarn (input_location
, OPT_Wmain
, "second argument of %q+D should be %<char **%>",
1738 if (TREE_CODE (type
) != POINTER_TYPE
1739 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1740 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1742 pedwarn (input_location
, OPT_Wmain
, "third argument of %q+D should probably be "
1743 "%<char **%>", decl
);
1748 /* It is intentional that this message does not mention the third
1749 argument because it's only mentioned in an appendix of the
1751 if (argct
> 0 && (argct
< 2 || argct
> 3))
1752 pedwarn (input_location
, OPT_Wmain
, "%q+D takes only zero or two arguments", decl
);
1755 /* True if pointers to distinct types T1 and T2 can be converted to
1756 each other without an explicit cast. Only returns true for opaque
1759 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
1761 if (TREE_CODE (t1
) == VECTOR_TYPE
&& TREE_CODE (t2
) == VECTOR_TYPE
1762 && (targetm
.vector_opaque_p (t1
) || targetm
.vector_opaque_p (t2
))
1763 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1769 /* True if vector types T1 and T2 can be converted to each other
1770 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1771 can only be converted with -flax-vector-conversions yet that is not
1772 in effect, emit a note telling the user about that option if such
1773 a note has not previously been emitted. */
1775 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
1777 static bool emitted_lax_note
= false;
1778 bool convertible_lax
;
1780 if ((targetm
.vector_opaque_p (t1
) || targetm
.vector_opaque_p (t2
))
1781 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1785 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1786 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
1787 TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
1788 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1789 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
1791 if (!convertible_lax
|| flag_lax_vector_conversions
)
1792 return convertible_lax
;
1794 if (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
1795 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1798 if (emit_lax_note
&& !emitted_lax_note
)
1800 emitted_lax_note
= true;
1801 inform (input_location
, "use -flax-vector-conversions to permit "
1802 "conversions between vectors with differing "
1803 "element types or numbers of subparts");
1809 /* This is a helper function of build_binary_op.
1811 For certain operations if both args were extended from the same
1812 smaller type, do the arithmetic in that type and then extend.
1814 BITWISE indicates a bitwise operation.
1815 For them, this optimization is safe only if
1816 both args are zero-extended or both are sign-extended.
1817 Otherwise, we might change the result.
1818 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1819 but calculated in (unsigned short) it would be (unsigned short)-1.
1821 tree
shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
1823 int unsigned0
, unsigned1
;
1828 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1829 excessive narrowing when we call get_narrower below. For
1830 example, suppose that OP0 is of unsigned int extended
1831 from signed char and that RESULT_TYPE is long long int.
1832 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1835 (long long int) (unsigned int) signed_char
1837 which get_narrower would narrow down to
1839 (unsigned int) signed char
1841 If we do not cast OP0 first, get_narrower would return
1842 signed_char, which is inconsistent with the case of the
1844 op0
= convert (result_type
, op0
);
1845 op1
= convert (result_type
, op1
);
1847 arg0
= get_narrower (op0
, &unsigned0
);
1848 arg1
= get_narrower (op1
, &unsigned1
);
1850 /* UNS is 1 if the operation to be done is an unsigned one. */
1851 uns
= TYPE_UNSIGNED (result_type
);
1853 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1854 but it *requires* conversion to FINAL_TYPE. */
1856 if ((TYPE_PRECISION (TREE_TYPE (op0
))
1857 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1858 && TREE_TYPE (op0
) != result_type
)
1859 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1860 if ((TYPE_PRECISION (TREE_TYPE (op1
))
1861 == TYPE_PRECISION (TREE_TYPE (arg1
)))
1862 && TREE_TYPE (op1
) != result_type
)
1863 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1865 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1867 /* For bitwise operations, signedness of nominal type
1868 does not matter. Consider only how operands were extended. */
1872 /* Note that in all three cases below we refrain from optimizing
1873 an unsigned operation on sign-extended args.
1874 That would not be valid. */
1876 /* Both args variable: if both extended in same way
1877 from same width, do it in that width.
1878 Do it unsigned if args were zero-extended. */
1879 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
1880 < TYPE_PRECISION (result_type
))
1881 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1882 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1883 && unsigned0
== unsigned1
1884 && (unsigned0
|| !uns
))
1885 return c_common_signed_or_unsigned_type
1886 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
1888 else if (TREE_CODE (arg0
) == INTEGER_CST
1889 && (unsigned1
|| !uns
)
1890 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1891 < TYPE_PRECISION (result_type
))
1893 = c_common_signed_or_unsigned_type (unsigned1
,
1895 && !POINTER_TYPE_P (type
)
1896 && int_fits_type_p (arg0
, type
))
1899 else if (TREE_CODE (arg1
) == INTEGER_CST
1900 && (unsigned0
|| !uns
)
1901 && (TYPE_PRECISION (TREE_TYPE (arg0
))
1902 < TYPE_PRECISION (result_type
))
1904 = c_common_signed_or_unsigned_type (unsigned0
,
1906 && !POINTER_TYPE_P (type
)
1907 && int_fits_type_p (arg1
, type
))
1913 /* Warns if the conversion of EXPR to TYPE may alter a value.
1914 This is a helper function for warnings_for_convert_and_check. */
1917 conversion_warning (tree type
, tree expr
)
1919 bool give_warning
= false;
1922 const int expr_num_operands
= TREE_OPERAND_LENGTH (expr
);
1923 tree expr_type
= TREE_TYPE (expr
);
1925 if (!warn_conversion
&& !warn_sign_conversion
)
1928 /* If any operand is artificial, then this expression was generated
1929 by the compiler and we do not warn. */
1930 for (i
= 0; i
< expr_num_operands
; i
++)
1932 tree op
= TREE_OPERAND (expr
, i
);
1933 if (op
&& DECL_P (op
) && DECL_ARTIFICIAL (op
))
1937 switch (TREE_CODE (expr
))
1945 case TRUTH_ANDIF_EXPR
:
1946 case TRUTH_ORIF_EXPR
:
1947 case TRUTH_AND_EXPR
:
1949 case TRUTH_XOR_EXPR
:
1950 case TRUTH_NOT_EXPR
:
1951 /* Conversion from boolean to a signed:1 bit-field (which only
1952 can hold the values 0 and -1) doesn't lose information - but
1953 it does change the value. */
1954 if (TYPE_PRECISION (type
) == 1 && !TYPE_UNSIGNED (type
))
1955 warning (OPT_Wconversion
,
1956 "conversion to %qT from boolean expression", type
);
1962 /* Warn for real constant that is not an exact integer converted
1964 if (TREE_CODE (expr_type
) == REAL_TYPE
1965 && TREE_CODE (type
) == INTEGER_TYPE
)
1967 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (expr_type
)))
1968 give_warning
= true;
1970 /* Warn for an integer constant that does not fit into integer type. */
1971 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1972 && TREE_CODE (type
) == INTEGER_TYPE
1973 && !int_fits_type_p (expr
, type
))
1975 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)
1976 && tree_int_cst_sgn (expr
) < 0)
1977 warning (OPT_Wsign_conversion
,
1978 "negative integer implicitly converted to unsigned type");
1979 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (expr_type
))
1980 warning (OPT_Wsign_conversion
, "conversion of unsigned constant "
1981 "value to negative integer");
1983 give_warning
= true;
1985 else if (TREE_CODE (type
) == REAL_TYPE
)
1987 /* Warn for an integer constant that does not fit into real type. */
1988 if (TREE_CODE (expr_type
) == INTEGER_TYPE
)
1990 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
1991 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1992 give_warning
= true;
1994 /* Warn for a real constant that does not fit into a smaller
1996 else if (TREE_CODE (expr_type
) == REAL_TYPE
1997 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
1999 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
2000 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
2001 give_warning
= true;
2006 warning (OPT_Wconversion
,
2007 "conversion to %qT alters %qT constant value",
2014 /* In case of COND_EXPR, if both operands are constants or
2015 COND_EXPR, then we do not care about the type of COND_EXPR,
2016 only about the conversion of each operand. */
2017 tree op1
= TREE_OPERAND (expr
, 1);
2018 tree op2
= TREE_OPERAND (expr
, 2);
2020 if ((TREE_CODE (op1
) == REAL_CST
|| TREE_CODE (op1
) == INTEGER_CST
2021 || TREE_CODE (op1
) == COND_EXPR
)
2022 && (TREE_CODE (op2
) == REAL_CST
|| TREE_CODE (op2
) == INTEGER_CST
2023 || TREE_CODE (op2
) == COND_EXPR
))
2025 conversion_warning (type
, op1
);
2026 conversion_warning (type
, op2
);
2032 default: /* 'expr' is not a constant. */
2034 /* Warn for real types converted to integer types. */
2035 if (TREE_CODE (expr_type
) == REAL_TYPE
2036 && TREE_CODE (type
) == INTEGER_TYPE
)
2037 give_warning
= true;
2039 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2040 && TREE_CODE (type
) == INTEGER_TYPE
)
2042 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2043 expr
= get_unwidened (expr
, 0);
2044 expr_type
= TREE_TYPE (expr
);
2046 /* Don't warn for short y; short x = ((int)y & 0xff); */
2047 if (TREE_CODE (expr
) == BIT_AND_EXPR
2048 || TREE_CODE (expr
) == BIT_IOR_EXPR
2049 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
2051 /* If both args were extended from a shortest type,
2052 use that type if that is safe. */
2053 expr_type
= shorten_binary_op (expr_type
,
2054 TREE_OPERAND (expr
, 0),
2055 TREE_OPERAND (expr
, 1),
2058 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
2060 tree op0
= TREE_OPERAND (expr
, 0);
2061 tree op1
= TREE_OPERAND (expr
, 1);
2062 bool unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2063 bool unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2065 /* If one of the operands is a non-negative constant
2066 that fits in the target type, then the type of the
2067 other operand does not matter. */
2068 if ((TREE_CODE (op0
) == INTEGER_CST
2069 && int_fits_type_p (op0
, c_common_signed_type (type
))
2070 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
2071 || (TREE_CODE (op1
) == INTEGER_CST
2072 && int_fits_type_p (op1
, c_common_signed_type (type
))
2073 && int_fits_type_p (op1
,
2074 c_common_unsigned_type (type
))))
2076 /* If constant is unsigned and fits in the target
2077 type, then the result will also fit. */
2078 else if ((TREE_CODE (op0
) == INTEGER_CST
2080 && int_fits_type_p (op0
, type
))
2081 || (TREE_CODE (op1
) == INTEGER_CST
2083 && int_fits_type_p (op1
, type
)))
2087 /* Warn for integer types converted to smaller integer types. */
2088 if (TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2089 give_warning
= true;
2091 /* When they are the same width but different signedness,
2092 then the value may change. */
2093 else if ((TYPE_PRECISION (type
) == TYPE_PRECISION (expr_type
)
2094 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
2095 /* Even when converted to a bigger type, if the type is
2096 unsigned but expr is signed, then negative values
2098 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
2099 warning (OPT_Wsign_conversion
, "conversion to %qT from %qT "
2100 "may change the sign of the result",
2104 /* Warn for integer types converted to real types if and only if
2105 all the range of values of the integer type cannot be
2106 represented by the real type. */
2107 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2108 && TREE_CODE (type
) == REAL_TYPE
)
2110 tree type_low_bound
= TYPE_MIN_VALUE (expr_type
);
2111 tree type_high_bound
= TYPE_MAX_VALUE (expr_type
);
2112 REAL_VALUE_TYPE real_low_bound
2113 = real_value_from_int_cst (0, type_low_bound
);
2114 REAL_VALUE_TYPE real_high_bound
2115 = real_value_from_int_cst (0, type_high_bound
);
2117 if (!exact_real_truncate (TYPE_MODE (type
), &real_low_bound
)
2118 || !exact_real_truncate (TYPE_MODE (type
), &real_high_bound
))
2119 give_warning
= true;
2122 /* Warn for real types converted to smaller real types. */
2123 else if (TREE_CODE (expr_type
) == REAL_TYPE
2124 && TREE_CODE (type
) == REAL_TYPE
2125 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2126 give_warning
= true;
2130 warning (OPT_Wconversion
,
2131 "conversion to %qT from %qT may alter its value",
2136 /* Produce warnings after a conversion. RESULT is the result of
2137 converting EXPR to TYPE. This is a helper function for
2138 convert_and_check and cp_convert_and_check. */
2141 warnings_for_convert_and_check (tree type
, tree expr
, tree result
)
2143 if (TREE_CODE (expr
) == INTEGER_CST
2144 && (TREE_CODE (type
) == INTEGER_TYPE
2145 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2146 && !int_fits_type_p (expr
, type
))
2148 /* Do not diagnose overflow in a constant expression merely
2149 because a conversion overflowed. */
2150 if (TREE_OVERFLOW (result
))
2151 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
2153 if (TYPE_UNSIGNED (type
))
2155 /* This detects cases like converting -129 or 256 to
2157 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
2158 warning (OPT_Woverflow
,
2159 "large integer implicitly truncated to unsigned type");
2161 conversion_warning (type
, expr
);
2163 else if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
2164 warning (OPT_Woverflow
,
2165 "overflow in implicit constant conversion");
2166 /* No warning for converting 0x80000000 to int. */
2168 && (TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
2169 || TYPE_PRECISION (TREE_TYPE (expr
))
2170 != TYPE_PRECISION (type
)))
2171 warning (OPT_Woverflow
,
2172 "overflow in implicit constant conversion");
2175 conversion_warning (type
, expr
);
2177 else if ((TREE_CODE (result
) == INTEGER_CST
2178 || TREE_CODE (result
) == FIXED_CST
) && TREE_OVERFLOW (result
))
2179 warning (OPT_Woverflow
,
2180 "overflow in implicit constant conversion");
2182 conversion_warning (type
, expr
);
2186 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2187 Invoke this function on every expression that is converted implicitly,
2188 i.e. because of language rules and not because of an explicit cast. */
2191 convert_and_check (tree type
, tree expr
)
2194 tree expr_for_warning
;
2196 /* Convert from a value with possible excess precision rather than
2197 via the semantic type, but do not warn about values not fitting
2198 exactly in the semantic type. */
2199 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
2201 tree orig_type
= TREE_TYPE (expr
);
2202 expr
= TREE_OPERAND (expr
, 0);
2203 expr_for_warning
= convert (orig_type
, expr
);
2204 if (orig_type
== type
)
2205 return expr_for_warning
;
2208 expr_for_warning
= expr
;
2210 if (TREE_TYPE (expr
) == type
)
2213 result
= convert (type
, expr
);
2215 if (!skip_evaluation
&& !TREE_OVERFLOW_P (expr
) && result
!= error_mark_node
)
2216 warnings_for_convert_and_check (type
, expr_for_warning
, result
);
2221 /* A node in a list that describes references to variables (EXPR), which are
2222 either read accesses if WRITER is zero, or write accesses, in which case
2223 WRITER is the parent of EXPR. */
2230 /* Used to implement a cache the results of a call to verify_tree. We only
2231 use this for SAVE_EXPRs. */
2234 struct tlist_cache
*next
;
2235 struct tlist
*cache_before_sp
;
2236 struct tlist
*cache_after_sp
;
2240 /* Obstack to use when allocating tlist structures, and corresponding
2242 static struct obstack tlist_obstack
;
2243 static char *tlist_firstobj
= 0;
2245 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2247 static struct tlist
*warned_ids
;
2248 /* SAVE_EXPRs need special treatment. We process them only once and then
2249 cache the results. */
2250 static struct tlist_cache
*save_expr_cache
;
2252 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
2253 static void merge_tlist (struct tlist
**, struct tlist
*, int);
2254 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
2255 static int warning_candidate_p (tree
);
2256 static void warn_for_collisions (struct tlist
*);
2257 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
2258 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
2260 /* Create a new struct tlist and fill in its fields. */
2261 static struct tlist
*
2262 new_tlist (struct tlist
*next
, tree t
, tree writer
)
2265 l
= XOBNEW (&tlist_obstack
, struct tlist
);
2272 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2273 is nonnull, we ignore any node we find which has a writer equal to it. */
2276 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
2280 struct tlist
*next
= add
->next
;
2283 if (!exclude_writer
|| add
->writer
!= exclude_writer
)
2284 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
2289 /* Merge the nodes of ADD into TO. This merging process is done so that for
2290 each variable that already exists in TO, no new node is added; however if
2291 there is a write access recorded in ADD, and an occurrence on TO is only
2292 a read access, then the occurrence in TO will be modified to record the
2296 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
2298 struct tlist
**end
= to
;
2301 end
= &(*end
)->next
;
2307 struct tlist
*next
= add
->next
;
2309 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
2310 if (tmp2
->expr
== add
->expr
)
2314 tmp2
->writer
= add
->writer
;
2318 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
2319 end
= &(*end
)->next
;
2326 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2327 references in list LIST conflict with it, excluding reads if ONLY writers
2331 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
2336 /* Avoid duplicate warnings. */
2337 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
2338 if (tmp
->expr
== written
)
2343 if (list
->expr
== written
2344 && list
->writer
!= writer
2345 && (!only_writes
|| list
->writer
)
2346 && DECL_NAME (list
->expr
))
2348 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
2349 warning_at (EXPR_HAS_LOCATION (writer
)
2350 ? EXPR_LOCATION (writer
) : input_location
,
2351 OPT_Wsequence_point
, "operation on %qE may be undefined",
2358 /* Given a list LIST of references to variables, find whether any of these
2359 can cause conflicts due to missing sequence points. */
2362 warn_for_collisions (struct tlist
*list
)
2366 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
2369 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
2373 /* Return nonzero if X is a tree that can be verified by the sequence point
2376 warning_candidate_p (tree x
)
2378 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
2381 /* Walk the tree X, and record accesses to variables. If X is written by the
2382 parent tree, WRITER is the parent.
2383 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2384 expression or its only operand forces a sequence point, then everything up
2385 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2387 Once we return, we will have emitted warnings if any subexpression before
2388 such a sequence point could be undefined. On a higher level, however, the
2389 sequence point may not be relevant, and we'll merge the two lists.
2391 Example: (b++, a) + b;
2392 The call that processes the COMPOUND_EXPR will store the increment of B
2393 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2394 processes the PLUS_EXPR will need to merge the two lists so that
2395 eventually, all accesses end up on the same list (and we'll warn about the
2396 unordered subexpressions b++ and b.
2398 A note on merging. If we modify the former example so that our expression
2401 care must be taken not simply to add all three expressions into the final
2402 PNO_SP list. The function merge_tlist takes care of that by merging the
2403 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2404 way, so that no more than one access to B is recorded. */
2407 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
2410 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
2411 enum tree_code code
;
2412 enum tree_code_class cl
;
2414 /* X may be NULL if it is the operand of an empty statement expression
2420 code
= TREE_CODE (x
);
2421 cl
= TREE_CODE_CLASS (code
);
2423 if (warning_candidate_p (x
))
2425 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
2435 case TRUTH_ANDIF_EXPR
:
2436 case TRUTH_ORIF_EXPR
:
2437 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2438 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2439 warn_for_collisions (tmp_nosp
);
2440 merge_tlist (pbefore_sp
, tmp_before
, 0);
2441 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
2442 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
2443 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2447 tmp_before
= tmp_list2
= 0;
2448 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
2449 warn_for_collisions (tmp_list2
);
2450 merge_tlist (pbefore_sp
, tmp_before
, 0);
2451 merge_tlist (pbefore_sp
, tmp_list2
, 1);
2453 tmp_list3
= tmp_nosp
= 0;
2454 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
2455 warn_for_collisions (tmp_nosp
);
2456 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2458 tmp_list3
= tmp_list2
= 0;
2459 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
2460 warn_for_collisions (tmp_list2
);
2461 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2462 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2463 two first, to avoid warning for (a ? b++ : b++). */
2464 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
2465 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2468 case PREDECREMENT_EXPR
:
2469 case PREINCREMENT_EXPR
:
2470 case POSTDECREMENT_EXPR
:
2471 case POSTINCREMENT_EXPR
:
2472 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
2476 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2477 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2478 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
2479 /* Expressions inside the LHS are not ordered wrt. the sequence points
2480 in the RHS. Example:
2482 Despite the fact that the modification of "a" is in the before_sp
2483 list (tmp_before), it conflicts with the use of "a" in the LHS.
2484 We can handle this by adding the contents of tmp_list3
2485 to those of tmp_before, and redoing the collision warnings for that
2487 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
2488 warn_for_collisions (tmp_before
);
2489 /* Exclude the LHS itself here; we first have to merge it into the
2490 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2491 didn't exclude the LHS, we'd get it twice, once as a read and once
2493 add_tlist (pno_sp
, tmp_list3
, x
, 0);
2494 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
2496 merge_tlist (pbefore_sp
, tmp_before
, 0);
2497 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
2498 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
2499 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
2503 /* We need to warn about conflicts among arguments and conflicts between
2504 args and the function address. Side effects of the function address,
2505 however, are not ordered by the sequence point of the call. */
2507 call_expr_arg_iterator iter
;
2509 tmp_before
= tmp_nosp
= 0;
2510 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2511 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
2513 tmp_list2
= tmp_list3
= 0;
2514 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
2515 merge_tlist (&tmp_list3
, tmp_list2
, 0);
2516 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
2518 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
2519 warn_for_collisions (tmp_before
);
2520 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
2525 /* Scan all the list, e.g. indices of multi dimensional array. */
2528 tmp_before
= tmp_nosp
= 0;
2529 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2530 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2531 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2538 struct tlist_cache
*t
;
2539 for (t
= save_expr_cache
; t
; t
= t
->next
)
2545 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
2546 t
->next
= save_expr_cache
;
2548 save_expr_cache
= t
;
2550 tmp_before
= tmp_nosp
= 0;
2551 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2552 warn_for_collisions (tmp_nosp
);
2557 struct tlist
*t
= tmp_nosp
;
2559 merge_tlist (&tmp_list3
, t
, 0);
2561 t
->cache_before_sp
= tmp_before
;
2562 t
->cache_after_sp
= tmp_list3
;
2564 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
2565 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
2570 x
= TREE_OPERAND (x
, 0);
2577 /* For other expressions, simply recurse on their operands.
2578 Manual tail recursion for unary expressions.
2579 Other non-expressions need not be processed. */
2580 if (cl
== tcc_unary
)
2582 x
= TREE_OPERAND (x
, 0);
2586 else if (IS_EXPR_CODE_CLASS (cl
))
2589 int max
= TREE_OPERAND_LENGTH (x
);
2590 for (lp
= 0; lp
< max
; lp
++)
2592 tmp_before
= tmp_nosp
= 0;
2593 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
2594 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2595 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2602 /* Try to warn for undefined behavior in EXPR due to missing sequence
2606 verify_sequence_points (tree expr
)
2608 struct tlist
*before_sp
= 0, *after_sp
= 0;
2611 save_expr_cache
= 0;
2612 if (tlist_firstobj
== 0)
2614 gcc_obstack_init (&tlist_obstack
);
2615 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
2618 verify_tree (expr
, &before_sp
, &after_sp
, 0);
2619 warn_for_collisions (after_sp
);
2620 obstack_free (&tlist_obstack
, tlist_firstobj
);
2623 /* Validate the expression after `case' and apply default promotions. */
2626 check_case_value (tree value
)
2628 if (value
== NULL_TREE
)
2631 /* ??? Can we ever get nops here for a valid case value? We
2633 STRIP_TYPE_NOPS (value
);
2634 /* In C++, the following is allowed:
2637 switch (...) { case i: ... }
2639 So, we try to reduce the VALUE to a constant that way. */
2640 if (c_dialect_cxx ())
2642 value
= decl_constant_value (value
);
2643 STRIP_TYPE_NOPS (value
);
2644 value
= fold (value
);
2647 if (TREE_CODE (value
) == INTEGER_CST
)
2648 /* Promote char or short to int. */
2649 value
= perform_integral_promotions (value
);
2650 else if (value
!= error_mark_node
)
2652 error ("case label does not reduce to an integer constant");
2653 value
= error_mark_node
;
2656 constant_expression_warning (value
);
2661 /* See if the case values LOW and HIGH are in the range of the original
2662 type (i.e. before the default conversion to int) of the switch testing
2664 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2665 the type before promoting it. CASE_LOW_P is a pointer to the lower
2666 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2667 if the case is not a case range.
2668 The caller has to make sure that we are not called with NULL for
2669 CASE_LOW_P (i.e. the default case).
2670 Returns true if the case label is in range of ORIG_TYPE (saturated or
2671 untouched) or false if the label is out of range. */
2674 check_case_bounds (tree type
, tree orig_type
,
2675 tree
*case_low_p
, tree
*case_high_p
)
2677 tree min_value
, max_value
;
2678 tree case_low
= *case_low_p
;
2679 tree case_high
= case_high_p
? *case_high_p
: case_low
;
2681 /* If there was a problem with the original type, do nothing. */
2682 if (orig_type
== error_mark_node
)
2685 min_value
= TYPE_MIN_VALUE (orig_type
);
2686 max_value
= TYPE_MAX_VALUE (orig_type
);
2688 /* Case label is less than minimum for type. */
2689 if (tree_int_cst_compare (case_low
, min_value
) < 0
2690 && tree_int_cst_compare (case_high
, min_value
) < 0)
2692 warning (0, "case label value is less than minimum value for type");
2696 /* Case value is greater than maximum for type. */
2697 if (tree_int_cst_compare (case_low
, max_value
) > 0
2698 && tree_int_cst_compare (case_high
, max_value
) > 0)
2700 warning (0, "case label value exceeds maximum value for type");
2704 /* Saturate lower case label value to minimum. */
2705 if (tree_int_cst_compare (case_high
, min_value
) >= 0
2706 && tree_int_cst_compare (case_low
, min_value
) < 0)
2708 warning (0, "lower value in case label range"
2709 " less than minimum value for type");
2710 case_low
= min_value
;
2713 /* Saturate upper case label value to maximum. */
2714 if (tree_int_cst_compare (case_low
, max_value
) <= 0
2715 && tree_int_cst_compare (case_high
, max_value
) > 0)
2717 warning (0, "upper value in case label range"
2718 " exceeds maximum value for type");
2719 case_high
= max_value
;
2722 if (*case_low_p
!= case_low
)
2723 *case_low_p
= convert (type
, case_low
);
2724 if (case_high_p
&& *case_high_p
!= case_high
)
2725 *case_high_p
= convert (type
, case_high
);
2730 /* Return an integer type with BITS bits of precision,
2731 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2734 c_common_type_for_size (unsigned int bits
, int unsignedp
)
2736 if (bits
== TYPE_PRECISION (integer_type_node
))
2737 return unsignedp
? unsigned_type_node
: integer_type_node
;
2739 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2740 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2742 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2743 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2745 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2746 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2748 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2749 return (unsignedp
? long_long_unsigned_type_node
2750 : long_long_integer_type_node
);
2752 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2753 return (unsignedp
? widest_unsigned_literal_type_node
2754 : widest_integer_literal_type_node
);
2756 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2757 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2759 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2760 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2762 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2763 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2765 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2766 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2771 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2772 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2773 and saturating if SATP is nonzero, otherwise not saturating. */
2776 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
2777 int unsignedp
, int satp
)
2779 enum machine_mode mode
;
2781 mode
= unsignedp
? UQQmode
: QQmode
;
2783 mode
= unsignedp
? UHAmode
: HAmode
;
2785 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
2786 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2789 if (mode
== VOIDmode
|| !targetm
.scalar_mode_supported_p (mode
))
2791 sorry ("GCC cannot support operators with integer types and "
2792 "fixed-point types that have too many integral and "
2793 "fractional bits together");
2797 return c_common_type_for_mode (mode
, satp
);
2800 /* Used for communication between c_common_type_for_mode and
2801 c_register_builtin_type. */
2802 static GTY(()) tree registered_builtin_types
;
2804 /* Return a data type that has machine mode MODE.
2805 If the mode is an integer,
2806 then UNSIGNEDP selects between signed and unsigned types.
2807 If the mode is a fixed-point mode,
2808 then UNSIGNEDP selects between saturating and nonsaturating types. */
2811 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
2815 if (mode
== TYPE_MODE (integer_type_node
))
2816 return unsignedp
? unsigned_type_node
: integer_type_node
;
2818 if (mode
== TYPE_MODE (signed_char_type_node
))
2819 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2821 if (mode
== TYPE_MODE (short_integer_type_node
))
2822 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2824 if (mode
== TYPE_MODE (long_integer_type_node
))
2825 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2827 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2828 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2830 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2831 return unsignedp
? widest_unsigned_literal_type_node
2832 : widest_integer_literal_type_node
;
2835 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2838 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2841 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2844 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2846 #if HOST_BITS_PER_WIDE_INT >= 64
2847 if (mode
== TYPE_MODE (intTI_type_node
))
2848 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2851 if (mode
== TYPE_MODE (float_type_node
))
2852 return float_type_node
;
2854 if (mode
== TYPE_MODE (double_type_node
))
2855 return double_type_node
;
2857 if (mode
== TYPE_MODE (long_double_type_node
))
2858 return long_double_type_node
;
2860 if (mode
== TYPE_MODE (void_type_node
))
2861 return void_type_node
;
2863 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2865 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2866 : make_signed_type (GET_MODE_PRECISION (mode
)));
2868 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2870 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2871 : make_signed_type (GET_MODE_PRECISION (mode
)));
2873 if (COMPLEX_MODE_P (mode
))
2875 enum machine_mode inner_mode
;
2878 if (mode
== TYPE_MODE (complex_float_type_node
))
2879 return complex_float_type_node
;
2880 if (mode
== TYPE_MODE (complex_double_type_node
))
2881 return complex_double_type_node
;
2882 if (mode
== TYPE_MODE (complex_long_double_type_node
))
2883 return complex_long_double_type_node
;
2885 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
2886 return complex_integer_type_node
;
2888 inner_mode
= GET_MODE_INNER (mode
);
2889 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2890 if (inner_type
!= NULL_TREE
)
2891 return build_complex_type (inner_type
);
2893 else if (VECTOR_MODE_P (mode
))
2895 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
2896 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2897 if (inner_type
!= NULL_TREE
)
2898 return build_vector_type_for_mode (inner_type
, mode
);
2901 if (mode
== TYPE_MODE (dfloat32_type_node
))
2902 return dfloat32_type_node
;
2903 if (mode
== TYPE_MODE (dfloat64_type_node
))
2904 return dfloat64_type_node
;
2905 if (mode
== TYPE_MODE (dfloat128_type_node
))
2906 return dfloat128_type_node
;
2908 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
2910 if (mode
== TYPE_MODE (short_fract_type_node
))
2911 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
2912 if (mode
== TYPE_MODE (fract_type_node
))
2913 return unsignedp
? sat_fract_type_node
: fract_type_node
;
2914 if (mode
== TYPE_MODE (long_fract_type_node
))
2915 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
2916 if (mode
== TYPE_MODE (long_long_fract_type_node
))
2917 return unsignedp
? sat_long_long_fract_type_node
2918 : long_long_fract_type_node
;
2920 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
2921 return unsignedp
? sat_unsigned_short_fract_type_node
2922 : unsigned_short_fract_type_node
;
2923 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
2924 return unsignedp
? sat_unsigned_fract_type_node
2925 : unsigned_fract_type_node
;
2926 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
2927 return unsignedp
? sat_unsigned_long_fract_type_node
2928 : unsigned_long_fract_type_node
;
2929 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
2930 return unsignedp
? sat_unsigned_long_long_fract_type_node
2931 : unsigned_long_long_fract_type_node
;
2933 if (mode
== TYPE_MODE (short_accum_type_node
))
2934 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
2935 if (mode
== TYPE_MODE (accum_type_node
))
2936 return unsignedp
? sat_accum_type_node
: accum_type_node
;
2937 if (mode
== TYPE_MODE (long_accum_type_node
))
2938 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
2939 if (mode
== TYPE_MODE (long_long_accum_type_node
))
2940 return unsignedp
? sat_long_long_accum_type_node
2941 : long_long_accum_type_node
;
2943 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
2944 return unsignedp
? sat_unsigned_short_accum_type_node
2945 : unsigned_short_accum_type_node
;
2946 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
2947 return unsignedp
? sat_unsigned_accum_type_node
2948 : unsigned_accum_type_node
;
2949 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
2950 return unsignedp
? sat_unsigned_long_accum_type_node
2951 : unsigned_long_accum_type_node
;
2952 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
2953 return unsignedp
? sat_unsigned_long_long_accum_type_node
2954 : unsigned_long_long_accum_type_node
;
2957 return unsignedp
? sat_qq_type_node
: qq_type_node
;
2959 return unsignedp
? sat_hq_type_node
: hq_type_node
;
2961 return unsignedp
? sat_sq_type_node
: sq_type_node
;
2963 return unsignedp
? sat_dq_type_node
: dq_type_node
;
2965 return unsignedp
? sat_tq_type_node
: tq_type_node
;
2967 if (mode
== UQQmode
)
2968 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
2969 if (mode
== UHQmode
)
2970 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
2971 if (mode
== USQmode
)
2972 return unsignedp
? sat_usq_type_node
: usq_type_node
;
2973 if (mode
== UDQmode
)
2974 return unsignedp
? sat_udq_type_node
: udq_type_node
;
2975 if (mode
== UTQmode
)
2976 return unsignedp
? sat_utq_type_node
: utq_type_node
;
2979 return unsignedp
? sat_ha_type_node
: ha_type_node
;
2981 return unsignedp
? sat_sa_type_node
: sa_type_node
;
2983 return unsignedp
? sat_da_type_node
: da_type_node
;
2985 return unsignedp
? sat_ta_type_node
: ta_type_node
;
2987 if (mode
== UHAmode
)
2988 return unsignedp
? sat_uha_type_node
: uha_type_node
;
2989 if (mode
== USAmode
)
2990 return unsignedp
? sat_usa_type_node
: usa_type_node
;
2991 if (mode
== UDAmode
)
2992 return unsignedp
? sat_uda_type_node
: uda_type_node
;
2993 if (mode
== UTAmode
)
2994 return unsignedp
? sat_uta_type_node
: uta_type_node
;
2997 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
2998 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
2999 return TREE_VALUE (t
);
3005 c_common_unsigned_type (tree type
)
3007 return c_common_signed_or_unsigned_type (1, type
);
3010 /* Return a signed type the same as TYPE in other respects. */
3013 c_common_signed_type (tree type
)
3015 return c_common_signed_or_unsigned_type (0, type
);
3018 /* Return a type the same as TYPE except unsigned or
3019 signed according to UNSIGNEDP. */
3022 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
3026 /* This block of code emulates the behavior of the old
3027 c_common_unsigned_type. In particular, it returns
3028 long_unsigned_type_node if passed a long, even when a int would
3029 have the same size. This is necessary for warnings to work
3030 correctly in archs where sizeof(int) == sizeof(long) */
3032 type1
= TYPE_MAIN_VARIANT (type
);
3033 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
3034 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3035 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
3036 return unsignedp
? unsigned_type_node
: integer_type_node
;
3037 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
3038 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3039 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
3040 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3041 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
3042 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
3043 if (type1
== widest_integer_literal_type_node
|| type1
== widest_unsigned_literal_type_node
)
3044 return unsignedp
? widest_unsigned_literal_type_node
: widest_integer_literal_type_node
;
3045 #if HOST_BITS_PER_WIDE_INT >= 64
3046 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
3047 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3049 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
3050 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3051 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
3052 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3053 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
3054 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3055 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
3056 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3058 #define C_COMMON_FIXED_TYPES(NAME) \
3059 if (type1 == short_ ## NAME ## _type_node \
3060 || type1 == unsigned_short_ ## NAME ## _type_node) \
3061 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3062 : short_ ## NAME ## _type_node; \
3063 if (type1 == NAME ## _type_node \
3064 || type1 == unsigned_ ## NAME ## _type_node) \
3065 return unsignedp ? unsigned_ ## NAME ## _type_node \
3066 : NAME ## _type_node; \
3067 if (type1 == long_ ## NAME ## _type_node \
3068 || type1 == unsigned_long_ ## NAME ## _type_node) \
3069 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3070 : long_ ## NAME ## _type_node; \
3071 if (type1 == long_long_ ## NAME ## _type_node \
3072 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3073 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3074 : long_long_ ## NAME ## _type_node;
3076 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3077 if (type1 == NAME ## _type_node \
3078 || type1 == u ## NAME ## _type_node) \
3079 return unsignedp ? u ## NAME ## _type_node \
3080 : NAME ## _type_node;
3082 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3083 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3084 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3085 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3086 : sat_ ## short_ ## NAME ## _type_node; \
3087 if (type1 == sat_ ## NAME ## _type_node \
3088 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3089 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3090 : sat_ ## NAME ## _type_node; \
3091 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3092 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3093 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3094 : sat_ ## long_ ## NAME ## _type_node; \
3095 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3096 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3097 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3098 : sat_ ## long_long_ ## NAME ## _type_node;
3100 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3101 if (type1 == sat_ ## NAME ## _type_node \
3102 || type1 == sat_ ## u ## NAME ## _type_node) \
3103 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3104 : sat_ ## NAME ## _type_node;
3106 C_COMMON_FIXED_TYPES (fract
);
3107 C_COMMON_FIXED_TYPES_SAT (fract
);
3108 C_COMMON_FIXED_TYPES (accum
);
3109 C_COMMON_FIXED_TYPES_SAT (accum
);
3111 C_COMMON_FIXED_MODE_TYPES (qq
);
3112 C_COMMON_FIXED_MODE_TYPES (hq
);
3113 C_COMMON_FIXED_MODE_TYPES (sq
);
3114 C_COMMON_FIXED_MODE_TYPES (dq
);
3115 C_COMMON_FIXED_MODE_TYPES (tq
);
3116 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
3117 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
3118 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
3119 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
3120 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
3121 C_COMMON_FIXED_MODE_TYPES (ha
);
3122 C_COMMON_FIXED_MODE_TYPES (sa
);
3123 C_COMMON_FIXED_MODE_TYPES (da
);
3124 C_COMMON_FIXED_MODE_TYPES (ta
);
3125 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
3126 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
3127 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
3128 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
3130 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3131 the precision; they have precision set to match their range, but
3132 may use a wider mode to match an ABI. If we change modes, we may
3133 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3134 the precision as well, so as to yield correct results for
3135 bit-field types. C++ does not have these separate bit-field
3136 types, and producing a signed or unsigned variant of an
3137 ENUMERAL_TYPE may cause other problems as well. */
3139 if (!INTEGRAL_TYPE_P (type
)
3140 || TYPE_UNSIGNED (type
) == unsignedp
)
3143 #define TYPE_OK(node) \
3144 (TYPE_MODE (type) == TYPE_MODE (node) \
3145 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3146 if (TYPE_OK (signed_char_type_node
))
3147 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3148 if (TYPE_OK (integer_type_node
))
3149 return unsignedp
? unsigned_type_node
: integer_type_node
;
3150 if (TYPE_OK (short_integer_type_node
))
3151 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3152 if (TYPE_OK (long_integer_type_node
))
3153 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3154 if (TYPE_OK (long_long_integer_type_node
))
3155 return (unsignedp
? long_long_unsigned_type_node
3156 : long_long_integer_type_node
);
3157 if (TYPE_OK (widest_integer_literal_type_node
))
3158 return (unsignedp
? widest_unsigned_literal_type_node
3159 : widest_integer_literal_type_node
);
3161 #if HOST_BITS_PER_WIDE_INT >= 64
3162 if (TYPE_OK (intTI_type_node
))
3163 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3165 if (TYPE_OK (intDI_type_node
))
3166 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3167 if (TYPE_OK (intSI_type_node
))
3168 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3169 if (TYPE_OK (intHI_type_node
))
3170 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3171 if (TYPE_OK (intQI_type_node
))
3172 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3175 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
3178 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3181 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
3183 /* Extended integer types of the same width as a standard type have
3184 lesser rank, so those of the same width as int promote to int or
3185 unsigned int and are valid for printf formats expecting int or
3186 unsigned int. To avoid such special cases, avoid creating
3187 extended integer types for bit-fields if a standard integer type
3189 if (width
== TYPE_PRECISION (integer_type_node
))
3190 return unsignedp
? unsigned_type_node
: integer_type_node
;
3191 if (width
== TYPE_PRECISION (signed_char_type_node
))
3192 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3193 if (width
== TYPE_PRECISION (short_integer_type_node
))
3194 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3195 if (width
== TYPE_PRECISION (long_integer_type_node
))
3196 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3197 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
3198 return (unsignedp
? long_long_unsigned_type_node
3199 : long_long_integer_type_node
);
3200 return build_nonstandard_integer_type (width
, unsignedp
);
3203 /* The C version of the register_builtin_type langhook. */
3206 c_register_builtin_type (tree type
, const char* name
)
3210 decl
= build_decl (TYPE_DECL
, get_identifier (name
), type
);
3211 DECL_ARTIFICIAL (decl
) = 1;
3212 if (!TYPE_NAME (type
))
3213 TYPE_NAME (type
) = decl
;
3216 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
3219 /* Print an error message for invalid operands to arith operation
3220 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3221 LOCATION is the location of the message. */
3224 binary_op_error (location_t location
, enum tree_code code
,
3225 tree type0
, tree type1
)
3232 opname
= "+"; break;
3234 opname
= "-"; break;
3236 opname
= "*"; break;
3238 opname
= "max"; break;
3240 opname
= "min"; break;
3242 opname
= "=="; break;
3244 opname
= "!="; break;
3246 opname
= "<="; break;
3248 opname
= ">="; break;
3250 opname
= "<"; break;
3252 opname
= ">"; break;
3254 opname
= "<<"; break;
3256 opname
= ">>"; break;
3257 case TRUNC_MOD_EXPR
:
3258 case FLOOR_MOD_EXPR
:
3259 opname
= "%"; break;
3260 case TRUNC_DIV_EXPR
:
3261 case FLOOR_DIV_EXPR
:
3262 opname
= "/"; break;
3264 opname
= "&"; break;
3266 opname
= "|"; break;
3267 case TRUTH_ANDIF_EXPR
:
3268 opname
= "&&"; break;
3269 case TRUTH_ORIF_EXPR
:
3270 opname
= "||"; break;
3272 opname
= "^"; break;
3277 "invalid operands to binary %s (have %qT and %qT)", opname
,
3281 /* Subroutine of build_binary_op, used for comparison operations.
3282 See if the operands have both been converted from subword integer types
3283 and, if so, perhaps change them both back to their original type.
3284 This function is also responsible for converting the two operands
3285 to the proper common type for comparison.
3287 The arguments of this function are all pointers to local variables
3288 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3289 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3291 If this function returns nonzero, it means that the comparison has
3292 a constant value. What this function returns is an expression for
3296 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
3297 enum tree_code
*rescode_ptr
)
3300 tree op0
= *op0_ptr
;
3301 tree op1
= *op1_ptr
;
3302 int unsignedp0
, unsignedp1
;
3304 tree primop0
, primop1
;
3305 enum tree_code code
= *rescode_ptr
;
3307 /* Throw away any conversions to wider types
3308 already present in the operands. */
3310 primop0
= get_narrower (op0
, &unsignedp0
);
3311 primop1
= get_narrower (op1
, &unsignedp1
);
3313 /* Handle the case that OP0 does not *contain* a conversion
3314 but it *requires* conversion to FINAL_TYPE. */
3316 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
3317 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
3318 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
3319 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
3321 /* If one of the operands must be floated, we cannot optimize. */
3322 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
3323 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
3325 /* If first arg is constant, swap the args (changing operation
3326 so value is preserved), for canonicalization. Don't do this if
3327 the second arg is 0. */
3329 if (TREE_CONSTANT (primop0
)
3330 && !integer_zerop (primop1
) && !real_zerop (primop1
)
3331 && !fixed_zerop (primop1
))
3334 int temi
= unsignedp0
;
3342 unsignedp0
= unsignedp1
;
3365 *rescode_ptr
= code
;
3368 /* If comparing an integer against a constant more bits wide,
3369 maybe we can deduce a value of 1 or 0 independent of the data.
3370 Or else truncate the constant now
3371 rather than extend the variable at run time.
3373 This is only interesting if the constant is the wider arg.
3374 Also, it is not safe if the constant is unsigned and the
3375 variable arg is signed, since in this case the variable
3376 would be sign-extended and then regarded as unsigned.
3377 Our technique fails in this case because the lowest/highest
3378 possible unsigned results don't follow naturally from the
3379 lowest/highest possible values of the variable operand.
3380 For just EQ_EXPR and NE_EXPR there is another technique that
3381 could be used: see if the constant can be faithfully represented
3382 in the other operand's type, by truncating it and reextending it
3383 and see if that preserves the constant's value. */
3385 if (!real1
&& !real2
3386 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
3387 && TREE_CODE (primop1
) == INTEGER_CST
3388 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
3390 int min_gt
, max_gt
, min_lt
, max_lt
;
3391 tree maxval
, minval
;
3392 /* 1 if comparison is nominally unsigned. */
3393 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
3396 type
= c_common_signed_or_unsigned_type (unsignedp0
,
3397 TREE_TYPE (primop0
));
3399 maxval
= TYPE_MAX_VALUE (type
);
3400 minval
= TYPE_MIN_VALUE (type
);
3402 if (unsignedp
&& !unsignedp0
)
3403 *restype_ptr
= c_common_signed_type (*restype_ptr
);
3405 if (TREE_TYPE (primop1
) != *restype_ptr
)
3407 /* Convert primop1 to target type, but do not introduce
3408 additional overflow. We know primop1 is an int_cst. */
3409 primop1
= force_fit_type_double (*restype_ptr
,
3410 TREE_INT_CST_LOW (primop1
),
3411 TREE_INT_CST_HIGH (primop1
), 0,
3412 TREE_OVERFLOW (primop1
));
3414 if (type
!= *restype_ptr
)
3416 minval
= convert (*restype_ptr
, minval
);
3417 maxval
= convert (*restype_ptr
, maxval
);
3420 if (unsignedp
&& unsignedp0
)
3422 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
3423 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
3424 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
3425 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
3429 min_gt
= INT_CST_LT (primop1
, minval
);
3430 max_gt
= INT_CST_LT (primop1
, maxval
);
3431 min_lt
= INT_CST_LT (minval
, primop1
);
3432 max_lt
= INT_CST_LT (maxval
, primop1
);
3436 /* This used to be a switch, but Genix compiler can't handle that. */
3437 if (code
== NE_EXPR
)
3439 if (max_lt
|| min_gt
)
3440 val
= truthvalue_true_node
;
3442 else if (code
== EQ_EXPR
)
3444 if (max_lt
|| min_gt
)
3445 val
= truthvalue_false_node
;
3447 else if (code
== LT_EXPR
)
3450 val
= truthvalue_true_node
;
3452 val
= truthvalue_false_node
;
3454 else if (code
== GT_EXPR
)
3457 val
= truthvalue_true_node
;
3459 val
= truthvalue_false_node
;
3461 else if (code
== LE_EXPR
)
3464 val
= truthvalue_true_node
;
3466 val
= truthvalue_false_node
;
3468 else if (code
== GE_EXPR
)
3471 val
= truthvalue_true_node
;
3473 val
= truthvalue_false_node
;
3476 /* If primop0 was sign-extended and unsigned comparison specd,
3477 we did a signed comparison above using the signed type bounds.
3478 But the comparison we output must be unsigned.
3480 Also, for inequalities, VAL is no good; but if the signed
3481 comparison had *any* fixed result, it follows that the
3482 unsigned comparison just tests the sign in reverse
3483 (positive values are LE, negative ones GE).
3484 So we can generate an unsigned comparison
3485 against an extreme value of the signed type. */
3487 if (unsignedp
&& !unsignedp0
)
3494 primop1
= TYPE_MIN_VALUE (type
);
3500 primop1
= TYPE_MAX_VALUE (type
);
3507 type
= c_common_unsigned_type (type
);
3510 if (TREE_CODE (primop0
) != INTEGER_CST
)
3512 if (val
== truthvalue_false_node
)
3513 warning (OPT_Wtype_limits
, "comparison is always false due to limited range of data type");
3514 if (val
== truthvalue_true_node
)
3515 warning (OPT_Wtype_limits
, "comparison is always true due to limited range of data type");
3520 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3521 if (TREE_SIDE_EFFECTS (primop0
))
3522 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
3526 /* Value is not predetermined, but do the comparison
3527 in the type of the operand that is not constant.
3528 TYPE is already properly set. */
3531 /* If either arg is decimal float and the other is float, find the
3532 proper common type to use for comparison. */
3533 else if (real1
&& real2
3534 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3535 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
3536 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3538 else if (real1
&& real2
3539 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3540 == TYPE_PRECISION (TREE_TYPE (primop1
))))
3541 type
= TREE_TYPE (primop0
);
3543 /* If args' natural types are both narrower than nominal type
3544 and both extend in the same manner, compare them
3545 in the type of the wider arg.
3546 Otherwise must actually extend both to the nominal
3547 common type lest different ways of extending
3549 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3551 else if (unsignedp0
== unsignedp1
&& real1
== real2
3552 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
3553 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
3555 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3556 type
= c_common_signed_or_unsigned_type (unsignedp0
3557 || TYPE_UNSIGNED (*restype_ptr
),
3559 /* Make sure shorter operand is extended the right way
3560 to match the longer operand. */
3562 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
3563 TREE_TYPE (primop0
)),
3566 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
3567 TREE_TYPE (primop1
)),
3572 /* Here we must do the comparison on the nominal type
3573 using the args exactly as we received them. */
3574 type
= *restype_ptr
;
3578 if (!real1
&& !real2
&& integer_zerop (primop1
)
3579 && TYPE_UNSIGNED (*restype_ptr
))
3585 /* All unsigned values are >= 0, so we warn. However,
3586 if OP0 is a constant that is >= 0, the signedness of
3587 the comparison isn't an issue, so suppress the
3589 if (warn_type_limits
&& !in_system_header
3590 && !(TREE_CODE (primop0
) == INTEGER_CST
3591 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3593 warning (OPT_Wtype_limits
,
3594 "comparison of unsigned expression >= 0 is always true");
3595 value
= truthvalue_true_node
;
3599 if (warn_type_limits
&& !in_system_header
3600 && !(TREE_CODE (primop0
) == INTEGER_CST
3601 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3603 warning (OPT_Wtype_limits
,
3604 "comparison of unsigned expression < 0 is always false");
3605 value
= truthvalue_false_node
;
3614 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3615 if (TREE_SIDE_EFFECTS (primop0
))
3616 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3623 *op0_ptr
= convert (type
, primop0
);
3624 *op1_ptr
= convert (type
, primop1
);
3626 *restype_ptr
= truthvalue_type_node
;
3631 /* Return a tree for the sum or difference (RESULTCODE says which)
3632 of pointer PTROP and integer INTOP. */
3635 pointer_int_sum (location_t location
, enum tree_code resultcode
,
3636 tree ptrop
, tree intop
)
3640 /* The result is a pointer of the same type that is being added. */
3641 tree result_type
= TREE_TYPE (ptrop
);
3643 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3645 pedwarn (location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3646 "pointer of type %<void *%> used in arithmetic");
3647 size_exp
= integer_one_node
;
3649 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3651 pedwarn (location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3652 "pointer to a function used in arithmetic");
3653 size_exp
= integer_one_node
;
3655 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3657 pedwarn (location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3658 "pointer to member function used in arithmetic");
3659 size_exp
= integer_one_node
;
3662 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3664 /* We are manipulating pointer values, so we don't need to warn
3665 about relying on undefined signed overflow. We disable the
3666 warning here because we use integer types so fold won't know that
3667 they are really pointers. */
3668 fold_defer_overflow_warnings ();
3670 /* If what we are about to multiply by the size of the elements
3671 contains a constant term, apply distributive law
3672 and multiply that constant term separately.
3673 This helps produce common subexpressions. */
3674 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3675 && !TREE_CONSTANT (intop
)
3676 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3677 && TREE_CONSTANT (size_exp
)
3678 /* If the constant comes from pointer subtraction,
3679 skip this optimization--it would cause an error. */
3680 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
3681 /* If the constant is unsigned, and smaller than the pointer size,
3682 then we must skip this optimization. This is because it could cause
3683 an overflow error if the constant is negative but INTOP is not. */
3684 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
3685 || (TYPE_PRECISION (TREE_TYPE (intop
))
3686 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
3688 enum tree_code subcode
= resultcode
;
3689 tree int_type
= TREE_TYPE (intop
);
3690 if (TREE_CODE (intop
) == MINUS_EXPR
)
3691 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3692 /* Convert both subexpression types to the type of intop,
3693 because weird cases involving pointer arithmetic
3694 can result in a sum or difference with different type args. */
3695 ptrop
= build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop
, 1)),
3697 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
3698 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
3701 /* Convert the integer argument to a type the same size as sizetype
3702 so the multiply won't overflow spuriously. */
3703 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
3704 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
3705 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
3706 TYPE_UNSIGNED (sizetype
)), intop
);
3708 /* Replace the integer argument with a suitable product by the object size.
3709 Do this multiplication as signed, then convert to the appropriate
3710 type for the pointer operation. */
3711 intop
= convert (sizetype
,
3712 build_binary_op (EXPR_LOCATION (intop
),
3714 convert (TREE_TYPE (intop
), size_exp
), 1));
3716 /* Create the sum or difference. */
3717 if (resultcode
== MINUS_EXPR
)
3718 intop
= fold_build1 (NEGATE_EXPR
, sizetype
, intop
);
3720 if (TREE_CODE (intop
) == INTEGER_CST
)
3723 tree string_cst
= string_constant (ptrop
, &offset_node
);
3726 && !(offset_node
&& TREE_CODE (offset_node
) != INTEGER_CST
))
3728 HOST_WIDE_INT max
= TREE_STRING_LENGTH (string_cst
);
3729 HOST_WIDE_INT offset
;
3730 if (offset_node
== 0)
3732 else if (! host_integerp (offset_node
, 0))
3735 offset
= tree_low_cst (offset_node
, 0);
3737 offset
= offset
+ tree_low_cst (intop
, 0);
3738 if (offset
< 0 || offset
> max
)
3739 warning_at (location
, 0,
3740 "offset %<%wd%> outside bounds of constant string",
3741 tree_low_cst (intop
, 0));
3745 ret
= fold_build2 (POINTER_PLUS_EXPR
, result_type
, ptrop
, intop
);
3747 fold_undefer_and_ignore_overflow_warnings ();
3752 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3753 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3754 around the SAVE_EXPR if needed so that c_fully_fold does not need
3755 to look inside SAVE_EXPRs. */
3758 c_save_expr (tree expr
)
3760 bool maybe_const
= true;
3761 if (c_dialect_cxx ())
3762 return save_expr (expr
);
3763 expr
= c_fully_fold (expr
, false, &maybe_const
);
3764 expr
= save_expr (expr
);
3767 expr
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL
, expr
);
3768 C_MAYBE_CONST_EXPR_NON_CONST (expr
) = 1;
3773 /* Return whether EXPR is a declaration whose address can never be
3777 decl_with_nonnull_addr_p (const_tree expr
)
3779 return (DECL_P (expr
)
3780 && (TREE_CODE (expr
) == PARM_DECL
3781 || TREE_CODE (expr
) == LABEL_DECL
3782 || !DECL_WEAK (expr
)));
3785 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3786 or for an `if' or `while' statement or ?..: exp. It should already
3787 have been validated to be of suitable type; otherwise, a bad
3788 diagnostic may result.
3790 The EXPR is located at LOCATION.
3792 This preparation consists of taking the ordinary
3793 representation of an expression expr and producing a valid tree
3794 boolean expression describing whether expr is nonzero. We could
3795 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3796 but we optimize comparisons, &&, ||, and !.
3798 The resulting type should always be `truthvalue_type_node'. */
3801 c_common_truthvalue_conversion (location_t location
, tree expr
)
3803 switch (TREE_CODE (expr
))
3805 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
3806 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3807 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
3808 case ORDERED_EXPR
: case UNORDERED_EXPR
:
3809 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3811 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
3812 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
3814 case TRUTH_ANDIF_EXPR
:
3815 case TRUTH_ORIF_EXPR
:
3816 case TRUTH_AND_EXPR
:
3818 case TRUTH_XOR_EXPR
:
3819 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3821 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
3822 c_common_truthvalue_conversion (location
,
3823 TREE_OPERAND (expr
, 0)),
3824 c_common_truthvalue_conversion (location
,
3825 TREE_OPERAND (expr
, 1)));
3827 case TRUTH_NOT_EXPR
:
3828 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3830 return build1 (TREE_CODE (expr
), truthvalue_type_node
,
3831 c_common_truthvalue_conversion (location
,
3832 TREE_OPERAND (expr
, 0)));
3838 return integer_zerop (expr
) ? truthvalue_false_node
3839 : truthvalue_true_node
;
3842 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3843 ? truthvalue_true_node
3844 : truthvalue_false_node
;
3847 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3848 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3849 ? truthvalue_true_node
3850 : truthvalue_false_node
;
3853 expr
= build_unary_op (location
, ADDR_EXPR
, expr
, 0);
3858 tree inner
= TREE_OPERAND (expr
, 0);
3859 if (decl_with_nonnull_addr_p (inner
))
3861 /* Common Ada/Pascal programmer's mistake. */
3862 warning_at (location
,
3864 "the address of %qD will always evaluate as %<true%>",
3866 return truthvalue_true_node
;
3869 /* If we still have a decl, it is possible for its address to
3870 be NULL, so we cannot optimize. */
3873 gcc_assert (DECL_WEAK (inner
));
3877 if (TREE_SIDE_EFFECTS (inner
))
3878 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3879 inner
, truthvalue_true_node
);
3881 return truthvalue_true_node
;
3885 return build_binary_op (EXPR_LOCATION (expr
),
3886 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3887 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3888 c_common_truthvalue_conversion (location
,
3889 TREE_OPERAND (expr
, 0)),
3890 c_common_truthvalue_conversion (location
,
3891 TREE_OPERAND (expr
, 1)),
3897 case EXCESS_PRECISION_EXPR
:
3898 /* These don't change whether an object is nonzero or zero. */
3899 return c_common_truthvalue_conversion (location
, TREE_OPERAND (expr
, 0));
3903 /* These don't change whether an object is zero or nonzero, but
3904 we can't ignore them if their second arg has side-effects. */
3905 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3906 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3907 TREE_OPERAND (expr
, 1),
3908 c_common_truthvalue_conversion
3909 (location
, TREE_OPERAND (expr
, 0)));
3911 return c_common_truthvalue_conversion (location
,
3912 TREE_OPERAND (expr
, 0));
3915 /* Distribute the conversion into the arms of a COND_EXPR. */
3916 if (c_dialect_cxx ())
3917 return fold_build3 (COND_EXPR
, truthvalue_type_node
,
3918 TREE_OPERAND (expr
, 0),
3919 c_common_truthvalue_conversion (location
,
3922 c_common_truthvalue_conversion (location
,
3926 /* Folding will happen later for C. */
3927 return build3 (COND_EXPR
, truthvalue_type_node
,
3928 TREE_OPERAND (expr
, 0),
3929 c_common_truthvalue_conversion (location
,
3930 TREE_OPERAND (expr
, 1)),
3931 c_common_truthvalue_conversion (location
,
3932 TREE_OPERAND (expr
, 2)));
3935 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3936 since that affects how `default_conversion' will behave. */
3937 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
3938 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
3940 /* If this is widening the argument, we can ignore it. */
3941 if (TYPE_PRECISION (TREE_TYPE (expr
))
3942 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
3943 return c_common_truthvalue_conversion (location
,
3944 TREE_OPERAND (expr
, 0));
3948 if (!TREE_NO_WARNING (expr
)
3949 && warn_parentheses
)
3951 warning (OPT_Wparentheses
,
3952 "suggest parentheses around assignment used as truth value");
3953 TREE_NO_WARNING (expr
) = 1;
3961 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
3963 tree t
= c_save_expr (expr
);
3964 return (build_binary_op
3965 (EXPR_LOCATION (expr
),
3966 (TREE_SIDE_EFFECTS (expr
)
3967 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3968 c_common_truthvalue_conversion
3970 build_unary_op (location
, REALPART_EXPR
, t
, 0)),
3971 c_common_truthvalue_conversion
3973 build_unary_op (location
, IMAGPART_EXPR
, t
, 0)),
3977 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
3979 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
3981 (TREE_TYPE (expr
))));
3982 return build_binary_op (EXPR_LOCATION (expr
),
3983 NE_EXPR
, expr
, fixed_zero_node
, 1);
3986 return build_binary_op (EXPR_LOCATION (expr
),
3987 NE_EXPR
, expr
, integer_zero_node
, 1);
3990 static void def_builtin_1 (enum built_in_function fncode
,
3992 enum built_in_class fnclass
,
3993 tree fntype
, tree libtype
,
3994 bool both_p
, bool fallback_p
, bool nonansi_p
,
3995 tree fnattrs
, bool implicit_p
);
3998 /* Apply the TYPE_QUALS to the new DECL. */
4001 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
4003 tree type
= TREE_TYPE (decl
);
4005 if (type
== error_mark_node
)
4008 if (((type_quals
& TYPE_QUAL_CONST
)
4009 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
4010 /* An object declared 'const' is only readonly after it is
4011 initialized. We don't have any way of expressing this currently,
4012 so we need to be conservative and unset TREE_READONLY for types
4013 with constructors. Otherwise aliasing code will ignore stores in
4014 an inline constructor. */
4015 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
4016 TREE_READONLY (decl
) = 1;
4017 if (type_quals
& TYPE_QUAL_VOLATILE
)
4019 TREE_SIDE_EFFECTS (decl
) = 1;
4020 TREE_THIS_VOLATILE (decl
) = 1;
4022 if (type_quals
& TYPE_QUAL_RESTRICT
)
4024 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
4025 /* Allow 'restrict' on arrays of pointers.
4026 FIXME currently we just ignore it. */
4027 type
= TREE_TYPE (type
);
4029 || !POINTER_TYPE_P (type
)
4030 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
4031 error ("invalid use of %<restrict%>");
4032 else if (flag_strict_aliasing
&& type
== TREE_TYPE (decl
))
4033 /* Indicate we need to make a unique alias set for this pointer.
4034 We can't do it here because it might be pointing to an
4036 DECL_POINTER_ALIAS_SET (decl
) = -2;
4040 /* Hash function for the problem of multiple type definitions in
4041 different files. This must hash all types that will compare
4042 equal via comptypes to the same value. In practice it hashes
4043 on some of the simple stuff and leaves the details to comptypes. */
4046 c_type_hash (const void *p
)
4050 const_tree
const t
= (const_tree
) p
;
4052 switch (TREE_CODE (t
))
4054 /* For pointers, hash on pointee type plus some swizzling. */
4056 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
4057 /* Hash on number of elements and total size. */
4060 t2
= TYPE_VALUES (t
);
4064 t2
= TYPE_FIELDS (t
);
4066 case QUAL_UNION_TYPE
:
4068 t2
= TYPE_FIELDS (t
);
4072 t2
= TYPE_FIELDS (t
);
4077 for (; t2
; t2
= TREE_CHAIN (t2
))
4079 /* We might have a VLA here. */
4080 if (TREE_CODE (TYPE_SIZE (t
)) != INTEGER_CST
)
4083 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
4084 return ((size
<< 24) | (i
<< shift
));
4087 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
4089 /* Return the typed-based alias set for T, which may be an expression
4090 or a type. Return -1 if we don't do anything special. */
4093 c_common_get_alias_set (tree t
)
4098 /* Permit type-punning when accessing a union, provided the access
4099 is directly through the union. For example, this code does not
4100 permit taking the address of a union member and then storing
4101 through it. Even the type-punning allowed here is a GCC
4102 extension, albeit a common and useful one; the C standard says
4103 that such accesses have implementation-defined behavior. */
4105 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
4106 u
= TREE_OPERAND (u
, 0))
4107 if (TREE_CODE (u
) == COMPONENT_REF
4108 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
4111 /* That's all the expressions we handle specially. */
4115 /* The C standard guarantees that any object may be accessed via an
4116 lvalue that has character type. */
4117 if (t
== char_type_node
4118 || t
== signed_char_type_node
4119 || t
== unsigned_char_type_node
)
4122 /* The C standard specifically allows aliasing between signed and
4123 unsigned variants of the same type. We treat the signed
4124 variant as canonical. */
4125 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
4127 tree t1
= c_common_signed_type (t
);
4129 /* t1 == t can happen for boolean nodes which are always unsigned. */
4131 return get_alias_set (t1
);
4133 else if (POINTER_TYPE_P (t
))
4137 /* Unfortunately, there is no canonical form of a pointer type.
4138 In particular, if we have `typedef int I', then `int *', and
4139 `I *' are different types. So, we have to pick a canonical
4140 representative. We do this below.
4142 Technically, this approach is actually more conservative that
4143 it needs to be. In particular, `const int *' and `int *'
4144 should be in different alias sets, according to the C and C++
4145 standard, since their types are not the same, and so,
4146 technically, an `int **' and `const int **' cannot point at
4149 But, the standard is wrong. In particular, this code is
4154 const int* const* cipp = ipp;
4156 And, it doesn't make sense for that to be legal unless you
4157 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4158 the pointed-to types. This issue has been reported to the
4160 t1
= build_type_no_quals (t
);
4162 return get_alias_set (t1
);
4165 /* Handle the case of multiple type nodes referring to "the same" type,
4166 which occurs with IMA. These share an alias set. FIXME: Currently only
4167 C90 is handled. (In C99 type compatibility is not transitive, which
4168 complicates things mightily. The alias set splay trees can theoretically
4169 represent this, but insertion is tricky when you consider all the
4170 different orders things might arrive in.) */
4172 if (c_language
!= clk_c
|| flag_isoc99
)
4175 /* Save time if there's only one input file. */
4176 if (num_in_fnames
== 1)
4179 /* Pointers need special handling if they point to any type that
4180 needs special handling (below). */
4181 if (TREE_CODE (t
) == POINTER_TYPE
)
4184 /* Find bottom type under any nested POINTERs. */
4185 for (t2
= TREE_TYPE (t
);
4186 TREE_CODE (t2
) == POINTER_TYPE
;
4187 t2
= TREE_TYPE (t2
))
4189 if (TREE_CODE (t2
) != RECORD_TYPE
4190 && TREE_CODE (t2
) != ENUMERAL_TYPE
4191 && TREE_CODE (t2
) != QUAL_UNION_TYPE
4192 && TREE_CODE (t2
) != UNION_TYPE
)
4194 if (TYPE_SIZE (t2
) == 0)
4197 /* These are the only cases that need special handling. */
4198 if (TREE_CODE (t
) != RECORD_TYPE
4199 && TREE_CODE (t
) != ENUMERAL_TYPE
4200 && TREE_CODE (t
) != QUAL_UNION_TYPE
4201 && TREE_CODE (t
) != UNION_TYPE
4202 && TREE_CODE (t
) != POINTER_TYPE
)
4205 if (TYPE_SIZE (t
) == 0)
4208 /* Look up t in hash table. Only one of the compatible types within each
4209 alias set is recorded in the table. */
4210 if (!type_hash_table
)
4211 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
4212 (htab_eq
) lang_hooks
.types_compatible_p
,
4214 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
4217 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
4218 return TYPE_ALIAS_SET ((tree
)*slot
);
4221 /* Our caller will assign and record (in t) a new alias set; all we need
4222 to do is remember t in the hash table. */
4228 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
4229 second parameter indicates which OPERATOR is being applied. The COMPLAIN
4230 flag controls whether we should diagnose possibly ill-formed
4231 constructs or not. */
4234 c_sizeof_or_alignof_type (tree type
, bool is_sizeof
, int complain
)
4236 const char *op_name
;
4238 enum tree_code type_code
= TREE_CODE (type
);
4240 op_name
= is_sizeof
? "sizeof" : "__alignof__";
4242 if (type_code
== FUNCTION_TYPE
)
4246 if (complain
&& (pedantic
|| warn_pointer_arith
))
4247 pedwarn (input_location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4248 "invalid application of %<sizeof%> to a function type");
4250 return error_mark_node
;
4251 value
= size_one_node
;
4254 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
4256 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
4258 if (type_code
== VOID_TYPE
4259 && complain
&& (pedantic
|| warn_pointer_arith
))
4260 pedwarn (input_location
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4261 "invalid application of %qs to a void type", op_name
);
4263 return error_mark_node
;
4264 value
= size_one_node
;
4266 else if (!COMPLETE_TYPE_P (type
))
4269 error ("invalid application of %qs to incomplete type %qT ",
4271 value
= size_zero_node
;
4276 /* Convert in case a char is more than one unit. */
4277 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
4278 size_int (TYPE_PRECISION (char_type_node
)
4281 value
= size_int (TYPE_ALIGN_UNIT (type
));
4284 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4285 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4286 never happen. However, this node should really have type
4287 `size_t', which is just a typedef for an ordinary integer type. */
4288 value
= fold_convert (size_type_node
, value
);
4289 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)));
4294 /* Implement the __alignof keyword: Return the minimum required
4295 alignment of EXPR, measured in bytes. For VAR_DECLs,
4296 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4297 from an "aligned" __attribute__ specification). */
4300 c_alignof_expr (tree expr
)
4304 if (VAR_OR_FUNCTION_DECL_P (expr
))
4305 t
= size_int (DECL_ALIGN_UNIT (expr
));
4307 else if (TREE_CODE (expr
) == COMPONENT_REF
4308 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
4310 error ("%<__alignof%> applied to a bit-field");
4313 else if (TREE_CODE (expr
) == COMPONENT_REF
4314 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
4315 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
4317 else if (TREE_CODE (expr
) == INDIRECT_REF
)
4319 tree t
= TREE_OPERAND (expr
, 0);
4321 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4323 while (CONVERT_EXPR_P (t
)
4324 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
4328 t
= TREE_OPERAND (t
, 0);
4329 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4330 if (thisalign
> bestalign
)
4331 best
= t
, bestalign
= thisalign
;
4333 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
4336 return c_alignof (TREE_TYPE (expr
));
4338 return fold_convert (size_type_node
, t
);
4341 /* Handle C and C++ default attributes. */
4343 enum built_in_attribute
4345 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4346 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4347 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4348 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4349 #include "builtin-attrs.def"
4350 #undef DEF_ATTR_NULL_TREE
4352 #undef DEF_ATTR_IDENT
4353 #undef DEF_ATTR_TREE_LIST
4357 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
4359 static void c_init_attributes (void);
4363 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4364 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4365 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4366 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4367 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4368 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4369 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4370 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4371 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4372 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4373 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4374 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4375 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4376 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4377 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4379 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4380 #include "builtin-types.def"
4381 #undef DEF_PRIMITIVE_TYPE
4382 #undef DEF_FUNCTION_TYPE_0
4383 #undef DEF_FUNCTION_TYPE_1
4384 #undef DEF_FUNCTION_TYPE_2
4385 #undef DEF_FUNCTION_TYPE_3
4386 #undef DEF_FUNCTION_TYPE_4
4387 #undef DEF_FUNCTION_TYPE_5
4388 #undef DEF_FUNCTION_TYPE_6
4389 #undef DEF_FUNCTION_TYPE_7
4390 #undef DEF_FUNCTION_TYPE_VAR_0
4391 #undef DEF_FUNCTION_TYPE_VAR_1
4392 #undef DEF_FUNCTION_TYPE_VAR_2
4393 #undef DEF_FUNCTION_TYPE_VAR_3
4394 #undef DEF_FUNCTION_TYPE_VAR_4
4395 #undef DEF_FUNCTION_TYPE_VAR_5
4396 #undef DEF_POINTER_TYPE
4400 typedef enum c_builtin_type builtin_type
;
4402 /* A temporary array for c_common_nodes_and_builtins. Used in
4403 communication with def_fn_type. */
4404 static tree builtin_types
[(int) BT_LAST
+ 1];
4406 /* A helper function for c_common_nodes_and_builtins. Build function type
4407 for DEF with return type RET and N arguments. If VAR is true, then the
4408 function should be variadic after those N arguments.
4410 Takes special care not to ICE if any of the types involved are
4411 error_mark_node, which indicates that said type is not in fact available
4412 (see builtin_type_for_size). In which case the function type as a whole
4413 should be error_mark_node. */
4416 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
4418 tree args
= NULL
, t
;
4423 for (i
= 0; i
< n
; ++i
)
4425 builtin_type a
= (builtin_type
) va_arg (list
, int);
4426 t
= builtin_types
[a
];
4427 if (t
== error_mark_node
)
4429 args
= tree_cons (NULL_TREE
, t
, args
);
4433 args
= nreverse (args
);
4435 args
= chainon (args
, void_list_node
);
4437 t
= builtin_types
[ret
];
4438 if (t
== error_mark_node
)
4440 t
= build_function_type (t
, args
);
4443 builtin_types
[def
] = t
;
4446 /* Build builtin functions common to both C and C++ language
4450 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
4452 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4453 builtin_types[ENUM] = VALUE;
4454 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4455 def_fn_type (ENUM, RETURN, 0, 0);
4456 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4457 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4458 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4459 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4460 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4461 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4462 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4463 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4464 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4465 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4466 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4468 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4469 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4471 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4472 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4473 def_fn_type (ENUM, RETURN, 1, 0);
4474 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4475 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4476 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4477 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4478 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4479 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4480 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4481 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4482 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4483 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4484 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4485 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4487 #include "builtin-types.def"
4489 #undef DEF_PRIMITIVE_TYPE
4490 #undef DEF_FUNCTION_TYPE_1
4491 #undef DEF_FUNCTION_TYPE_2
4492 #undef DEF_FUNCTION_TYPE_3
4493 #undef DEF_FUNCTION_TYPE_4
4494 #undef DEF_FUNCTION_TYPE_5
4495 #undef DEF_FUNCTION_TYPE_6
4496 #undef DEF_FUNCTION_TYPE_VAR_0
4497 #undef DEF_FUNCTION_TYPE_VAR_1
4498 #undef DEF_FUNCTION_TYPE_VAR_2
4499 #undef DEF_FUNCTION_TYPE_VAR_3
4500 #undef DEF_FUNCTION_TYPE_VAR_4
4501 #undef DEF_FUNCTION_TYPE_VAR_5
4502 #undef DEF_POINTER_TYPE
4503 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
4505 c_init_attributes ();
4507 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4508 NONANSI_P, ATTRS, IMPLICIT, COND) \
4510 def_builtin_1 (ENUM, NAME, CLASS, \
4511 builtin_types[(int) TYPE], \
4512 builtin_types[(int) LIBTYPE], \
4513 BOTH_P, FALLBACK_P, NONANSI_P, \
4514 built_in_attributes[(int) ATTRS], IMPLICIT);
4515 #include "builtins.def"
4518 targetm
.init_builtins ();
4520 build_common_builtin_nodes ();
4526 /* Build tree nodes and builtin functions common to both C and C++ language
4530 c_common_nodes_and_builtins (void)
4532 int char16_type_size
;
4533 int char32_type_size
;
4534 int wchar_type_size
;
4535 tree array_domain_type
;
4536 tree va_list_ref_type_node
;
4537 tree va_list_arg_type_node
;
4539 /* Define `int' and `char' first so that dbx will output them first. */
4540 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
4541 record_builtin_type (RID_CHAR
, "char", char_type_node
);
4543 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4544 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4545 but not C. Are the conditionals here needed? */
4546 if (c_dialect_cxx ())
4547 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
4548 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
4549 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
4550 record_builtin_type (RID_MAX
, "long unsigned int",
4551 long_unsigned_type_node
);
4552 if (c_dialect_cxx ())
4553 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
4554 record_builtin_type (RID_MAX
, "long long int",
4555 long_long_integer_type_node
);
4556 record_builtin_type (RID_MAX
, "long long unsigned int",
4557 long_long_unsigned_type_node
);
4558 if (c_dialect_cxx ())
4559 record_builtin_type (RID_MAX
, "long long unsigned",
4560 long_long_unsigned_type_node
);
4561 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
4562 record_builtin_type (RID_MAX
, "short unsigned int",
4563 short_unsigned_type_node
);
4564 if (c_dialect_cxx ())
4565 record_builtin_type (RID_MAX
, "unsigned short",
4566 short_unsigned_type_node
);
4568 /* Define both `signed char' and `unsigned char'. */
4569 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
4570 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
4572 /* These are types that c_common_type_for_size and
4573 c_common_type_for_mode use. */
4574 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4576 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4578 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4580 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4582 #if HOST_BITS_PER_WIDE_INT >= 64
4583 if (targetm
.scalar_mode_supported_p (TImode
))
4584 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4585 get_identifier ("__int128_t"),
4588 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4589 unsigned_intQI_type_node
));
4590 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4591 unsigned_intHI_type_node
));
4592 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4593 unsigned_intSI_type_node
));
4594 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4595 unsigned_intDI_type_node
));
4596 #if HOST_BITS_PER_WIDE_INT >= 64
4597 if (targetm
.scalar_mode_supported_p (TImode
))
4598 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4599 get_identifier ("__uint128_t"),
4600 unsigned_intTI_type_node
));
4603 /* Create the widest literal types. */
4604 widest_integer_literal_type_node
4605 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
4606 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4607 widest_integer_literal_type_node
));
4609 widest_unsigned_literal_type_node
4610 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
4611 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4612 widest_unsigned_literal_type_node
));
4614 /* `unsigned long' is the standard type for sizeof.
4615 Note that stddef.h uses `unsigned long',
4616 and this must agree, even if long and int are the same size. */
4618 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
4619 signed_size_type_node
= c_common_signed_type (size_type_node
);
4620 set_sizetype (size_type_node
);
4623 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
4625 build_common_tree_nodes_2 (flag_short_double
);
4627 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
4628 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
4629 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
4631 /* Only supported decimal floating point extension if the target
4632 actually supports underlying modes. */
4633 if (targetm
.scalar_mode_supported_p (SDmode
)
4634 && targetm
.scalar_mode_supported_p (DDmode
)
4635 && targetm
.scalar_mode_supported_p (TDmode
))
4637 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
4638 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
4639 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
4642 if (targetm
.fixed_point_supported_p ())
4644 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
4645 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
4646 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
4647 record_builtin_type (RID_MAX
, "long long _Fract",
4648 long_long_fract_type_node
);
4649 record_builtin_type (RID_MAX
, "unsigned short _Fract",
4650 unsigned_short_fract_type_node
);
4651 record_builtin_type (RID_MAX
, "unsigned _Fract",
4652 unsigned_fract_type_node
);
4653 record_builtin_type (RID_MAX
, "unsigned long _Fract",
4654 unsigned_long_fract_type_node
);
4655 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
4656 unsigned_long_long_fract_type_node
);
4657 record_builtin_type (RID_MAX
, "_Sat short _Fract",
4658 sat_short_fract_type_node
);
4659 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
4660 record_builtin_type (RID_MAX
, "_Sat long _Fract",
4661 sat_long_fract_type_node
);
4662 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
4663 sat_long_long_fract_type_node
);
4664 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
4665 sat_unsigned_short_fract_type_node
);
4666 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
4667 sat_unsigned_fract_type_node
);
4668 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
4669 sat_unsigned_long_fract_type_node
);
4670 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
4671 sat_unsigned_long_long_fract_type_node
);
4672 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
4673 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
4674 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
4675 record_builtin_type (RID_MAX
, "long long _Accum",
4676 long_long_accum_type_node
);
4677 record_builtin_type (RID_MAX
, "unsigned short _Accum",
4678 unsigned_short_accum_type_node
);
4679 record_builtin_type (RID_MAX
, "unsigned _Accum",
4680 unsigned_accum_type_node
);
4681 record_builtin_type (RID_MAX
, "unsigned long _Accum",
4682 unsigned_long_accum_type_node
);
4683 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
4684 unsigned_long_long_accum_type_node
);
4685 record_builtin_type (RID_MAX
, "_Sat short _Accum",
4686 sat_short_accum_type_node
);
4687 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
4688 record_builtin_type (RID_MAX
, "_Sat long _Accum",
4689 sat_long_accum_type_node
);
4690 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
4691 sat_long_long_accum_type_node
);
4692 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
4693 sat_unsigned_short_accum_type_node
);
4694 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
4695 sat_unsigned_accum_type_node
);
4696 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
4697 sat_unsigned_long_accum_type_node
);
4698 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
4699 sat_unsigned_long_long_accum_type_node
);
4703 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4704 get_identifier ("complex int"),
4705 complex_integer_type_node
));
4706 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4707 get_identifier ("complex float"),
4708 complex_float_type_node
));
4709 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4710 get_identifier ("complex double"),
4711 complex_double_type_node
));
4712 lang_hooks
.decls
.pushdecl
4713 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
4714 complex_long_double_type_node
));
4716 if (c_dialect_cxx ())
4717 /* For C++, make fileptr_type_node a distinct void * type until
4718 FILE type is defined. */
4719 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
4721 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
4723 /* Set the TYPE_NAME for any variants that were built before
4724 record_builtin_type gave names to the built-in types. */
4726 tree void_name
= TYPE_NAME (void_type_node
);
4727 TYPE_NAME (void_type_node
) = NULL_TREE
;
4728 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
4730 TYPE_NAME (void_type_node
) = void_name
;
4733 /* This node must not be shared. */
4734 void_zero_node
= make_node (INTEGER_CST
);
4735 TREE_TYPE (void_zero_node
) = void_type_node
;
4737 void_list_node
= build_void_list_node ();
4739 /* Make a type to be the domain of a few array types
4740 whose domains don't really matter.
4741 200 is small enough that it always fits in size_t
4742 and large enough that it can hold most function names for the
4743 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4744 array_domain_type
= build_index_type (size_int (200));
4746 /* Make a type for arrays of characters.
4747 With luck nothing will ever really depend on the length of this
4749 char_array_type_node
4750 = build_array_type (char_type_node
, array_domain_type
);
4752 /* Likewise for arrays of ints. */
4754 = build_array_type (integer_type_node
, array_domain_type
);
4756 string_type_node
= build_pointer_type (char_type_node
);
4757 const_string_type_node
4758 = build_pointer_type (build_qualified_type
4759 (char_type_node
, TYPE_QUAL_CONST
));
4761 /* This is special for C++ so functions can be overloaded. */
4762 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
4763 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
4764 wchar_type_size
= TYPE_PRECISION (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
);
4775 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
4776 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
4779 /* This is for wide string constants. */
4780 wchar_array_type_node
4781 = build_array_type (wchar_type_node
, array_domain_type
);
4783 /* Define 'char16_t'. */
4784 char16_type_node
= get_identifier (CHAR16_TYPE
);
4785 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
4786 char16_type_size
= TYPE_PRECISION (char16_type_node
);
4787 if (c_dialect_cxx ())
4789 char16_type_node
= make_unsigned_type (char16_type_size
);
4791 if (cxx_dialect
== cxx0x
)
4792 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
4795 /* This is for UTF-16 string constants. */
4796 char16_array_type_node
4797 = build_array_type (char16_type_node
, array_domain_type
);
4799 /* Define 'char32_t'. */
4800 char32_type_node
= get_identifier (CHAR32_TYPE
);
4801 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
4802 char32_type_size
= TYPE_PRECISION (char32_type_node
);
4803 if (c_dialect_cxx ())
4805 char32_type_node
= make_unsigned_type (char32_type_size
);
4807 if (cxx_dialect
== cxx0x
)
4808 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
4811 /* This is for UTF-32 string constants. */
4812 char32_array_type_node
4813 = build_array_type (char32_type_node
, array_domain_type
);
4816 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
4819 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
4821 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
4823 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
4825 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
4826 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
4828 lang_hooks
.decls
.pushdecl
4829 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
4830 va_list_type_node
));
4831 #ifdef TARGET_ENUM_VA_LIST
4836 for (l
= 0; TARGET_ENUM_VA_LIST (l
, &pname
, &ptype
); ++l
)
4838 lang_hooks
.decls
.pushdecl
4839 (build_decl (TYPE_DECL
, get_identifier (pname
),
4846 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4848 va_list_arg_type_node
= va_list_ref_type_node
=
4849 build_pointer_type (TREE_TYPE (va_list_type_node
));
4853 va_list_arg_type_node
= va_list_type_node
;
4854 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
4857 if (!flag_preprocess_only
)
4858 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
4860 main_identifier_node
= get_identifier ("main");
4862 /* Create the built-in __null node. It is important that this is
4864 null_node
= make_node (INTEGER_CST
);
4865 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
4867 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4868 memset (builtin_types
, 0, sizeof (builtin_types
));
4871 /* Look up the function in built_in_decls that corresponds to DECL
4872 and set ASMSPEC as its user assembler name. DECL must be a
4873 function decl that declares a builtin. */
4876 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
4879 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
4880 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
4883 builtin
= built_in_decls
[DECL_FUNCTION_CODE (decl
)];
4884 set_user_assembler_name (builtin
, asmspec
);
4885 switch (DECL_FUNCTION_CODE (decl
))
4887 case BUILT_IN_MEMCPY
:
4888 init_block_move_fn (asmspec
);
4889 memcpy_libfunc
= set_user_assembler_libfunc ("memcpy", asmspec
);
4891 case BUILT_IN_MEMSET
:
4892 init_block_clear_fn (asmspec
);
4893 memset_libfunc
= set_user_assembler_libfunc ("memset", asmspec
);
4895 case BUILT_IN_MEMMOVE
:
4896 memmove_libfunc
= set_user_assembler_libfunc ("memmove", asmspec
);
4898 case BUILT_IN_MEMCMP
:
4899 memcmp_libfunc
= set_user_assembler_libfunc ("memcmp", asmspec
);
4901 case BUILT_IN_ABORT
:
4902 abort_libfunc
= set_user_assembler_libfunc ("abort", asmspec
);
4909 /* The number of named compound-literals generated thus far. */
4910 static GTY(()) int compound_literal_number
;
4912 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4915 set_compound_literal_name (tree decl
)
4918 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
4919 compound_literal_number
);
4920 compound_literal_number
++;
4921 DECL_NAME (decl
) = get_identifier (name
);
4925 build_va_arg (tree expr
, tree type
)
4927 return build1 (VA_ARG_EXPR
, type
, expr
);
4931 /* Linked list of disabled built-in functions. */
4933 typedef struct disabled_builtin
4936 struct disabled_builtin
*next
;
4938 static disabled_builtin
*disabled_builtins
= NULL
;
4940 static bool builtin_function_disabled_p (const char *);
4942 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4943 begins with "__builtin_", give an error. */
4946 disable_builtin_function (const char *name
)
4948 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
4949 error ("cannot disable built-in function %qs", name
);
4952 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
4953 new_disabled_builtin
->name
= name
;
4954 new_disabled_builtin
->next
= disabled_builtins
;
4955 disabled_builtins
= new_disabled_builtin
;
4960 /* Return true if the built-in function NAME has been disabled, false
4964 builtin_function_disabled_p (const char *name
)
4966 disabled_builtin
*p
;
4967 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
4969 if (strcmp (name
, p
->name
) == 0)
4976 /* Worker for DEF_BUILTIN.
4977 Possibly define a builtin function with one or two names.
4978 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4979 nonansi_p and flag_no_nonansi_builtin. */
4982 def_builtin_1 (enum built_in_function fncode
,
4984 enum built_in_class fnclass
,
4985 tree fntype
, tree libtype
,
4986 bool both_p
, bool fallback_p
, bool nonansi_p
,
4987 tree fnattrs
, bool implicit_p
)
4990 const char *libname
;
4992 if (fntype
== error_mark_node
)
4995 gcc_assert ((!both_p
&& !fallback_p
)
4996 || !strncmp (name
, "__builtin_",
4997 strlen ("__builtin_")));
4999 libname
= name
+ strlen ("__builtin_");
5000 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
5001 (fallback_p
? libname
: NULL
),
5004 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
5005 && !(nonansi_p
&& flag_no_nonansi_builtin
))
5006 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
5009 built_in_decls
[(int) fncode
] = decl
;
5011 implicit_built_in_decls
[(int) fncode
] = decl
;
5014 /* Nonzero if the type T promotes to int. This is (nearly) the
5015 integral promotions defined in ISO C99 6.3.1.1/2. */
5018 c_promoting_integer_type_p (const_tree t
)
5020 switch (TREE_CODE (t
))
5023 return (TYPE_MAIN_VARIANT (t
) == char_type_node
5024 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
5025 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
5026 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
5027 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
5028 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
5031 /* ??? Technically all enumerations not larger than an int
5032 promote to an int. But this is used along code paths
5033 that only want to notice a size change. */
5034 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
5044 /* Return 1 if PARMS specifies a fixed number of parameters
5045 and none of their types is affected by default promotions. */
5048 self_promoting_args_p (const_tree parms
)
5051 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
5053 tree type
= TREE_VALUE (t
);
5055 if (type
== error_mark_node
)
5058 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
5064 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
5067 if (c_promoting_integer_type_p (type
))
5073 /* Recursively remove any '*' or '&' operator from TYPE. */
5075 strip_pointer_operator (tree t
)
5077 while (POINTER_TYPE_P (t
))
5082 /* Recursively remove pointer or array type from TYPE. */
5084 strip_pointer_or_array_types (tree t
)
5086 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
5091 /* Used to compare case labels. K1 and K2 are actually tree nodes
5092 representing case labels, or NULL_TREE for a `default' label.
5093 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5094 K2, and 0 if K1 and K2 are equal. */
5097 case_compare (splay_tree_key k1
, splay_tree_key k2
)
5099 /* Consider a NULL key (such as arises with a `default' label) to be
5100 smaller than anything else. */
5106 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5109 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
5110 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
5111 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
5112 case label was declared using the usual C/C++ syntax, rather than
5113 the GNU case range extension. CASES is a tree containing all the
5114 case ranges processed so far; COND is the condition for the
5115 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
5116 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
5119 c_add_case_label (splay_tree cases
, tree cond
, tree orig_type
,
5120 tree low_value
, tree high_value
)
5125 splay_tree_node node
;
5127 /* Create the LABEL_DECL itself. */
5128 label
= create_artificial_label ();
5130 /* If there was an error processing the switch condition, bail now
5131 before we get more confused. */
5132 if (!cond
|| cond
== error_mark_node
)
5135 if ((low_value
&& TREE_TYPE (low_value
)
5136 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
5137 || (high_value
&& TREE_TYPE (high_value
)
5138 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
5140 error ("pointers are not permitted as case values");
5144 /* Case ranges are a GNU extension. */
5146 pedwarn (input_location
, OPT_pedantic
,
5147 "range expressions in switch statements are non-standard");
5149 type
= TREE_TYPE (cond
);
5152 low_value
= check_case_value (low_value
);
5153 low_value
= convert_and_check (type
, low_value
);
5154 if (low_value
== error_mark_node
)
5159 high_value
= check_case_value (high_value
);
5160 high_value
= convert_and_check (type
, high_value
);
5161 if (high_value
== error_mark_node
)
5165 if (low_value
&& high_value
)
5167 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5168 really a case range, even though it was written that way.
5169 Remove the HIGH_VALUE to simplify later processing. */
5170 if (tree_int_cst_equal (low_value
, high_value
))
5171 high_value
= NULL_TREE
;
5172 else if (!tree_int_cst_lt (low_value
, high_value
))
5173 warning (0, "empty range specified");
5176 /* See if the case is in range of the type of the original testing
5177 expression. If both low_value and high_value are out of range,
5178 don't insert the case label and return NULL_TREE. */
5180 && !check_case_bounds (type
, orig_type
,
5181 &low_value
, high_value
? &high_value
: NULL
))
5184 /* Look up the LOW_VALUE in the table of case labels we already
5186 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
5187 /* If there was not an exact match, check for overlapping ranges.
5188 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5189 that's a `default' label and the only overlap is an exact match. */
5190 if (!node
&& (low_value
|| high_value
))
5192 splay_tree_node low_bound
;
5193 splay_tree_node high_bound
;
5195 /* Even though there wasn't an exact match, there might be an
5196 overlap between this case range and another case range.
5197 Since we've (inductively) not allowed any overlapping case
5198 ranges, we simply need to find the greatest low case label
5199 that is smaller that LOW_VALUE, and the smallest low case
5200 label that is greater than LOW_VALUE. If there is an overlap
5201 it will occur in one of these two ranges. */
5202 low_bound
= splay_tree_predecessor (cases
,
5203 (splay_tree_key
) low_value
);
5204 high_bound
= splay_tree_successor (cases
,
5205 (splay_tree_key
) low_value
);
5207 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5208 the LOW_VALUE, so there is no need to check unless the
5209 LOW_BOUND is in fact itself a case range. */
5211 && CASE_HIGH ((tree
) low_bound
->value
)
5212 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
5215 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5216 range is bigger than the low end of the current range, so we
5217 are only interested if the current range is a real range, and
5218 not an ordinary case label. */
5221 && (tree_int_cst_compare ((tree
) high_bound
->key
,
5226 /* If there was an overlap, issue an error. */
5229 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
5233 error ("duplicate (or overlapping) case value");
5234 error ("%Jthis is the first entry overlapping that value", duplicate
);
5238 error ("duplicate case value") ;
5239 error ("%Jpreviously used here", duplicate
);
5243 error ("multiple default labels in one switch");
5244 error ("%Jthis is the first default label", duplicate
);
5249 /* Add a CASE_LABEL to the statement-tree. */
5250 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
5251 /* Register this case label in the splay tree. */
5252 splay_tree_insert (cases
,
5253 (splay_tree_key
) low_value
,
5254 (splay_tree_value
) case_label
);
5259 /* Add a label so that the back-end doesn't think that the beginning of
5260 the switch is unreachable. Note that we do not add a case label, as
5261 that just leads to duplicates and thence to failure later on. */
5264 tree t
= create_artificial_label ();
5265 add_stmt (build_stmt (LABEL_EXPR
, t
));
5267 return error_mark_node
;
5270 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5271 Used to verify that case values match up with enumerator values. */
5274 match_case_to_enum_1 (tree key
, tree type
, tree label
)
5276 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
5278 /* ??? Not working too hard to print the double-word value.
5279 Should perhaps be done with %lwd in the diagnostic routines? */
5280 if (TREE_INT_CST_HIGH (key
) == 0)
5281 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
5282 TREE_INT_CST_LOW (key
));
5283 else if (!TYPE_UNSIGNED (type
)
5284 && TREE_INT_CST_HIGH (key
) == -1
5285 && TREE_INT_CST_LOW (key
) != 0)
5286 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
5287 -TREE_INT_CST_LOW (key
));
5289 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
5290 (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (key
),
5291 (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (key
));
5293 if (TYPE_NAME (type
) == 0)
5294 warning (warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5295 "%Jcase value %qs not in enumerated type",
5296 CASE_LABEL (label
), buf
);
5298 warning (warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5299 "%Jcase value %qs not in enumerated type %qT",
5300 CASE_LABEL (label
), buf
, type
);
5303 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5304 Used to verify that case values match up with enumerator values. */
5307 match_case_to_enum (splay_tree_node node
, void *data
)
5309 tree label
= (tree
) node
->value
;
5310 tree type
= (tree
) data
;
5312 /* Skip default case. */
5313 if (!CASE_LOW (label
))
5316 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5317 when we did our enum->case scan. Reset our scratch bit after. */
5318 if (!CASE_LOW_SEEN (label
))
5319 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
5321 CASE_LOW_SEEN (label
) = 0;
5323 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5324 not set, that means that CASE_HIGH did not appear when we did our
5325 enum->case scan. Reset our scratch bit after. */
5326 if (CASE_HIGH (label
))
5328 if (!CASE_HIGH_SEEN (label
))
5329 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
5331 CASE_HIGH_SEEN (label
) = 0;
5337 /* Handle -Wswitch*. Called from the front end after parsing the
5338 switch construct. */
5339 /* ??? Should probably be somewhere generic, since other languages
5340 besides C and C++ would want this. At the moment, however, C/C++
5341 are the only tree-ssa languages that support enumerations at all,
5342 so the point is moot. */
5345 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
5346 tree type
, tree cond
)
5348 splay_tree_node default_node
;
5349 splay_tree_node node
;
5351 int saved_warn_switch
;
5353 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
5356 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
5358 warning (OPT_Wswitch_default
, "%Hswitch missing default case",
5361 /* From here on, we only care about about enumerated types. */
5362 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
5365 /* If the switch expression was an enumerated type, check that
5366 exactly all enumeration literals are covered by the cases.
5367 The check is made when -Wswitch was specified and there is no
5368 default case, or when -Wswitch-enum was specified. */
5370 if (!warn_switch_enum
5371 && !(warn_switch
&& !default_node
))
5374 /* Clearing COND if it is not an integer constant simplifies
5375 the tests inside the loop below. */
5376 if (TREE_CODE (cond
) != INTEGER_CST
)
5379 /* The time complexity here is O(N*lg(N)) worst case, but for the
5380 common case of monotonically increasing enumerators, it is
5381 O(N), since the nature of the splay tree will keep the next
5382 element adjacent to the root at all times. */
5384 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
5386 tree value
= TREE_VALUE (chain
);
5387 if (TREE_CODE (value
) == CONST_DECL
)
5388 value
= DECL_INITIAL (value
);
5389 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
5392 /* Mark the CASE_LOW part of the case entry as seen. */
5393 tree label
= (tree
) node
->value
;
5394 CASE_LOW_SEEN (label
) = 1;
5398 /* Even though there wasn't an exact match, there might be a
5399 case range which includes the enumerator's value. */
5400 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
5401 if (node
&& CASE_HIGH ((tree
) node
->value
))
5403 tree label
= (tree
) node
->value
;
5404 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
5407 /* If we match the upper bound exactly, mark the CASE_HIGH
5408 part of the case entry as seen. */
5410 CASE_HIGH_SEEN (label
) = 1;
5415 /* We've now determined that this enumerated literal isn't
5416 handled by the case labels of the switch statement. */
5418 /* If the switch expression is a constant, we only really care
5419 about whether that constant is handled by the switch. */
5420 if (cond
&& tree_int_cst_compare (cond
, value
))
5423 /* If there is a default_node, the only relevant option is
5424 Wswitch-enum. Otherwise, if both are enabled then we prefer
5425 to warn using -Wswitch because -Wswitch is enabled by -Wall
5426 while -Wswitch-enum is explicit. */
5427 warning ((default_node
|| !warn_switch
)
5428 ? OPT_Wswitch_enum
: OPT_Wswitch
,
5429 "%Henumeration value %qE not handled in switch",
5430 &switch_location
, TREE_PURPOSE (chain
));
5433 /* Warn if there are case expressions that don't correspond to
5434 enumerators. This can occur since C and C++ don't enforce
5435 type-checking of assignments to enumeration variables.
5437 The time complexity here is now always O(N) worst case, since
5438 we should have marked both the lower bound and upper bound of
5439 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5440 above. This scan also resets those fields. */
5442 /* If there is a default_node, the only relevant option is
5443 Wswitch-enum. Otherwise, if both are enabled then we prefer
5444 to warn using -Wswitch because -Wswitch is enabled by -Wall
5445 while -Wswitch-enum is explicit. */
5446 saved_warn_switch
= warn_switch
;
5449 splay_tree_foreach (cases
, match_case_to_enum
, type
);
5450 warn_switch
= saved_warn_switch
;
5454 /* Finish an expression taking the address of LABEL (an
5455 IDENTIFIER_NODE). Returns an expression for the address.
5457 LOC is the location for the expression returned. */
5460 finish_label_address_expr (tree label
, location_t loc
)
5464 pedwarn (input_location
, OPT_pedantic
, "taking the address of a label is non-standard");
5466 if (label
== error_mark_node
)
5467 return error_mark_node
;
5469 label
= lookup_label (label
);
5470 if (label
== NULL_TREE
)
5471 result
= null_pointer_node
;
5474 TREE_USED (label
) = 1;
5475 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
5476 /* The current function in not necessarily uninlinable.
5477 Computed gotos are incompatible with inlining, but the value
5478 here could be used only in a diagnostic, for example. */
5479 protected_set_expr_location (result
, loc
);
5486 /* Given a boolean expression ARG, return a tree representing an increment
5487 or decrement (as indicated by CODE) of ARG. The front end must check for
5488 invalid cases (e.g., decrement in C++). */
5490 boolean_increment (enum tree_code code
, tree arg
)
5493 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
5495 arg
= stabilize_reference (arg
);
5498 case PREINCREMENT_EXPR
:
5499 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5501 case POSTINCREMENT_EXPR
:
5502 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5503 arg
= save_expr (arg
);
5504 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5505 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5507 case PREDECREMENT_EXPR
:
5508 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5509 invert_truthvalue (arg
));
5511 case POSTDECREMENT_EXPR
:
5512 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5513 invert_truthvalue (arg
));
5514 arg
= save_expr (arg
);
5515 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5516 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5521 TREE_SIDE_EFFECTS (val
) = 1;
5525 /* Built-in macros for stddef.h, that require macros defined in this
5528 c_stddef_cpp_builtins(void)
5530 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
5531 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
5532 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
5533 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
5534 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
5535 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
5536 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
5537 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
5541 c_init_attributes (void)
5543 /* Fill in the built_in_attributes array. */
5544 #define DEF_ATTR_NULL_TREE(ENUM) \
5545 built_in_attributes[(int) ENUM] = NULL_TREE;
5546 #define DEF_ATTR_INT(ENUM, VALUE) \
5547 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5548 #define DEF_ATTR_IDENT(ENUM, STRING) \
5549 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5550 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5551 built_in_attributes[(int) ENUM] \
5552 = tree_cons (built_in_attributes[(int) PURPOSE], \
5553 built_in_attributes[(int) VALUE], \
5554 built_in_attributes[(int) CHAIN]);
5555 #include "builtin-attrs.def"
5556 #undef DEF_ATTR_NULL_TREE
5558 #undef DEF_ATTR_IDENT
5559 #undef DEF_ATTR_TREE_LIST
5562 /* Attribute handlers common to C front ends. */
5564 /* Handle a "packed" attribute; arguments as in
5565 struct attribute_spec.handler. */
5568 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5569 int flags
, bool *no_add_attrs
)
5573 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5574 *node
= build_variant_type_copy (*node
);
5575 TYPE_PACKED (*node
) = 1;
5577 else if (TREE_CODE (*node
) == FIELD_DECL
)
5579 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
5580 /* Still pack bitfields. */
5581 && ! DECL_INITIAL (*node
))
5582 warning (OPT_Wattributes
,
5583 "%qE attribute ignored for field of type %qT",
5584 name
, TREE_TYPE (*node
));
5586 DECL_PACKED (*node
) = 1;
5588 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5589 used for DECL_REGISTER. It wouldn't mean anything anyway.
5590 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5591 that changes what the typedef is typing. */
5594 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5595 *no_add_attrs
= true;
5601 /* Handle a "nocommon" attribute; arguments as in
5602 struct attribute_spec.handler. */
5605 handle_nocommon_attribute (tree
*node
, tree name
,
5606 tree
ARG_UNUSED (args
),
5607 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5609 if (TREE_CODE (*node
) == VAR_DECL
)
5610 DECL_COMMON (*node
) = 0;
5613 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5614 *no_add_attrs
= true;
5620 /* Handle a "common" attribute; arguments as in
5621 struct attribute_spec.handler. */
5624 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5625 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5627 if (TREE_CODE (*node
) == VAR_DECL
)
5628 DECL_COMMON (*node
) = 1;
5631 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5632 *no_add_attrs
= true;
5638 /* Handle a "noreturn" attribute; arguments as in
5639 struct attribute_spec.handler. */
5642 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5643 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5645 tree type
= TREE_TYPE (*node
);
5647 /* See FIXME comment in c_common_attribute_table. */
5648 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5649 TREE_THIS_VOLATILE (*node
) = 1;
5650 else if (TREE_CODE (type
) == POINTER_TYPE
5651 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5653 = build_pointer_type
5654 (build_type_variant (TREE_TYPE (type
),
5655 TYPE_READONLY (TREE_TYPE (type
)), 1));
5658 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5659 *no_add_attrs
= true;
5665 /* Handle a "hot" and attribute; arguments as in
5666 struct attribute_spec.handler. */
5669 handle_hot_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5670 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5672 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5674 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node
)) != NULL
)
5676 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5678 *no_add_attrs
= true;
5680 /* Most of the rest of the hot processing is done later with
5681 lookup_attribute. */
5685 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5686 *no_add_attrs
= true;
5691 /* Handle a "cold" and attribute; arguments as in
5692 struct attribute_spec.handler. */
5695 handle_cold_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5696 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5698 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5700 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node
)) != NULL
)
5702 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5704 *no_add_attrs
= true;
5706 /* Most of the rest of the cold processing is done later with
5707 lookup_attribute. */
5711 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5712 *no_add_attrs
= true;
5718 /* Handle a "noinline" attribute; arguments as in
5719 struct attribute_spec.handler. */
5722 handle_noinline_attribute (tree
*node
, tree name
,
5723 tree
ARG_UNUSED (args
),
5724 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5726 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5727 DECL_UNINLINABLE (*node
) = 1;
5730 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5731 *no_add_attrs
= true;
5737 /* Handle a "always_inline" attribute; arguments as in
5738 struct attribute_spec.handler. */
5741 handle_always_inline_attribute (tree
*node
, tree name
,
5742 tree
ARG_UNUSED (args
),
5743 int ARG_UNUSED (flags
),
5746 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5748 /* Set the attribute and mark it for disregarding inline
5750 DECL_DISREGARD_INLINE_LIMITS (*node
) = 1;
5754 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5755 *no_add_attrs
= true;
5761 /* Handle a "gnu_inline" attribute; arguments as in
5762 struct attribute_spec.handler. */
5765 handle_gnu_inline_attribute (tree
*node
, tree name
,
5766 tree
ARG_UNUSED (args
),
5767 int ARG_UNUSED (flags
),
5770 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
5772 /* Do nothing else, just set the attribute. We'll get at
5773 it later with lookup_attribute. */
5777 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5778 *no_add_attrs
= true;
5784 /* Handle an "artificial" attribute; arguments as in
5785 struct attribute_spec.handler. */
5788 handle_artificial_attribute (tree
*node
, tree name
,
5789 tree
ARG_UNUSED (args
),
5790 int ARG_UNUSED (flags
),
5793 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
5795 /* Do nothing else, just set the attribute. We'll get at
5796 it later with lookup_attribute. */
5800 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5801 *no_add_attrs
= true;
5807 /* Handle a "flatten" attribute; arguments as in
5808 struct attribute_spec.handler. */
5811 handle_flatten_attribute (tree
*node
, tree name
,
5812 tree args ATTRIBUTE_UNUSED
,
5813 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5815 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5816 /* Do nothing else, just set the attribute. We'll get at
5817 it later with lookup_attribute. */
5821 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5822 *no_add_attrs
= true;
5828 /* Handle a "warning" or "error" attribute; arguments as in
5829 struct attribute_spec.handler. */
5832 handle_error_attribute (tree
*node
, tree name
, tree args
,
5833 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5835 if (TREE_CODE (*node
) == FUNCTION_DECL
5836 || TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5837 /* Do nothing else, just set the attribute. We'll get at
5838 it later with lookup_attribute. */
5842 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5843 *no_add_attrs
= true;
5849 /* Handle a "used" attribute; arguments as in
5850 struct attribute_spec.handler. */
5853 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
5854 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5858 if (TREE_CODE (node
) == FUNCTION_DECL
5859 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
5861 TREE_USED (node
) = 1;
5862 DECL_PRESERVE_P (node
) = 1;
5866 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5867 *no_add_attrs
= true;
5873 /* Handle a "unused" attribute; arguments as in
5874 struct attribute_spec.handler. */
5877 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5878 int flags
, bool *no_add_attrs
)
5884 if (TREE_CODE (decl
) == PARM_DECL
5885 || TREE_CODE (decl
) == VAR_DECL
5886 || TREE_CODE (decl
) == FUNCTION_DECL
5887 || TREE_CODE (decl
) == LABEL_DECL
5888 || TREE_CODE (decl
) == TYPE_DECL
)
5889 TREE_USED (decl
) = 1;
5892 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5893 *no_add_attrs
= true;
5898 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5899 *node
= build_variant_type_copy (*node
);
5900 TREE_USED (*node
) = 1;
5906 /* Handle a "externally_visible" attribute; arguments as in
5907 struct attribute_spec.handler. */
5910 handle_externally_visible_attribute (tree
*pnode
, tree name
,
5911 tree
ARG_UNUSED (args
),
5912 int ARG_UNUSED (flags
),
5917 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
5919 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
5920 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
5922 warning (OPT_Wattributes
,
5923 "%qE attribute have effect only on public objects", name
);
5924 *no_add_attrs
= true;
5929 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5930 *no_add_attrs
= true;
5936 /* Handle a "const" attribute; arguments as in
5937 struct attribute_spec.handler. */
5940 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5941 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5943 tree type
= TREE_TYPE (*node
);
5945 /* See FIXME comment on noreturn in c_common_attribute_table. */
5946 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5947 TREE_READONLY (*node
) = 1;
5948 else if (TREE_CODE (type
) == POINTER_TYPE
5949 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5951 = build_pointer_type
5952 (build_type_variant (TREE_TYPE (type
), 1,
5953 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
5956 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5957 *no_add_attrs
= true;
5963 /* Handle a "transparent_union" attribute; arguments as in
5964 struct attribute_spec.handler. */
5967 handle_transparent_union_attribute (tree
*node
, tree name
,
5968 tree
ARG_UNUSED (args
), int flags
,
5973 *no_add_attrs
= true;
5975 if (TREE_CODE (*node
) == TYPE_DECL
)
5976 node
= &TREE_TYPE (*node
);
5979 if (TREE_CODE (type
) == UNION_TYPE
)
5981 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5982 the code in finish_struct. */
5983 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5985 if (TYPE_FIELDS (type
) == NULL_TREE
5986 || TYPE_MODE (type
) != DECL_MODE (TYPE_FIELDS (type
)))
5989 /* A type variant isn't good enough, since we don't a cast
5990 to such a type removed as a no-op. */
5991 *node
= type
= build_duplicate_type (type
);
5994 TYPE_TRANSPARENT_UNION (type
) = 1;
5999 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6003 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6004 get the requested priority for a constructor or destructor,
6005 possibly issuing diagnostics for invalid or reserved
6008 static priority_type
6009 get_priority (tree args
, bool is_destructor
)
6015 return DEFAULT_INIT_PRIORITY
;
6017 if (!SUPPORTS_INIT_PRIORITY
)
6020 error ("destructor priorities are not supported");
6022 error ("constructor priorities are not supported");
6023 return DEFAULT_INIT_PRIORITY
;
6026 arg
= TREE_VALUE (args
);
6027 if (!host_integerp (arg
, /*pos=*/0)
6028 || !INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
6031 pri
= tree_low_cst (TREE_VALUE (args
), /*pos=*/0);
6032 if (pri
< 0 || pri
> MAX_INIT_PRIORITY
)
6035 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
6039 "destructor priorities from 0 to %d are reserved "
6040 "for the implementation",
6041 MAX_RESERVED_INIT_PRIORITY
);
6044 "constructor priorities from 0 to %d are reserved "
6045 "for the implementation",
6046 MAX_RESERVED_INIT_PRIORITY
);
6052 error ("destructor priorities must be integers from 0 to %d inclusive",
6055 error ("constructor priorities must be integers from 0 to %d inclusive",
6057 return DEFAULT_INIT_PRIORITY
;
6060 /* Handle a "constructor" attribute; arguments as in
6061 struct attribute_spec.handler. */
6064 handle_constructor_attribute (tree
*node
, tree name
, tree args
,
6065 int ARG_UNUSED (flags
),
6069 tree type
= TREE_TYPE (decl
);
6071 if (TREE_CODE (decl
) == FUNCTION_DECL
6072 && TREE_CODE (type
) == FUNCTION_TYPE
6073 && decl_function_context (decl
) == 0)
6075 priority_type priority
;
6076 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
6077 priority
= get_priority (args
, /*is_destructor=*/false);
6078 SET_DECL_INIT_PRIORITY (decl
, priority
);
6079 TREE_USED (decl
) = 1;
6083 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6084 *no_add_attrs
= true;
6090 /* Handle a "destructor" attribute; arguments as in
6091 struct attribute_spec.handler. */
6094 handle_destructor_attribute (tree
*node
, tree name
, tree args
,
6095 int ARG_UNUSED (flags
),
6099 tree type
= TREE_TYPE (decl
);
6101 if (TREE_CODE (decl
) == FUNCTION_DECL
6102 && TREE_CODE (type
) == FUNCTION_TYPE
6103 && decl_function_context (decl
) == 0)
6105 priority_type priority
;
6106 DECL_STATIC_DESTRUCTOR (decl
) = 1;
6107 priority
= get_priority (args
, /*is_destructor=*/true);
6108 SET_DECL_FINI_PRIORITY (decl
, priority
);
6109 TREE_USED (decl
) = 1;
6113 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6114 *no_add_attrs
= true;
6120 /* Handle a "mode" attribute; arguments as in
6121 struct attribute_spec.handler. */
6124 handle_mode_attribute (tree
*node
, tree name
, tree args
,
6125 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6129 *no_add_attrs
= true;
6131 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
6132 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6136 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
6137 int len
= strlen (p
);
6138 enum machine_mode mode
= VOIDmode
;
6142 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
6143 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
6145 char *newp
= (char *) alloca (len
- 1);
6147 strcpy (newp
, &p
[2]);
6148 newp
[len
- 4] = '\0';
6152 /* Change this type to have a type with the specified mode.
6153 First check for the special modes. */
6154 if (!strcmp (p
, "byte"))
6156 else if (!strcmp (p
, "word"))
6158 else if (!strcmp (p
, "pointer"))
6160 else if (!strcmp (p
, "libgcc_cmp_return"))
6161 mode
= targetm
.libgcc_cmp_return_mode ();
6162 else if (!strcmp (p
, "libgcc_shift_count"))
6163 mode
= targetm
.libgcc_shift_count_mode ();
6164 else if (!strcmp (p
, "unwind_word"))
6165 mode
= targetm
.unwind_word_mode ();
6167 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
6168 if (!strcmp (p
, GET_MODE_NAME (j
)))
6170 mode
= (enum machine_mode
) j
;
6174 if (mode
== VOIDmode
)
6176 error ("unknown machine mode %qs", p
);
6181 switch (GET_MODE_CLASS (mode
))
6184 case MODE_PARTIAL_INT
:
6186 case MODE_DECIMAL_FLOAT
:
6191 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
6194 case MODE_COMPLEX_INT
:
6195 case MODE_COMPLEX_FLOAT
:
6196 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
6199 case MODE_VECTOR_INT
:
6200 case MODE_VECTOR_FLOAT
:
6201 case MODE_VECTOR_FRACT
:
6202 case MODE_VECTOR_UFRACT
:
6203 case MODE_VECTOR_ACCUM
:
6204 case MODE_VECTOR_UACCUM
:
6205 warning (OPT_Wattributes
, "specifying vector types with "
6206 "__attribute__ ((mode)) is deprecated");
6207 warning (OPT_Wattributes
,
6208 "use __attribute__ ((vector_size)) instead");
6209 valid_mode
= vector_mode_valid_p (mode
);
6217 error ("unable to emulate %qs", p
);
6221 if (POINTER_TYPE_P (type
))
6223 tree (*fn
)(tree
, enum machine_mode
, bool);
6225 if (!targetm
.valid_pointer_mode (mode
))
6227 error ("invalid pointer mode %qs", p
);
6231 if (TREE_CODE (type
) == POINTER_TYPE
)
6232 fn
= build_pointer_type_for_mode
;
6234 fn
= build_reference_type_for_mode
;
6235 typefm
= fn (TREE_TYPE (type
), mode
, false);
6239 /* For fixed-point modes, we need to test if the signness of type
6240 and the machine mode are consistent. */
6241 if (ALL_FIXED_POINT_MODE_P (mode
)
6242 && TYPE_UNSIGNED (type
) != UNSIGNED_FIXED_POINT_MODE_P (mode
))
6244 error ("signness of type and machine mode %qs don't match", p
);
6247 /* For fixed-point modes, we need to pass saturating info. */
6248 typefm
= lang_hooks
.types
.type_for_mode (mode
,
6249 ALL_FIXED_POINT_MODE_P (mode
) ? TYPE_SATURATING (type
)
6250 : TYPE_UNSIGNED (type
));
6253 if (typefm
== NULL_TREE
)
6255 error ("no data type for mode %qs", p
);
6258 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
6260 /* For enumeral types, copy the precision from the integer
6261 type returned above. If not an INTEGER_TYPE, we can't use
6262 this mode for this type. */
6263 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
6265 error ("cannot use mode %qs for enumeral types", p
);
6269 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
6271 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
6276 /* We cannot build a type variant, as there's code that assumes
6277 that TYPE_MAIN_VARIANT has the same mode. This includes the
6278 debug generators. Instead, create a subrange type. This
6279 results in all of the enumeral values being emitted only once
6280 in the original, and the subtype gets them by reference. */
6281 if (TYPE_UNSIGNED (type
))
6282 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
6284 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
6285 TREE_TYPE (typefm
) = type
;
6288 else if (VECTOR_MODE_P (mode
)
6289 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
6290 : TREE_CODE (type
) != TREE_CODE (typefm
))
6292 error ("mode %qs applied to inappropriate type", p
);
6302 /* Handle a "section" attribute; arguments as in
6303 struct attribute_spec.handler. */
6306 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6307 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6311 if (targetm
.have_named_sections
)
6313 user_defined_section_attribute
= true;
6315 if ((TREE_CODE (decl
) == FUNCTION_DECL
6316 || TREE_CODE (decl
) == VAR_DECL
)
6317 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
6319 if (TREE_CODE (decl
) == VAR_DECL
6320 && current_function_decl
!= NULL_TREE
6321 && !TREE_STATIC (decl
))
6323 error ("%Jsection attribute cannot be specified for "
6324 "local variables", decl
);
6325 *no_add_attrs
= true;
6328 /* The decl may have already been given a section attribute
6329 from a previous declaration. Ensure they match. */
6330 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
6331 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
6332 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
6334 error ("section of %q+D conflicts with previous declaration",
6336 *no_add_attrs
= true;
6338 else if (TREE_CODE (decl
) == VAR_DECL
6339 && !targetm
.have_tls
&& targetm
.emutls
.tmpl_section
6340 && DECL_THREAD_LOCAL_P (decl
))
6342 error ("section of %q+D cannot be overridden", *node
);
6343 *no_add_attrs
= true;
6346 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
6350 error ("section attribute not allowed for %q+D", *node
);
6351 *no_add_attrs
= true;
6356 error ("%Jsection attributes are not supported for this target", *node
);
6357 *no_add_attrs
= true;
6363 /* Handle a "aligned" attribute; arguments as in
6364 struct attribute_spec.handler. */
6367 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6368 int flags
, bool *no_add_attrs
)
6370 tree decl
= NULL_TREE
;
6373 tree align_expr
= (args
? TREE_VALUE (args
)
6374 : size_int (ATTRIBUTE_ALIGNED_VALUE
/ BITS_PER_UNIT
));
6380 type
= &TREE_TYPE (decl
);
6381 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
6383 else if (TYPE_P (*node
))
6384 type
= node
, is_type
= 1;
6386 if (TREE_CODE (align_expr
) != INTEGER_CST
)
6388 error ("requested alignment is not a constant");
6389 *no_add_attrs
= true;
6391 else if ((i
= tree_log2 (align_expr
)) == -1)
6393 error ("requested alignment is not a power of 2");
6394 *no_add_attrs
= true;
6396 else if (i
>= HOST_BITS_PER_INT
- BITS_PER_UNIT_LOG
)
6398 error ("requested alignment is too large");
6399 *no_add_attrs
= true;
6403 /* If we have a TYPE_DECL, then copy the type, so that we
6404 don't accidentally modify a builtin type. See pushdecl. */
6405 if (decl
&& TREE_TYPE (decl
) != error_mark_node
6406 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
6408 tree tt
= TREE_TYPE (decl
);
6409 *type
= build_variant_type_copy (*type
);
6410 DECL_ORIGINAL_TYPE (decl
) = tt
;
6411 TYPE_NAME (*type
) = decl
;
6412 TREE_USED (*type
) = TREE_USED (decl
);
6413 TREE_TYPE (decl
) = *type
;
6415 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6416 *type
= build_variant_type_copy (*type
);
6418 TYPE_ALIGN (*type
) = (1U << i
) * BITS_PER_UNIT
;
6419 TYPE_USER_ALIGN (*type
) = 1;
6421 else if (! VAR_OR_FUNCTION_DECL_P (decl
)
6422 && TREE_CODE (decl
) != FIELD_DECL
)
6424 error ("alignment may not be specified for %q+D", decl
);
6425 *no_add_attrs
= true;
6427 else if (TREE_CODE (decl
) == FUNCTION_DECL
6428 && DECL_ALIGN (decl
) > (1U << i
) * BITS_PER_UNIT
)
6430 if (DECL_USER_ALIGN (decl
))
6431 error ("alignment for %q+D was previously specified as %d "
6432 "and may not be decreased", decl
,
6433 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6435 error ("alignment for %q+D must be at least %d", decl
,
6436 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6437 *no_add_attrs
= true;
6441 DECL_ALIGN (decl
) = (1U << i
) * BITS_PER_UNIT
;
6442 DECL_USER_ALIGN (decl
) = 1;
6448 /* Handle a "weak" attribute; arguments as in
6449 struct attribute_spec.handler. */
6452 handle_weak_attribute (tree
*node
, tree name
,
6453 tree
ARG_UNUSED (args
),
6454 int ARG_UNUSED (flags
),
6455 bool * ARG_UNUSED (no_add_attrs
))
6457 if (TREE_CODE (*node
) == FUNCTION_DECL
6458 && DECL_DECLARED_INLINE_P (*node
))
6460 error ("inline function %q+D cannot be declared weak", *node
);
6461 *no_add_attrs
= true;
6463 else if (TREE_CODE (*node
) == FUNCTION_DECL
6464 || TREE_CODE (*node
) == VAR_DECL
)
6465 declare_weak (*node
);
6467 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6472 /* Handle an "alias" attribute; arguments as in
6473 struct attribute_spec.handler. */
6476 handle_alias_attribute (tree
*node
, tree name
, tree args
,
6477 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6481 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
6483 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6484 *no_add_attrs
= true;
6486 else if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
6487 || (TREE_CODE (decl
) != FUNCTION_DECL
6488 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
6489 /* A static variable declaration is always a tentative definition,
6490 but the alias is a non-tentative definition which overrides. */
6491 || (TREE_CODE (decl
) != FUNCTION_DECL
6492 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
6494 error ("%q+D defined both normally and as an alias", decl
);
6495 *no_add_attrs
= true;
6498 /* Note that the very first time we process a nested declaration,
6499 decl_function_context will not be set. Indeed, *would* never
6500 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6501 we do below. After such frobbery, pushdecl would set the context.
6502 In any case, this is never what we want. */
6503 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
6507 id
= TREE_VALUE (args
);
6508 if (TREE_CODE (id
) != STRING_CST
)
6510 error ("alias argument not a string");
6511 *no_add_attrs
= true;
6514 id
= get_identifier (TREE_STRING_POINTER (id
));
6515 /* This counts as a use of the object pointed to. */
6518 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6519 DECL_INITIAL (decl
) = error_mark_node
;
6522 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
6523 DECL_EXTERNAL (decl
) = 1;
6525 DECL_EXTERNAL (decl
) = 0;
6526 TREE_STATIC (decl
) = 1;
6531 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6532 *no_add_attrs
= true;
6538 /* Handle a "weakref" attribute; arguments as in struct
6539 attribute_spec.handler. */
6542 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6543 int flags
, bool *no_add_attrs
)
6545 tree attr
= NULL_TREE
;
6547 /* We must ignore the attribute when it is associated with
6548 local-scoped decls, since attribute alias is ignored and many
6549 such symbols do not even have a DECL_WEAK field. */
6550 if (decl_function_context (*node
)
6551 || current_function_decl
6552 || (TREE_CODE (*node
) != VAR_DECL
&& TREE_CODE (*node
) != FUNCTION_DECL
))
6554 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6555 *no_add_attrs
= true;
6559 /* The idea here is that `weakref("name")' mutates into `weakref,
6560 alias("name")', and weakref without arguments, in turn,
6561 implicitly adds weak. */
6565 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
6566 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
6568 *no_add_attrs
= true;
6570 decl_attributes (node
, attr
, flags
);
6574 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
6575 error ("%Jweakref attribute must appear before alias attribute",
6578 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6579 and that isn't supported; and because it wants to add it to
6580 the list of weak decls, which isn't helpful. */
6581 DECL_WEAK (*node
) = 1;
6587 /* Handle an "visibility" attribute; arguments as in
6588 struct attribute_spec.handler. */
6591 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
6592 int ARG_UNUSED (flags
),
6593 bool *ARG_UNUSED (no_add_attrs
))
6596 tree id
= TREE_VALUE (args
);
6597 enum symbol_visibility vis
;
6601 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
6603 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
6605 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
6609 else if (TYPE_FIELDS (*node
))
6611 error ("%qE attribute ignored because %qT is already defined",
6616 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
6618 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6622 if (TREE_CODE (id
) != STRING_CST
)
6624 error ("visibility argument not a string");
6628 /* If this is a type, set the visibility on the type decl. */
6631 decl
= TYPE_NAME (decl
);
6634 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6636 warning (OPT_Wattributes
, "%qE attribute ignored on types",
6642 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
6643 vis
= VISIBILITY_DEFAULT
;
6644 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
6645 vis
= VISIBILITY_INTERNAL
;
6646 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
6647 vis
= VISIBILITY_HIDDEN
;
6648 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
6649 vis
= VISIBILITY_PROTECTED
;
6652 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6653 vis
= VISIBILITY_DEFAULT
;
6656 if (DECL_VISIBILITY_SPECIFIED (decl
)
6657 && vis
!= DECL_VISIBILITY (decl
))
6659 tree attributes
= (TYPE_P (*node
)
6660 ? TYPE_ATTRIBUTES (*node
)
6661 : DECL_ATTRIBUTES (decl
));
6662 if (lookup_attribute ("visibility", attributes
))
6663 error ("%qD redeclared with different visibility", decl
);
6664 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6665 && lookup_attribute ("dllimport", attributes
))
6666 error ("%qD was declared %qs which implies default visibility",
6668 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6669 && lookup_attribute ("dllexport", attributes
))
6670 error ("%qD was declared %qs which implies default visibility",
6674 DECL_VISIBILITY (decl
) = vis
;
6675 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
6677 /* Go ahead and attach the attribute to the node as well. This is needed
6678 so we can determine whether we have VISIBILITY_DEFAULT because the
6679 visibility was not specified, or because it was explicitly overridden
6680 from the containing scope. */
6685 /* Determine the ELF symbol visibility for DECL, which is either a
6686 variable or a function. It is an error to use this function if a
6687 definition of DECL is not available in this translation unit.
6688 Returns true if the final visibility has been determined by this
6689 function; false if the caller is free to make additional
6693 c_determine_visibility (tree decl
)
6695 gcc_assert (TREE_CODE (decl
) == VAR_DECL
6696 || TREE_CODE (decl
) == FUNCTION_DECL
);
6698 /* If the user explicitly specified the visibility with an
6699 attribute, honor that. DECL_VISIBILITY will have been set during
6700 the processing of the attribute. We check for an explicit
6701 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6702 to distinguish the use of an attribute from the use of a "#pragma
6703 GCC visibility push(...)"; in the latter case we still want other
6704 considerations to be able to overrule the #pragma. */
6705 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
6706 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6707 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
6708 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
6711 /* Set default visibility to whatever the user supplied with
6712 visibility_specified depending on #pragma GCC visibility. */
6713 if (!DECL_VISIBILITY_SPECIFIED (decl
))
6715 if (visibility_options
.inpragma
6716 || DECL_VISIBILITY (decl
) != default_visibility
)
6718 DECL_VISIBILITY (decl
) = default_visibility
;
6719 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
6720 /* If visibility changed and DECL already has DECL_RTL, ensure
6721 symbol flags are updated. */
6722 if (((TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
6723 || TREE_CODE (decl
) == FUNCTION_DECL
)
6724 && DECL_RTL_SET_P (decl
))
6725 make_decl_rtl (decl
);
6731 /* Handle an "tls_model" attribute; arguments as in
6732 struct attribute_spec.handler. */
6735 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
6736 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6740 enum tls_model kind
;
6742 *no_add_attrs
= true;
6744 if (TREE_CODE (decl
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (decl
))
6746 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6750 kind
= DECL_TLS_MODEL (decl
);
6751 id
= TREE_VALUE (args
);
6752 if (TREE_CODE (id
) != STRING_CST
)
6754 error ("tls_model argument not a string");
6758 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
6759 kind
= TLS_MODEL_LOCAL_EXEC
;
6760 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
6761 kind
= TLS_MODEL_INITIAL_EXEC
;
6762 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
6763 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
6764 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
6765 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
6767 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6769 DECL_TLS_MODEL (decl
) = kind
;
6773 /* Handle a "no_instrument_function" attribute; arguments as in
6774 struct attribute_spec.handler. */
6777 handle_no_instrument_function_attribute (tree
*node
, tree name
,
6778 tree
ARG_UNUSED (args
),
6779 int ARG_UNUSED (flags
),
6784 if (TREE_CODE (decl
) != FUNCTION_DECL
)
6786 error ("%J%qE attribute applies only to functions", decl
, name
);
6787 *no_add_attrs
= true;
6789 else if (DECL_INITIAL (decl
))
6791 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
6792 *no_add_attrs
= true;
6795 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
6800 /* Handle a "malloc" attribute; arguments as in
6801 struct attribute_spec.handler. */
6804 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6805 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6807 if (TREE_CODE (*node
) == FUNCTION_DECL
6808 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
6809 DECL_IS_MALLOC (*node
) = 1;
6812 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6813 *no_add_attrs
= true;
6819 /* Handle a "alloc_size" attribute; arguments as in
6820 struct attribute_spec.handler. */
6823 handle_alloc_size_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6824 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6826 unsigned arg_count
= type_num_arguments (*node
);
6827 for (; args
; args
= TREE_CHAIN (args
))
6829 tree position
= TREE_VALUE (args
);
6831 if (TREE_CODE (position
) != INTEGER_CST
6832 || TREE_INT_CST_HIGH (position
)
6833 || TREE_INT_CST_LOW (position
) < 1
6834 || TREE_INT_CST_LOW (position
) > arg_count
)
6836 warning (OPT_Wattributes
,
6837 "alloc_size parameter outside range");
6838 *no_add_attrs
= true;
6845 /* Handle a "returns_twice" attribute; arguments as in
6846 struct attribute_spec.handler. */
6849 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6850 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6852 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6853 DECL_IS_RETURNS_TWICE (*node
) = 1;
6856 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6857 *no_add_attrs
= true;
6863 /* Handle a "no_limit_stack" attribute; arguments as in
6864 struct attribute_spec.handler. */
6867 handle_no_limit_stack_attribute (tree
*node
, tree name
,
6868 tree
ARG_UNUSED (args
),
6869 int ARG_UNUSED (flags
),
6874 if (TREE_CODE (decl
) != FUNCTION_DECL
)
6876 error ("%J%qE attribute applies only to functions", decl
, name
);
6877 *no_add_attrs
= true;
6879 else if (DECL_INITIAL (decl
))
6881 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
6882 *no_add_attrs
= true;
6885 DECL_NO_LIMIT_STACK (decl
) = 1;
6890 /* Handle a "pure" attribute; arguments as in
6891 struct attribute_spec.handler. */
6894 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6895 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6897 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6898 DECL_PURE_P (*node
) = 1;
6899 /* ??? TODO: Support types. */
6902 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6903 *no_add_attrs
= true;
6909 /* Handle a "no vops" attribute; arguments as in
6910 struct attribute_spec.handler. */
6913 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
6914 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
6915 bool *ARG_UNUSED (no_add_attrs
))
6917 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
6918 DECL_IS_NOVOPS (*node
) = 1;
6922 /* Handle a "deprecated" attribute; arguments as in
6923 struct attribute_spec.handler. */
6926 handle_deprecated_attribute (tree
*node
, tree name
,
6927 tree
ARG_UNUSED (args
), int flags
,
6930 tree type
= NULL_TREE
;
6932 tree what
= NULL_TREE
;
6937 type
= TREE_TYPE (decl
);
6939 if (TREE_CODE (decl
) == TYPE_DECL
6940 || TREE_CODE (decl
) == PARM_DECL
6941 || TREE_CODE (decl
) == VAR_DECL
6942 || TREE_CODE (decl
) == FUNCTION_DECL
6943 || TREE_CODE (decl
) == FIELD_DECL
)
6944 TREE_DEPRECATED (decl
) = 1;
6948 else if (TYPE_P (*node
))
6950 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6951 *node
= build_variant_type_copy (*node
);
6952 TREE_DEPRECATED (*node
) = 1;
6960 *no_add_attrs
= true;
6961 if (type
&& TYPE_NAME (type
))
6963 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
6964 what
= TYPE_NAME (*node
);
6965 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
6966 && DECL_NAME (TYPE_NAME (type
)))
6967 what
= DECL_NAME (TYPE_NAME (type
));
6970 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
6972 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6978 /* Handle a "vector_size" attribute; arguments as in
6979 struct attribute_spec.handler. */
6982 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
6983 int ARG_UNUSED (flags
),
6986 unsigned HOST_WIDE_INT vecsize
, nunits
;
6987 enum machine_mode orig_mode
;
6988 tree type
= *node
, new_type
, size
;
6990 *no_add_attrs
= true;
6992 size
= TREE_VALUE (args
);
6994 if (!host_integerp (size
, 1))
6996 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7000 /* Get the vector size (in bytes). */
7001 vecsize
= tree_low_cst (size
, 1);
7003 /* We need to provide for vector pointers, vector arrays, and
7004 functions returning vectors. For example:
7006 __attribute__((vector_size(16))) short *foo;
7008 In this case, the mode is SI, but the type being modified is
7009 HI, so we need to look further. */
7011 while (POINTER_TYPE_P (type
)
7012 || TREE_CODE (type
) == FUNCTION_TYPE
7013 || TREE_CODE (type
) == METHOD_TYPE
7014 || TREE_CODE (type
) == ARRAY_TYPE
7015 || TREE_CODE (type
) == OFFSET_TYPE
)
7016 type
= TREE_TYPE (type
);
7018 /* Get the mode of the type being modified. */
7019 orig_mode
= TYPE_MODE (type
);
7021 if ((!INTEGRAL_TYPE_P (type
)
7022 && !SCALAR_FLOAT_TYPE_P (type
)
7023 && !FIXED_POINT_TYPE_P (type
))
7024 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
7025 && GET_MODE_CLASS (orig_mode
) != MODE_INT
7026 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode
))
7027 || !host_integerp (TYPE_SIZE_UNIT (type
), 1)
7028 || TREE_CODE (type
) == BOOLEAN_TYPE
)
7030 error ("invalid vector type for attribute %qE", name
);
7034 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
7036 error ("vector size not an integral multiple of component size");
7042 error ("zero vector size");
7046 /* Calculate how many units fit in the vector. */
7047 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
7048 if (nunits
& (nunits
- 1))
7050 error ("number of components of the vector not a power of two");
7054 new_type
= build_vector_type (type
, nunits
);
7056 /* Build back pointers if needed. */
7057 *node
= lang_hooks
.types
.reconstruct_complex_type (*node
, new_type
);
7062 /* Handle the "nonnull" attribute. */
7064 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7065 tree args
, int ARG_UNUSED (flags
),
7069 unsigned HOST_WIDE_INT attr_arg_num
;
7071 /* If no arguments are specified, all pointer arguments should be
7072 non-null. Verify a full prototype is given so that the arguments
7073 will have the correct types when we actually check them later. */
7076 if (!TYPE_ARG_TYPES (type
))
7078 error ("nonnull attribute without arguments on a non-prototype");
7079 *no_add_attrs
= true;
7084 /* Argument list specified. Verify that each argument number references
7085 a pointer argument. */
7086 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
7089 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
7091 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
7093 error ("nonnull argument has invalid operand number (argument %lu)",
7094 (unsigned long) attr_arg_num
);
7095 *no_add_attrs
= true;
7099 argument
= TYPE_ARG_TYPES (type
);
7102 for (ck_num
= 1; ; ck_num
++)
7104 if (!argument
|| ck_num
== arg_num
)
7106 argument
= TREE_CHAIN (argument
);
7110 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
7112 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7113 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7114 *no_add_attrs
= true;
7118 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
7120 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7121 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7122 *no_add_attrs
= true;
7131 /* Check the argument list of a function call for null in argument slots
7132 that are marked as requiring a non-null pointer argument. The NARGS
7133 arguments are passed in the array ARGARRAY.
7137 check_function_nonnull (tree attrs
, int nargs
, tree
*argarray
)
7142 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
7144 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
7146 args
= TREE_VALUE (a
);
7148 /* Walk the argument list. If we encounter an argument number we
7149 should check for non-null, do it. If the attribute has no args,
7150 then every pointer argument is checked (in which case the check
7151 for pointer type is done in check_nonnull_arg). */
7152 for (i
= 0; i
< nargs
; i
++)
7154 if (!args
|| nonnull_check_p (args
, i
+ 1))
7155 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
7163 /* Check that the Nth argument of a function call (counting backwards
7164 from the end) is a (pointer)0. The NARGS arguments are passed in the
7168 check_function_sentinel (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7170 tree attr
= lookup_attribute ("sentinel", attrs
);
7178 /* Skip over the named arguments. */
7179 while (typelist
&& len
< nargs
)
7181 typelist
= TREE_CHAIN (typelist
);
7185 if (TREE_VALUE (attr
))
7187 tree p
= TREE_VALUE (TREE_VALUE (attr
));
7188 pos
= TREE_INT_CST_LOW (p
);
7191 /* The sentinel must be one of the varargs, i.e.
7192 in position >= the number of fixed arguments. */
7193 if ((nargs
- 1 - pos
) < len
)
7195 warning (OPT_Wformat
,
7196 "not enough variable arguments to fit a sentinel");
7200 /* Validate the sentinel. */
7201 sentinel
= argarray
[nargs
- 1 - pos
];
7202 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
7203 || !integer_zerop (sentinel
))
7204 /* Although __null (in C++) is only an integer we allow it
7205 nevertheless, as we are guaranteed that it's exactly
7206 as wide as a pointer, and we don't want to force
7207 users to cast the NULL they have written there.
7208 We warn with -Wstrict-null-sentinel, though. */
7209 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
7210 warning (OPT_Wformat
, "missing sentinel in function call");
7214 /* Helper for check_function_nonnull; given a list of operands which
7215 must be non-null in ARGS, determine if operand PARAM_NUM should be
7219 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
7221 unsigned HOST_WIDE_INT arg_num
= 0;
7223 for (; args
; args
= TREE_CHAIN (args
))
7225 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
7229 if (arg_num
== param_num
)
7235 /* Check that the function argument PARAM (which is operand number
7236 PARAM_NUM) is non-null. This is called by check_function_nonnull
7237 via check_function_arguments_recurse. */
7240 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
7241 unsigned HOST_WIDE_INT param_num
)
7243 /* Just skip checking the argument if it's not a pointer. This can
7244 happen if the "nonnull" attribute was given without an operand
7245 list (which means to check every pointer argument). */
7247 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
7250 if (integer_zerop (param
))
7251 warning (OPT_Wnonnull
, "null argument where non-null required "
7252 "(argument %lu)", (unsigned long) param_num
);
7255 /* Helper for nonnull attribute handling; fetch the operand number
7256 from the attribute argument list. */
7259 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
7261 /* Verify the arg number is a constant. */
7262 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
7263 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
7266 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
7270 /* Handle a "nothrow" attribute; arguments as in
7271 struct attribute_spec.handler. */
7274 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7275 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7277 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7278 TREE_NOTHROW (*node
) = 1;
7279 /* ??? TODO: Support types. */
7282 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7283 *no_add_attrs
= true;
7289 /* Handle a "cleanup" attribute; arguments as in
7290 struct attribute_spec.handler. */
7293 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
7294 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7297 tree cleanup_id
, cleanup_decl
;
7299 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7300 for global destructors in C++. This requires infrastructure that
7301 we don't have generically at the moment. It's also not a feature
7302 we'd be missing too much, since we do have attribute constructor. */
7303 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
7305 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7306 *no_add_attrs
= true;
7310 /* Verify that the argument is a function in scope. */
7311 /* ??? We could support pointers to functions here as well, if
7312 that was considered desirable. */
7313 cleanup_id
= TREE_VALUE (args
);
7314 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
7316 error ("cleanup argument not an identifier");
7317 *no_add_attrs
= true;
7320 cleanup_decl
= lookup_name (cleanup_id
);
7321 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
7323 error ("cleanup argument not a function");
7324 *no_add_attrs
= true;
7328 /* That the function has proper type is checked with the
7329 eventual call to build_function_call. */
7334 /* Handle a "warn_unused_result" attribute. No special handling. */
7337 handle_warn_unused_result_attribute (tree
*node
, tree name
,
7338 tree
ARG_UNUSED (args
),
7339 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7341 /* Ignore the attribute for functions not returning any value. */
7342 if (VOID_TYPE_P (TREE_TYPE (*node
)))
7344 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7345 *no_add_attrs
= true;
7351 /* Handle a "sentinel" attribute. */
7354 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
7355 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7357 tree params
= TYPE_ARG_TYPES (*node
);
7361 warning (OPT_Wattributes
,
7362 "%qE attribute requires prototypes with named arguments", name
);
7363 *no_add_attrs
= true;
7367 while (TREE_CHAIN (params
))
7368 params
= TREE_CHAIN (params
);
7370 if (VOID_TYPE_P (TREE_VALUE (params
)))
7372 warning (OPT_Wattributes
,
7373 "%qE attribute only applies to variadic functions", name
);
7374 *no_add_attrs
= true;
7380 tree position
= TREE_VALUE (args
);
7382 if (TREE_CODE (position
) != INTEGER_CST
)
7384 warning (OPT_Wattributes
,
7385 "requested position is not an integer constant");
7386 *no_add_attrs
= true;
7390 if (tree_int_cst_lt (position
, integer_zero_node
))
7392 warning (OPT_Wattributes
,
7393 "requested position is less than zero");
7394 *no_add_attrs
= true;
7402 /* Handle a "type_generic" attribute. */
7405 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7406 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
7407 bool * ARG_UNUSED (no_add_attrs
))
7411 /* Ensure we have a function type. */
7412 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
7414 params
= TYPE_ARG_TYPES (*node
);
7415 while (params
&& ! VOID_TYPE_P (TREE_VALUE (params
)))
7416 params
= TREE_CHAIN (params
);
7418 /* Ensure we have a variadic function. */
7419 gcc_assert (!params
);
7424 /* Handle a "target" attribute. */
7427 handle_target_attribute (tree
*node
, tree name
, tree args
, int flags
,
7430 /* Ensure we have a function type. */
7431 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7433 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7434 *no_add_attrs
= true;
7436 else if (! targetm
.target_option
.valid_attribute_p (*node
, name
, args
,
7438 *no_add_attrs
= true;
7443 /* Arguments being collected for optimization. */
7444 typedef const char *const_char_p
; /* For DEF_VEC_P. */
7445 DEF_VEC_P(const_char_p
);
7446 DEF_VEC_ALLOC_P(const_char_p
, gc
);
7447 static GTY(()) VEC(const_char_p
, gc
) *optimize_args
;
7450 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7451 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7452 false for #pragma GCC optimize. */
7455 parse_optimize_options (tree args
, bool attr_p
)
7460 int saved_flag_strict_aliasing
;
7461 const char **opt_argv
;
7464 /* Build up argv vector. Just in case the string is stored away, use garbage
7465 collected strings. */
7466 VEC_truncate (const_char_p
, optimize_args
, 0);
7467 VEC_safe_push (const_char_p
, gc
, optimize_args
, NULL
);
7469 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
7471 tree value
= TREE_VALUE (ap
);
7473 if (TREE_CODE (value
) == INTEGER_CST
)
7476 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
7477 VEC_safe_push (const_char_p
, gc
, optimize_args
, ggc_strdup (buffer
));
7480 else if (TREE_CODE (value
) == STRING_CST
)
7482 /* Split string into multiple substrings. */
7483 size_t len
= TREE_STRING_LENGTH (value
);
7484 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
7485 char *end
= p
+ len
;
7489 while (next_p
!= NULL
)
7495 comma
= strchr (p
, ',');
7508 r
= q
= (char *) ggc_alloc (len2
+ 3);
7510 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7512 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
7516 warning (OPT_Wattributes
,
7517 "Bad option %s to optimize attribute.", p
);
7519 warning (OPT_Wpragmas
,
7520 "Bad option %s to pragma attribute", p
);
7528 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7529 itself is -Os, and any other switch begins with a -f. */
7530 if ((*p
>= '0' && *p
<= '9')
7531 || (p
[0] == 's' && p
[1] == '\0'))
7537 memcpy (r
, p
, len2
);
7539 VEC_safe_push (const_char_p
, gc
, optimize_args
, q
);
7545 opt_argc
= VEC_length (const_char_p
, optimize_args
);
7546 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
7548 for (i
= 1; i
< opt_argc
; i
++)
7549 opt_argv
[i
] = VEC_index (const_char_p
, optimize_args
, i
);
7551 saved_flag_strict_aliasing
= flag_strict_aliasing
;
7553 /* Now parse the options. */
7554 decode_options (opt_argc
, opt_argv
);
7556 /* Don't allow changing -fstrict-aliasing. */
7557 flag_strict_aliasing
= saved_flag_strict_aliasing
;
7559 VEC_truncate (const_char_p
, optimize_args
, 0);
7563 /* For handling "optimize" attribute. arguments as in
7564 struct attribute_spec.handler. */
7567 handle_optimize_attribute (tree
*node
, tree name
, tree args
,
7568 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7570 /* Ensure we have a function type. */
7571 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7573 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7574 *no_add_attrs
= true;
7578 struct cl_optimization cur_opts
;
7579 tree old_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
);
7581 /* Save current options. */
7582 cl_optimization_save (&cur_opts
);
7584 /* If we previously had some optimization options, use them as the
7587 cl_optimization_restore (TREE_OPTIMIZATION (old_opts
));
7589 /* Parse options, and update the vector. */
7590 parse_optimize_options (args
, true);
7591 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
)
7592 = build_optimization_node ();
7594 /* Restore current options. */
7595 cl_optimization_restore (&cur_opts
);
7601 /* Check for valid arguments being passed to a function.
7602 ATTRS is a list of attributes. There are NARGS arguments in the array
7603 ARGARRAY. TYPELIST is the list of argument types for the function.
7606 check_function_arguments (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7608 /* Check for null being passed in a pointer argument that must be
7609 non-null. We also need to do this if format checking is enabled. */
7612 check_function_nonnull (attrs
, nargs
, argarray
);
7614 /* Check for errors in format strings. */
7616 if (warn_format
|| warn_missing_format_attribute
)
7617 check_function_format (attrs
, nargs
, argarray
);
7620 check_function_sentinel (attrs
, nargs
, argarray
, typelist
);
7623 /* Generic argument checking recursion routine. PARAM is the argument to
7624 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7625 once the argument is resolved. CTX is context for the callback. */
7627 check_function_arguments_recurse (void (*callback
)
7628 (void *, tree
, unsigned HOST_WIDE_INT
),
7629 void *ctx
, tree param
,
7630 unsigned HOST_WIDE_INT param_num
)
7632 if (CONVERT_EXPR_P (param
)
7633 && (TYPE_PRECISION (TREE_TYPE (param
))
7634 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
7636 /* Strip coercion. */
7637 check_function_arguments_recurse (callback
, ctx
,
7638 TREE_OPERAND (param
, 0), param_num
);
7642 if (TREE_CODE (param
) == CALL_EXPR
)
7644 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
7646 bool found_format_arg
= false;
7648 /* See if this is a call to a known internationalization function
7649 that modifies a format arg. Such a function may have multiple
7650 format_arg attributes (for example, ngettext). */
7652 for (attrs
= TYPE_ATTRIBUTES (type
);
7654 attrs
= TREE_CHAIN (attrs
))
7655 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
7658 tree format_num_expr
;
7661 call_expr_arg_iterator iter
;
7663 /* Extract the argument number, which was previously checked
7665 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
7667 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
7668 && !TREE_INT_CST_HIGH (format_num_expr
));
7670 format_num
= TREE_INT_CST_LOW (format_num_expr
);
7672 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
7674 inner_arg
= next_call_expr_arg (&iter
), i
++)
7675 if (i
== format_num
)
7677 check_function_arguments_recurse (callback
, ctx
,
7678 inner_arg
, param_num
);
7679 found_format_arg
= true;
7684 /* If we found a format_arg attribute and did a recursive check,
7685 we are done with checking this argument. Otherwise, we continue
7686 and this will be considered a non-literal. */
7687 if (found_format_arg
)
7691 if (TREE_CODE (param
) == COND_EXPR
)
7693 /* Check both halves of the conditional expression. */
7694 check_function_arguments_recurse (callback
, ctx
,
7695 TREE_OPERAND (param
, 1), param_num
);
7696 check_function_arguments_recurse (callback
, ctx
,
7697 TREE_OPERAND (param
, 2), param_num
);
7701 (*callback
) (ctx
, param
, param_num
);
7704 /* Checks the number of arguments NARGS against the required number
7705 REQUIRED and issues an error if there is a mismatch. Returns true
7706 if the number of arguments is correct, otherwise false. */
7709 validate_nargs (tree fndecl
, int nargs
, int required
)
7711 if (nargs
< required
)
7713 error ("not enough arguments to function %qE", fndecl
);
7716 else if (nargs
> required
)
7718 error ("too many arguments to function %qE", fndecl
);
7724 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7725 Returns false if there was an error, otherwise true. */
7728 check_builtin_function_arguments (tree fndecl
, int nargs
, tree
*args
)
7730 if (!DECL_BUILT_IN (fndecl
)
7731 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
7734 switch (DECL_FUNCTION_CODE (fndecl
))
7736 case BUILT_IN_CONSTANT_P
:
7737 return validate_nargs (fndecl
, nargs
, 1);
7739 case BUILT_IN_ISFINITE
:
7740 case BUILT_IN_ISINF
:
7741 case BUILT_IN_ISINF_SIGN
:
7742 case BUILT_IN_ISNAN
:
7743 case BUILT_IN_ISNORMAL
:
7744 if (validate_nargs (fndecl
, nargs
, 1))
7746 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
7748 error ("non-floating-point argument in call to "
7749 "function %qE", fndecl
);
7756 case BUILT_IN_ISGREATER
:
7757 case BUILT_IN_ISGREATEREQUAL
:
7758 case BUILT_IN_ISLESS
:
7759 case BUILT_IN_ISLESSEQUAL
:
7760 case BUILT_IN_ISLESSGREATER
:
7761 case BUILT_IN_ISUNORDERED
:
7762 if (validate_nargs (fndecl
, nargs
, 2))
7764 enum tree_code code0
, code1
;
7765 code0
= TREE_CODE (TREE_TYPE (args
[0]));
7766 code1
= TREE_CODE (TREE_TYPE (args
[1]));
7767 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
7768 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
7769 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
7771 error ("non-floating-point arguments in call to "
7772 "function %qE", fndecl
);
7779 case BUILT_IN_FPCLASSIFY
:
7780 if (validate_nargs (fndecl
, nargs
, 6))
7785 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
7787 error ("non-const integer argument %u in call to function %qE",
7792 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
7794 error ("non-floating-point argument in call to function %qE",
7807 /* Function to help qsort sort FIELD_DECLs by name order. */
7810 field_decl_cmp (const void *x_p
, const void *y_p
)
7812 const tree
*const x
= (const tree
*const) x_p
;
7813 const tree
*const y
= (const tree
*const) y_p
;
7815 if (DECL_NAME (*x
) == DECL_NAME (*y
))
7816 /* A nontype is "greater" than a type. */
7817 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
7818 if (DECL_NAME (*x
) == NULL_TREE
)
7820 if (DECL_NAME (*y
) == NULL_TREE
)
7822 if (DECL_NAME (*x
) < DECL_NAME (*y
))
7828 gt_pointer_operator new_value
;
7832 /* This routine compares two fields like field_decl_cmp but using the
7833 pointer operator in resort_data. */
7836 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
7838 const tree
*const x
= (const tree
*const) x_p
;
7839 const tree
*const y
= (const tree
*const) y_p
;
7841 if (DECL_NAME (*x
) == DECL_NAME (*y
))
7842 /* A nontype is "greater" than a type. */
7843 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
7844 if (DECL_NAME (*x
) == NULL_TREE
)
7846 if (DECL_NAME (*y
) == NULL_TREE
)
7849 tree d1
= DECL_NAME (*x
);
7850 tree d2
= DECL_NAME (*y
);
7851 resort_data
.new_value (&d1
, resort_data
.cookie
);
7852 resort_data
.new_value (&d2
, resort_data
.cookie
);
7859 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
7862 resort_sorted_fields (void *obj
,
7863 void * ARG_UNUSED (orig_obj
),
7864 gt_pointer_operator new_value
,
7867 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
7868 resort_data
.new_value
= new_value
;
7869 resort_data
.cookie
= cookie
;
7870 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
7871 resort_field_decl_cmp
);
7874 /* Subroutine of c_parse_error.
7875 Return the result of concatenating LHS and RHS. RHS is really
7876 a string literal, its first character is indicated by RHS_START and
7877 RHS_SIZE is its length (including the terminating NUL character).
7879 The caller is responsible for deleting the returned pointer. */
7882 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
7884 const int lhs_size
= strlen (lhs
);
7885 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
7886 strncpy (result
, lhs
, lhs_size
);
7887 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
7891 /* Issue the error given by GMSGID, indicating that it occurred before
7892 TOKEN, which had the associated VALUE. */
7895 c_parse_error (const char *gmsgid
, enum cpp_ttype token
, tree value
)
7897 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
7899 char *message
= NULL
;
7901 if (token
== CPP_EOF
)
7902 message
= catenate_messages (gmsgid
, " at end of input");
7903 else if (token
== CPP_CHAR
|| token
== CPP_WCHAR
|| token
== CPP_CHAR16
7904 || token
== CPP_CHAR32
)
7906 unsigned int val
= TREE_INT_CST_LOW (value
);
7925 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
7926 message
= catenate_messages (gmsgid
, " before %s'%c'");
7928 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
7930 error (message
, prefix
, val
);
7934 else if (token
== CPP_STRING
|| token
== CPP_WSTRING
|| token
== CPP_STRING16
7935 || token
== CPP_STRING32
)
7936 message
= catenate_messages (gmsgid
, " before string constant");
7937 else if (token
== CPP_NUMBER
)
7938 message
= catenate_messages (gmsgid
, " before numeric constant");
7939 else if (token
== CPP_NAME
)
7941 message
= catenate_messages (gmsgid
, " before %qE");
7942 error (message
, value
);
7946 else if (token
== CPP_PRAGMA
)
7947 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
7948 else if (token
== CPP_PRAGMA_EOL
)
7949 message
= catenate_messages (gmsgid
, " before end of line");
7950 else if (token
< N_TTYPES
)
7952 message
= catenate_messages (gmsgid
, " before %qs token");
7953 error (message
, cpp_type2name (token
));
7965 #undef catenate_messages
7968 /* Callback from cpp_error for PFILE to print diagnostics from the
7969 preprocessor. The diagnostic is of type LEVEL, at location
7970 LOCATION unless this is after lexing and the compiler's location
7971 should be used instead, with column number possibly overridden by
7972 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
7973 the arguments. Returns true if a diagnostic was emitted, false
7977 c_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
,
7978 location_t location
, unsigned int column_override
,
7979 const char *msg
, va_list *ap
)
7981 diagnostic_info diagnostic
;
7982 diagnostic_t dlevel
;
7983 int save_warn_system_headers
= warn_system_headers
;
7988 case CPP_DL_WARNING_SYSHDR
:
7991 warn_system_headers
= 1;
7993 case CPP_DL_WARNING
:
7996 dlevel
= DK_WARNING
;
7998 case CPP_DL_PEDWARN
:
7999 if (flag_no_output
&& !flag_pedantic_errors
)
8001 dlevel
= DK_PEDWARN
;
8019 location
= input_location
;
8020 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
8022 if (column_override
)
8023 diagnostic_override_column (&diagnostic
, column_override
);
8024 ret
= report_diagnostic (&diagnostic
);
8025 if (level
== CPP_DL_WARNING_SYSHDR
)
8026 warn_system_headers
= save_warn_system_headers
;
8030 /* Walk a gimplified function and warn for functions whose return value is
8031 ignored and attribute((warn_unused_result)) is set. This is done before
8032 inlining, so we don't have to worry about that. */
8035 c_warn_unused_result (gimple_seq seq
)
8038 gimple_stmt_iterator i
;
8040 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
8042 gimple g
= gsi_stmt (i
);
8044 switch (gimple_code (g
))
8047 c_warn_unused_result (gimple_bind_body (g
));
8050 c_warn_unused_result (gimple_try_eval (g
));
8051 c_warn_unused_result (gimple_try_cleanup (g
));
8054 c_warn_unused_result (gimple_catch_handler (g
));
8056 case GIMPLE_EH_FILTER
:
8057 c_warn_unused_result (gimple_eh_filter_failure (g
));
8061 if (gimple_call_lhs (g
))
8064 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8065 LHS. All calls whose value is ignored should be
8066 represented like this. Look for the attribute. */
8067 fdecl
= gimple_call_fndecl (g
);
8068 ftype
= TREE_TYPE (TREE_TYPE (gimple_call_fn (g
)));
8070 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
8072 location_t loc
= gimple_location (g
);
8075 warning (0, "%Hignoring return value of %qD, "
8076 "declared with attribute warn_unused_result",
8079 warning (0, "%Hignoring return value of function "
8080 "declared with attribute warn_unused_result",
8086 /* Not a container, not a call, or a call whose value is used. */
8092 /* Convert a character from the host to the target execution character
8093 set. cpplib handles this, mostly. */
8096 c_common_to_target_charset (HOST_WIDE_INT c
)
8098 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8099 zero-extended under -fno-signed-char. cpplib insists that characters
8100 and character constants are always unsigned. Hence we must convert
8102 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
8104 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
8106 if (flag_signed_char
)
8107 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
8108 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
8113 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8114 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8115 NULL, at the bottom; much like the traditional rendering of offsetof as a
8116 macro. Returns the folded and properly cast result. */
8119 fold_offsetof_1 (tree expr
, tree stop_ref
)
8121 enum tree_code code
= PLUS_EXPR
;
8124 if (expr
== stop_ref
&& TREE_CODE (expr
) != ERROR_MARK
)
8125 return size_zero_node
;
8127 switch (TREE_CODE (expr
))
8133 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
8134 return error_mark_node
;
8138 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8139 return error_mark_node
;
8142 gcc_assert (integer_zerop (expr
));
8143 return size_zero_node
;
8147 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8148 gcc_assert (base
== error_mark_node
|| base
== size_zero_node
);
8152 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8153 if (base
== error_mark_node
)
8156 t
= TREE_OPERAND (expr
, 1);
8157 if (DECL_C_BIT_FIELD (t
))
8159 error ("attempt to take address of bit-field structure "
8161 return error_mark_node
;
8163 off
= size_binop (PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
8164 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
), 1)
8169 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8170 if (base
== error_mark_node
)
8173 t
= TREE_OPERAND (expr
, 1);
8174 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) < 0)
8177 t
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (t
), t
);
8179 t
= convert (sizetype
, t
);
8180 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
8184 /* Handle static members of volatile structs. */
8185 t
= TREE_OPERAND (expr
, 1);
8186 gcc_assert (TREE_CODE (t
) == VAR_DECL
);
8187 return fold_offsetof_1 (t
, stop_ref
);
8193 return size_binop (code
, base
, off
);
8197 fold_offsetof (tree expr
, tree stop_ref
)
8199 /* Convert back from the internal sizetype to size_t. */
8200 return convert (size_type_node
, fold_offsetof_1 (expr
, stop_ref
));
8203 /* Print an error message for an invalid lvalue. USE says
8204 how the lvalue is being used and so selects the error message. */
8207 lvalue_error (enum lvalue_use use
)
8212 error ("lvalue required as left operand of assignment");
8215 error ("lvalue required as increment operand");
8218 error ("lvalue required as decrement operand");
8221 error ("lvalue required as unary %<&%> operand");
8224 error ("lvalue required in asm statement");
8231 /* *PTYPE is an incomplete array. Complete it with a domain based on
8232 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8233 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8234 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8237 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8239 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
8240 int failure
= 0, quals
;
8241 hashval_t hashcode
= 0;
8243 maxindex
= size_zero_node
;
8246 if (TREE_CODE (initial_value
) == STRING_CST
)
8249 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8250 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
8252 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8254 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
8256 if (VEC_empty (constructor_elt
, v
))
8260 maxindex
= integer_minus_one_node
;
8265 unsigned HOST_WIDE_INT cnt
;
8266 constructor_elt
*ce
;
8267 bool fold_p
= false;
8269 if (VEC_index (constructor_elt
, v
, 0)->index
)
8270 maxindex
= fold_convert (sizetype
,
8271 VEC_index (constructor_elt
,
8273 curindex
= maxindex
;
8276 VEC_iterate (constructor_elt
, v
, cnt
, ce
);
8279 bool curfold_p
= false;
8281 curindex
= ce
->index
, curfold_p
= true;
8285 curindex
= fold_convert (sizetype
, curindex
);
8286 curindex
= size_binop (PLUS_EXPR
, curindex
, size_one_node
);
8288 if (tree_int_cst_lt (maxindex
, curindex
))
8289 maxindex
= curindex
, fold_p
= curfold_p
;
8292 maxindex
= fold_convert (sizetype
, maxindex
);
8297 /* Make an error message unless that happened already. */
8298 if (initial_value
!= error_mark_node
)
8310 elt
= TREE_TYPE (type
);
8311 quals
= TYPE_QUALS (strip_array_types (elt
));
8315 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
8317 /* Using build_distinct_type_copy and modifying things afterward instead
8318 of using build_array_type to create a new type preserves all of the
8319 TYPE_LANG_FLAG_? bits that the front end may have set. */
8320 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
8321 TREE_TYPE (main_type
) = unqual_elt
;
8322 TYPE_DOMAIN (main_type
) = build_index_type (maxindex
);
8323 layout_type (main_type
);
8325 /* Make sure we have the canonical MAIN_TYPE. */
8326 hashcode
= iterative_hash_object (TYPE_HASH (unqual_elt
), hashcode
);
8327 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type
)),
8329 main_type
= type_hash_canon (hashcode
, main_type
);
8331 /* Fix the canonical type. */
8332 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
8333 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
8334 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
8335 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
8336 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
8337 != TYPE_DOMAIN (main_type
)))
8338 TYPE_CANONICAL (main_type
)
8339 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
8340 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)));
8342 TYPE_CANONICAL (main_type
) = main_type
;
8347 type
= c_build_qualified_type (main_type
, quals
);
8349 if (COMPLETE_TYPE_P (type
)
8350 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
8351 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
8353 error ("size of array is too large");
8354 /* If we proceed with the array type as it is, we'll eventually
8355 crash in tree_low_cst(). */
8356 type
= error_mark_node
;
8364 /* Used to help initialize the builtin-types.def table. When a type of
8365 the correct size doesn't exist, use error_mark_node instead of NULL.
8366 The later results in segfaults even when a decl using the type doesn't
8370 builtin_type_for_size (int size
, bool unsignedp
)
8372 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
8373 return type
? type
: error_mark_node
;
8376 /* A helper function for resolve_overloaded_builtin in resolving the
8377 overloaded __sync_ builtins. Returns a positive power of 2 if the
8378 first operand of PARAMS is a pointer to a supported data type.
8379 Returns 0 if an error is encountered. */
8382 sync_resolve_size (tree function
, tree params
)
8389 error ("too few arguments to function %qE", function
);
8393 type
= TREE_TYPE (TREE_VALUE (params
));
8394 if (TREE_CODE (type
) != POINTER_TYPE
)
8397 type
= TREE_TYPE (type
);
8398 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
8401 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
8402 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
8406 error ("incompatible type for argument %d of %qE", 1, function
);
8410 /* A helper function for resolve_overloaded_builtin. Adds casts to
8411 PARAMS to make arguments match up with those of FUNCTION. Drops
8412 the variadic arguments at the end. Returns false if some error
8413 was encountered; true on success. */
8416 sync_resolve_params (tree orig_function
, tree function
, tree params
)
8418 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
8422 /* We've declared the implementation functions to use "volatile void *"
8423 as the pointer parameter, so we shouldn't get any complaints from the
8424 call to check_function_arguments what ever type the user used. */
8425 arg_types
= TREE_CHAIN (arg_types
);
8426 ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
8429 /* For the rest of the values, we need to cast these to FTYPE, so that we
8430 don't get warnings for passing pointer types, etc. */
8431 while (arg_types
!= void_list_node
)
8435 params
= TREE_CHAIN (params
);
8438 error ("too few arguments to function %qE", orig_function
);
8442 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8443 so that we get warnings for anything that doesn't match the pointer
8444 type. This isn't portable across the C and C++ front ends atm. */
8445 val
= TREE_VALUE (params
);
8446 val
= convert (ptype
, val
);
8447 val
= convert (TREE_VALUE (arg_types
), val
);
8448 TREE_VALUE (params
) = val
;
8450 arg_types
= TREE_CHAIN (arg_types
);
8454 /* The definition of these primitives is variadic, with the remaining
8455 being "an optional list of variables protected by the memory barrier".
8456 No clue what that's supposed to mean, precisely, but we consider all
8457 call-clobbered variables to be protected so we're safe. */
8458 TREE_CHAIN (params
) = NULL
;
8463 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8464 RESULT to make it match the type of the first pointer argument in
8468 sync_resolve_return (tree params
, tree result
)
8470 tree ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
8471 ptype
= TYPE_MAIN_VARIANT (ptype
);
8472 return convert (ptype
, result
);
8475 /* Some builtin functions are placeholders for other expressions. This
8476 function should be called immediately after parsing the call expression
8477 before surrounding code has committed to the type of the expression.
8479 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8480 PARAMS is the argument list for the call. The return value is non-null
8481 when expansion is complete, and null if normal processing should
8485 resolve_overloaded_builtin (tree function
, tree params
)
8487 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
8488 switch (DECL_BUILT_IN_CLASS (function
))
8490 case BUILT_IN_NORMAL
:
8493 if (targetm
.resolve_overloaded_builtin
)
8494 return targetm
.resolve_overloaded_builtin (function
, params
);
8501 /* Handle BUILT_IN_NORMAL here. */
8504 case BUILT_IN_FETCH_AND_ADD_N
:
8505 case BUILT_IN_FETCH_AND_SUB_N
:
8506 case BUILT_IN_FETCH_AND_OR_N
:
8507 case BUILT_IN_FETCH_AND_AND_N
:
8508 case BUILT_IN_FETCH_AND_XOR_N
:
8509 case BUILT_IN_FETCH_AND_NAND_N
:
8510 case BUILT_IN_ADD_AND_FETCH_N
:
8511 case BUILT_IN_SUB_AND_FETCH_N
:
8512 case BUILT_IN_OR_AND_FETCH_N
:
8513 case BUILT_IN_AND_AND_FETCH_N
:
8514 case BUILT_IN_XOR_AND_FETCH_N
:
8515 case BUILT_IN_NAND_AND_FETCH_N
:
8516 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N
:
8517 case BUILT_IN_VAL_COMPARE_AND_SWAP_N
:
8518 case BUILT_IN_LOCK_TEST_AND_SET_N
:
8519 case BUILT_IN_LOCK_RELEASE_N
:
8521 int n
= sync_resolve_size (function
, params
);
8522 tree new_function
, result
;
8525 return error_mark_node
;
8527 new_function
= built_in_decls
[orig_code
+ exact_log2 (n
) + 1];
8528 if (!sync_resolve_params (function
, new_function
, params
))
8529 return error_mark_node
;
8531 result
= build_function_call (new_function
, params
);
8532 if (orig_code
!= BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8533 && orig_code
!= BUILT_IN_LOCK_RELEASE_N
)
8534 result
= sync_resolve_return (params
, result
);
8544 /* Ignoring their sign, return true if two scalar types are the same. */
8546 same_scalar_type_ignoring_signedness (tree t1
, tree t2
)
8548 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
8550 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
|| c1
== FIXED_POINT_TYPE
)
8551 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
8552 || c2
== FIXED_POINT_TYPE
));
8554 /* Equality works here because c_common_signed_type uses
8555 TYPE_MAIN_VARIANT. */
8556 return c_common_signed_type (t1
)
8557 == c_common_signed_type (t2
);
8560 /* Check for missing format attributes on function pointers. LTYPE is
8561 the new type or left-hand side type. RTYPE is the old type or
8562 right-hand side type. Returns TRUE if LTYPE is missing the desired
8566 check_missing_format_attribute (tree ltype
, tree rtype
)
8568 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
8571 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
8572 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
8577 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
8578 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
8586 /* Subscripting with type char is likely to lose on a machine where
8587 chars are signed. So warn on any machine, but optionally. Don't
8588 warn for unsigned char since that type is safe. Don't warn for
8589 signed char because anyone who uses that must have done so
8590 deliberately. Furthermore, we reduce the false positive load by
8591 warning only for non-constant value of type char. */
8594 warn_array_subscript_with_type_char (tree index
)
8596 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
8597 && TREE_CODE (index
) != INTEGER_CST
)
8598 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
8601 /* Implement -Wparentheses for the unexpected C precedence rules, to
8602 cover cases like x + y << z which readers are likely to
8603 misinterpret. We have seen an expression in which CODE is a binary
8604 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8605 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8606 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8607 expression was not formed using a binary or unary operator, or it
8608 was enclosed in parentheses. */
8611 warn_about_parentheses (enum tree_code code
,
8612 enum tree_code code_left
, tree arg_left
,
8613 enum tree_code code_right
, tree arg_right
)
8615 if (!warn_parentheses
)
8618 /* This macro tests that the expression ARG with original tree code
8619 CODE appears to be a boolean expression. or the result of folding a
8620 boolean expression. */
8621 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8622 (truth_value_p (TREE_CODE (ARG)) \
8623 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8624 /* Folding may create 0 or 1 integers from other expressions. */ \
8625 || ((CODE) != INTEGER_CST \
8626 && (integer_onep (ARG) || integer_zerop (ARG))))
8631 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8632 warning (OPT_Wparentheses
,
8633 "suggest parentheses around %<+%> inside %<<<%>");
8634 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8635 warning (OPT_Wparentheses
,
8636 "suggest parentheses around %<-%> inside %<<<%>");
8640 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8641 warning (OPT_Wparentheses
,
8642 "suggest parentheses around %<+%> inside %<>>%>");
8643 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8644 warning (OPT_Wparentheses
,
8645 "suggest parentheses around %<-%> inside %<>>%>");
8648 case TRUTH_ORIF_EXPR
:
8649 if (code_left
== TRUTH_ANDIF_EXPR
|| code_right
== TRUTH_ANDIF_EXPR
)
8650 warning (OPT_Wparentheses
,
8651 "suggest parentheses around %<&&%> within %<||%>");
8655 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
8656 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8657 || code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
8658 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8659 warning (OPT_Wparentheses
,
8660 "suggest parentheses around arithmetic in operand of %<|%>");
8661 /* Check cases like x|y==z */
8662 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8663 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8664 warning (OPT_Wparentheses
,
8665 "suggest parentheses around comparison in operand of %<|%>");
8666 /* Check cases like !x | y */
8667 else if (code_left
== TRUTH_NOT_EXPR
8668 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
8669 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
8670 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8674 if (code_left
== BIT_AND_EXPR
8675 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8676 || code_right
== BIT_AND_EXPR
8677 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8678 warning (OPT_Wparentheses
,
8679 "suggest parentheses around arithmetic in operand of %<^%>");
8680 /* Check cases like x^y==z */
8681 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8682 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8683 warning (OPT_Wparentheses
,
8684 "suggest parentheses around comparison in operand of %<^%>");
8688 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8689 warning (OPT_Wparentheses
,
8690 "suggest parentheses around %<+%> in operand of %<&%>");
8691 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8692 warning (OPT_Wparentheses
,
8693 "suggest parentheses around %<-%> in operand of %<&%>");
8694 /* Check cases like x&y==z */
8695 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8696 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8697 warning (OPT_Wparentheses
,
8698 "suggest parentheses around comparison in operand of %<&%>");
8699 /* Check cases like !x & y */
8700 else if (code_left
== TRUTH_NOT_EXPR
8701 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
8702 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
8703 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8707 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8708 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8709 warning (OPT_Wparentheses
,
8710 "suggest parentheses around comparison in operand of %<==%>");
8713 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8714 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8715 warning (OPT_Wparentheses
,
8716 "suggest parentheses around comparison in operand of %<!=%>");
8720 if (TREE_CODE_CLASS (code
) == tcc_comparison
8721 && ((TREE_CODE_CLASS (code_left
) == tcc_comparison
8722 && code_left
!= NE_EXPR
&& code_left
!= EQ_EXPR
8723 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left
)))
8724 || (TREE_CODE_CLASS (code_right
) == tcc_comparison
8725 && code_right
!= NE_EXPR
&& code_right
!= EQ_EXPR
8726 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right
)))))
8727 warning (OPT_Wparentheses
, "comparisons like %<X<=Y<=Z%> do not "
8728 "have their mathematical meaning");
8731 #undef NOT_A_BOOLEAN_EXPR_P
8734 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8737 warn_for_unused_label (tree label
)
8739 if (!TREE_USED (label
))
8741 if (DECL_INITIAL (label
))
8742 warning (OPT_Wunused_label
, "label %q+D defined but not used", label
);
8744 warning (OPT_Wunused_label
, "label %q+D declared but not defined", label
);
8748 #ifndef TARGET_HAS_TARGETCM
8749 struct gcc_targetcm targetcm
= TARGETCM_INITIALIZER
;
8752 /* Warn for division by zero according to the value of DIVISOR. LOC
8753 is the location of the division operator. */
8756 warn_for_div_by_zero (location_t loc
, tree divisor
)
8758 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8759 about division by zero. Do not issue a warning if DIVISOR has a
8760 floating-point type, since we consider 0.0/0.0 a valid way of
8761 generating a NaN. */
8762 if (skip_evaluation
== 0
8763 && (integer_zerop (divisor
) || fixed_zerop (divisor
)))
8764 warning_at (loc
, OPT_Wdiv_by_zero
, "division by zero");
8767 /* Subroutine of build_binary_op. Give warnings for comparisons
8768 between signed and unsigned quantities that may fail. Do the
8769 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8770 so that casts will be considered, but default promotions won't
8773 LOCATION is the location of the comparison operator.
8775 The arguments of this function map directly to local variables
8776 of build_binary_op. */
8779 warn_for_sign_compare (location_t location
,
8780 tree orig_op0
, tree orig_op1
,
8782 tree result_type
, enum tree_code resultcode
)
8784 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
8785 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
8786 int unsignedp0
, unsignedp1
;
8788 /* In C++, check for comparison of different enum types. */
8790 && TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
8791 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
8792 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
8793 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
8795 warning_at (location
,
8796 OPT_Wsign_compare
, "comparison between types %qT and %qT",
8797 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
8800 /* Do not warn if the comparison is being done in a signed type,
8801 since the signed type will only be chosen if it can represent
8802 all the values of the unsigned type. */
8803 if (!TYPE_UNSIGNED (result_type
))
8805 /* Do not warn if both operands are unsigned. */
8806 else if (op0_signed
== op1_signed
)
8810 tree sop
, uop
, base_type
;
8814 sop
= orig_op0
, uop
= orig_op1
;
8816 sop
= orig_op1
, uop
= orig_op0
;
8818 STRIP_TYPE_NOPS (sop
);
8819 STRIP_TYPE_NOPS (uop
);
8820 base_type
= (TREE_CODE (result_type
) == COMPLEX_TYPE
8821 ? TREE_TYPE (result_type
) : result_type
);
8823 /* Do not warn if the signed quantity is an unsuffixed integer
8824 literal (or some static constant expression involving such
8825 literals or a conditional expression involving such literals)
8826 and it is non-negative. */
8827 if (tree_expr_nonnegative_warnv_p (sop
, &ovf
))
8829 /* Do not warn if the comparison is an equality operation, the
8830 unsigned quantity is an integral constant, and it would fit
8831 in the result if the result were signed. */
8832 else if (TREE_CODE (uop
) == INTEGER_CST
8833 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
8834 && int_fits_type_p (uop
, c_common_signed_type (base_type
)))
8836 /* In C, do not warn if the unsigned quantity is an enumeration
8837 constant and its maximum value would fit in the result if the
8838 result were signed. */
8839 else if (!c_dialect_cxx() && TREE_CODE (uop
) == INTEGER_CST
8840 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
8841 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
8842 c_common_signed_type (base_type
)))
8845 warning_at (location
,
8847 "comparison between signed and unsigned integer expressions");
8850 /* Warn if two unsigned values are being compared in a size larger
8851 than their original size, and one (and only one) is the result of
8852 a `~' operator. This comparison will always fail.
8854 Also warn if one operand is a constant, and the constant does not
8855 have all bits set that are set in the ~ operand when it is
8858 op0
= get_narrower (op0
, &unsignedp0
);
8859 op1
= get_narrower (op1
, &unsignedp1
);
8861 if ((TREE_CODE (op0
) == BIT_NOT_EXPR
)
8862 ^ (TREE_CODE (op1
) == BIT_NOT_EXPR
))
8864 if (TREE_CODE (op0
) == BIT_NOT_EXPR
)
8865 op0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
8866 if (TREE_CODE (op1
) == BIT_NOT_EXPR
)
8867 op1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
8869 if (host_integerp (op0
, 0) || host_integerp (op1
, 0))
8872 HOST_WIDE_INT constant
, mask
;
8876 if (host_integerp (op0
, 0))
8879 unsignedp
= unsignedp1
;
8880 constant
= tree_low_cst (op0
, 0);
8885 unsignedp
= unsignedp0
;
8886 constant
= tree_low_cst (op1
, 0);
8889 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
8890 if (bits
< TYPE_PRECISION (result_type
)
8891 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
8893 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
8894 if ((mask
& constant
) != mask
)
8897 warning (OPT_Wsign_compare
,
8898 "promoted ~unsigned is always non-zero");
8900 warning_at (location
, OPT_Wsign_compare
,
8901 "comparison of promoted ~unsigned with constant");
8905 else if (unsignedp0
&& unsignedp1
8906 && (TYPE_PRECISION (TREE_TYPE (op0
))
8907 < TYPE_PRECISION (result_type
))
8908 && (TYPE_PRECISION (TREE_TYPE (op1
))
8909 < TYPE_PRECISION (result_type
)))
8910 warning_at (location
, OPT_Wsign_compare
,
8911 "comparison of promoted ~unsigned with unsigned");
8915 #include "gt-c-common.h"