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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
35 #include "diagnostic.h"
40 #include "langhooks.h"
41 #include "tree-inline.h"
44 #include "tree-iterator.h"
46 #include "tree-mudflap.h"
50 #include "target-def.h"
52 #include "fixed-value.h"
54 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
56 /* We let tm.h override the types used here, to handle trivial differences
57 such as the choice of unsigned int or long unsigned int for size_t.
58 When machines start needing nontrivial differences in the size type,
59 it would be best to do something here to figure out automatically
60 from other information what type to use. */
63 #define SIZE_TYPE "long unsigned int"
67 #define PID_TYPE "int"
71 #define CHAR16_TYPE "short unsigned int"
75 #define CHAR32_TYPE "unsigned int"
79 #define WCHAR_TYPE "int"
82 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
83 #define MODIFIED_WCHAR_TYPE \
84 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
87 #define PTRDIFF_TYPE "long int"
91 #define WINT_TYPE "unsigned int"
95 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
97 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
103 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
105 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
106 ? "long unsigned int" \
107 : "long long unsigned int"))
110 /* The following symbols are subsumed in the c_global_trees array, and
111 listed here individually for documentation purposes.
113 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
115 tree short_integer_type_node;
116 tree long_integer_type_node;
117 tree long_long_integer_type_node;
119 tree short_unsigned_type_node;
120 tree long_unsigned_type_node;
121 tree long_long_unsigned_type_node;
123 tree truthvalue_type_node;
124 tree truthvalue_false_node;
125 tree truthvalue_true_node;
127 tree ptrdiff_type_node;
129 tree unsigned_char_type_node;
130 tree signed_char_type_node;
131 tree wchar_type_node;
132 tree signed_wchar_type_node;
133 tree unsigned_wchar_type_node;
135 tree char16_type_node;
136 tree char32_type_node;
138 tree float_type_node;
139 tree double_type_node;
140 tree long_double_type_node;
142 tree complex_integer_type_node;
143 tree complex_float_type_node;
144 tree complex_double_type_node;
145 tree complex_long_double_type_node;
147 tree dfloat32_type_node;
148 tree dfloat64_type_node;
149 tree_dfloat128_type_node;
151 tree intQI_type_node;
152 tree intHI_type_node;
153 tree intSI_type_node;
154 tree intDI_type_node;
155 tree intTI_type_node;
157 tree unsigned_intQI_type_node;
158 tree unsigned_intHI_type_node;
159 tree unsigned_intSI_type_node;
160 tree unsigned_intDI_type_node;
161 tree unsigned_intTI_type_node;
163 tree widest_integer_literal_type_node;
164 tree widest_unsigned_literal_type_node;
166 Nodes for types `void *' and `const void *'.
168 tree ptr_type_node, const_ptr_type_node;
170 Nodes for types `char *' and `const char *'.
172 tree string_type_node, const_string_type_node;
174 Type `char[SOMENUMBER]'.
175 Used when an array of char is needed and the size is irrelevant.
177 tree char_array_type_node;
179 Type `int[SOMENUMBER]' or something like it.
180 Used when an array of int needed and the size is irrelevant.
182 tree int_array_type_node;
184 Type `wchar_t[SOMENUMBER]' or something like it.
185 Used when a wide string literal is created.
187 tree wchar_array_type_node;
189 Type `char16_t[SOMENUMBER]' or something like it.
190 Used when a UTF-16 string literal is created.
192 tree char16_array_type_node;
194 Type `char32_t[SOMENUMBER]' or something like it.
195 Used when a UTF-32 string literal is created.
197 tree char32_array_type_node;
199 Type `int ()' -- used for implicit declaration of functions.
201 tree default_function_type;
203 A VOID_TYPE node, packaged in a TREE_LIST.
207 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
208 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
209 VAR_DECLS, but C++ does.)
211 tree function_name_decl_node;
212 tree pretty_function_name_decl_node;
213 tree c99_function_name_decl_node;
215 Stack of nested function name VAR_DECLs.
217 tree saved_function_name_decls;
221 tree c_global_trees
[CTI_MAX
];
223 /* Switches common to the C front ends. */
225 /* Nonzero if preprocessing only. */
227 int flag_preprocess_only
;
229 /* Nonzero means don't output line number information. */
231 char flag_no_line_commands
;
233 /* Nonzero causes -E output not to be done, but directives such as
234 #define that have side effects are still obeyed. */
238 /* Nonzero means dump macros in some fashion. */
240 char flag_dump_macros
;
242 /* Nonzero means pass #include lines through to the output. */
244 char flag_dump_includes
;
246 /* Nonzero means process PCH files while preprocessing. */
248 bool flag_pch_preprocess
;
250 /* The file name to which we should write a precompiled header, or
251 NULL if no header will be written in this compile. */
253 const char *pch_file
;
255 /* Nonzero if an ISO standard was selected. It rejects macros in the
259 /* Nonzero if -undef was given. It suppresses target built-in macros
263 /* Nonzero means don't recognize the non-ANSI builtin functions. */
267 /* Nonzero means don't recognize the non-ANSI builtin functions.
270 int flag_no_nonansi_builtin
;
272 /* Nonzero means give `double' the same size as `float'. */
274 int flag_short_double
;
276 /* Nonzero means give `wchar_t' the same size as `short'. */
278 int flag_short_wchar
;
280 /* Nonzero means allow implicit conversions between vectors with
281 differing numbers of subparts and/or differing element types. */
282 int flag_lax_vector_conversions
;
284 /* Nonzero means allow Microsoft extensions without warnings or errors. */
285 int flag_ms_extensions
;
287 /* Nonzero means don't recognize the keyword `asm'. */
291 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
293 int flag_signed_bitfields
= 1;
295 /* Warn about #pragma directives that are not recognized. */
297 int warn_unknown_pragmas
; /* Tri state variable. */
299 /* Warn about format/argument anomalies in calls to formatted I/O functions
300 (*printf, *scanf, strftime, strfmon, etc.). */
304 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
305 with GCC this doesn't matter as __null is guaranteed to have the right
308 int warn_strict_null_sentinel
;
310 /* Zero means that faster, ...NonNil variants of objc_msgSend...
311 calls will be used in ObjC; passing nil receivers to such calls
312 will most likely result in crashes. */
313 int flag_nil_receivers
= 1;
315 /* Nonzero means that code generation will be altered to support
316 "zero-link" execution. This currently affects ObjC only, but may
317 affect other languages in the future. */
318 int flag_zero_link
= 0;
320 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
321 unit. It will inform the ObjC runtime that class definition(s) herein
322 contained are to replace one(s) previously loaded. */
323 int flag_replace_objc_classes
= 0;
325 /* C/ObjC language option variables. */
328 /* Nonzero means allow type mismatches in conditional expressions;
329 just make their values `void'. */
331 int flag_cond_mismatch
;
333 /* Nonzero means enable C89 Amendment 1 features. */
337 /* Nonzero means use the ISO C99 dialect of C. */
341 /* Nonzero means that we have builtin functions, and main is an int. */
345 /* Warn if main is suspicious. */
350 /* ObjC language option variables. */
353 /* Open and close the file for outputting class declarations, if
356 int flag_gen_declaration
;
358 /* Tells the compiler that this is a special run. Do not perform any
359 compiling, instead we are to test some platform dependent features
360 and output a C header file with appropriate definitions. */
362 int print_struct_values
;
364 /* Tells the compiler what is the constant string class for ObjC. */
366 const char *constant_string_class_name
;
369 /* C++ language option variables. */
372 /* Nonzero means don't recognize any extension keywords. */
374 int flag_no_gnu_keywords
;
376 /* Nonzero means do emit exported implementations of functions even if
377 they can be inlined. */
379 int flag_implement_inlines
= 1;
381 /* Nonzero means that implicit instantiations will be emitted if needed. */
383 int flag_implicit_templates
= 1;
385 /* Nonzero means that implicit instantiations of inline templates will be
386 emitted if needed, even if instantiations of non-inline templates
389 int flag_implicit_inline_templates
= 1;
391 /* Nonzero means generate separate instantiation control files and
392 juggle them at link time. */
394 int flag_use_repository
;
396 /* Nonzero if we want to issue diagnostics that the standard says are not
399 int flag_optional_diags
= 1;
401 /* Nonzero means we should attempt to elide constructors when possible. */
403 int flag_elide_constructors
= 1;
405 /* Nonzero means that member functions defined in class scope are
406 inline by default. */
408 int flag_default_inline
= 1;
410 /* Controls whether compiler generates 'type descriptor' that give
411 run-time type information. */
415 /* Nonzero if we want to conserve space in the .o files. We do this
416 by putting uninitialized data and runtime initialized data into
417 .common instead of .data at the expense of not flagging multiple
420 int flag_conserve_space
;
422 /* Nonzero if we want to obey access control semantics. */
424 int flag_access_control
= 1;
426 /* Nonzero if we want to check the return value of new and avoid calling
427 constructors if it is a null pointer. */
431 /* The C++ dialect being used. C++98 is the default. */
433 enum cxx_dialect cxx_dialect
= cxx98
;
435 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
436 initialization variables.
437 0: Old rules, set by -fno-for-scope.
438 2: New ISO rules, set by -ffor-scope.
439 1: Try to implement new ISO rules, but with backup compatibility
440 (and warnings). This is the default, for now. */
442 int flag_new_for_scope
= 1;
444 /* Nonzero if we want to emit defined symbols with common-like linkage as
445 weak symbols where possible, in order to conform to C++ semantics.
446 Otherwise, emit them as local symbols. */
450 /* 0 means we want the preprocessor to not emit line directives for
451 the current working directory. 1 means we want it to do it. -1
452 means we should decide depending on whether debugging information
453 is being emitted or not. */
455 int flag_working_directory
= -1;
457 /* Nonzero to use __cxa_atexit, rather than atexit, to register
458 destructors for local statics and global objects. '2' means it has been
459 set nonzero as a default, not by a command-line flag. */
461 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
463 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
464 code. '2' means it has not been set explicitly on the command line. */
466 int flag_use_cxa_get_exception_ptr
= 2;
468 /* Nonzero means to implement standard semantics for exception
469 specifications, calling unexpected if an exception is thrown that
470 doesn't match the specification. Zero means to treat them as
471 assertions and optimize accordingly, but not check them. */
473 int flag_enforce_eh_specs
= 1;
475 /* Nonzero means to generate thread-safe code for initializing local
478 int flag_threadsafe_statics
= 1;
480 /* Nonzero means warn about implicit declarations. */
482 int warn_implicit
= 1;
484 /* Maximum template instantiation depth. This limit is rather
485 arbitrary, but it exists to limit the time it takes to notice
486 infinite template instantiations. */
488 int max_tinst_depth
= 500;
492 /* The elements of `ridpointers' are identifier nodes for the reserved
493 type names and storage classes. It is indexed by a RID_... value. */
496 tree (*make_fname_decl
) (tree
, int);
498 /* Nonzero means the expression being parsed will never be evaluated.
499 This is a count, since unevaluated expressions can nest. */
502 /* Information about how a function name is generated. */
505 tree
*const decl
; /* pointer to the VAR_DECL. */
506 const unsigned rid
; /* RID number for the identifier. */
507 const int pretty
; /* How pretty is it? */
510 /* The three ways of getting then name of the current function. */
512 const struct fname_var_t fname_vars
[] =
514 /* C99 compliant __func__, must be first. */
515 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
516 /* GCC __FUNCTION__ compliant. */
517 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
518 /* GCC __PRETTY_FUNCTION__ compliant. */
519 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
523 static tree
check_case_value (tree
);
524 static bool check_case_bounds (tree
, tree
, tree
*, tree
*);
526 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
527 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
528 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
529 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
530 static tree
handle_hot_attribute (tree
*, tree
, tree
, int, bool *);
531 static tree
handle_cold_attribute (tree
*, tree
, tree
, int, bool *);
532 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
533 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
535 static tree
handle_gnu_inline_attribute (tree
*, tree
, tree
, int, bool *);
536 static tree
handle_artificial_attribute (tree
*, tree
, tree
, int, bool *);
537 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
538 static tree
handle_error_attribute (tree
*, tree
, tree
, int, bool *);
539 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
540 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
541 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
543 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
544 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
546 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
547 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
548 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
549 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
550 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
551 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
552 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
553 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
554 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
556 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
558 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
560 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
561 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
562 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
564 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
565 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
566 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
568 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
570 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
571 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
572 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
573 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
575 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
576 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
577 static tree
handle_alloc_size_attribute (tree
*, tree
, tree
, int, bool *);
578 static tree
handle_option_attribute (tree
*, tree
, tree
, int, bool *);
579 static tree
handle_optimize_attribute (tree
*, tree
, tree
, int, bool *);
581 static void check_function_nonnull (tree
, int, tree
*);
582 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
583 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
584 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
585 static int resort_field_decl_cmp (const void *, const void *);
587 /* Reserved words. The third field is a mask: keywords are disabled
588 if they match the mask.
591 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
592 C --std=c99: D_CXXONLY | D_OBJC
593 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
594 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
595 C++ --std=c0x: D_CONLY | D_OBJC
596 ObjC++ is like C++ except that D_OBJC is not set
598 If -fno-asm is used, D_ASM is added to the mask. If
599 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
600 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
601 In C with -Wcxx-compat, we warn if D_CXXWARN is set. */
603 const struct c_common_resword c_common_reswords
[] =
605 { "_Bool", RID_BOOL
, D_CONLY
},
606 { "_Complex", RID_COMPLEX
, 0 },
607 { "_Decimal32", RID_DFLOAT32
, D_CONLY
| D_EXT
},
608 { "_Decimal64", RID_DFLOAT64
, D_CONLY
| D_EXT
},
609 { "_Decimal128", RID_DFLOAT128
, D_CONLY
| D_EXT
},
610 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
611 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
612 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
613 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
614 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
615 { "__alignof", RID_ALIGNOF
, 0 },
616 { "__alignof__", RID_ALIGNOF
, 0 },
617 { "__asm", RID_ASM
, 0 },
618 { "__asm__", RID_ASM
, 0 },
619 { "__attribute", RID_ATTRIBUTE
, 0 },
620 { "__attribute__", RID_ATTRIBUTE
, 0 },
621 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
622 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
623 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
624 { "__builtin_va_arg", RID_VA_ARG
, 0 },
625 { "__complex", RID_COMPLEX
, 0 },
626 { "__complex__", RID_COMPLEX
, 0 },
627 { "__const", RID_CONST
, 0 },
628 { "__const__", RID_CONST
, 0 },
629 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
630 { "__extension__", RID_EXTENSION
, 0 },
631 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
632 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
633 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
634 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
635 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
636 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
637 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
638 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
639 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
640 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
641 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
642 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
643 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO
, D_CXXONLY
},
644 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
645 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
646 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
647 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
648 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
649 { "__imag", RID_IMAGPART
, 0 },
650 { "__imag__", RID_IMAGPART
, 0 },
651 { "__inline", RID_INLINE
, 0 },
652 { "__inline__", RID_INLINE
, 0 },
653 { "__label__", RID_LABEL
, 0 },
654 { "__null", RID_NULL
, 0 },
655 { "__real", RID_REALPART
, 0 },
656 { "__real__", RID_REALPART
, 0 },
657 { "__restrict", RID_RESTRICT
, 0 },
658 { "__restrict__", RID_RESTRICT
, 0 },
659 { "__signed", RID_SIGNED
, 0 },
660 { "__signed__", RID_SIGNED
, 0 },
661 { "__thread", RID_THREAD
, 0 },
662 { "__typeof", RID_TYPEOF
, 0 },
663 { "__typeof__", RID_TYPEOF
, 0 },
664 { "__volatile", RID_VOLATILE
, 0 },
665 { "__volatile__", RID_VOLATILE
, 0 },
666 { "asm", RID_ASM
, D_ASM
},
667 { "auto", RID_AUTO
, 0 },
668 { "bool", RID_BOOL
, D_CXXONLY
},
669 { "break", RID_BREAK
, 0 },
670 { "case", RID_CASE
, 0 },
671 { "catch", RID_CATCH
, D_CXX_OBJC
},
672 { "char", RID_CHAR
, 0 },
673 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX0X
},
674 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX0X
},
675 { "class", RID_CLASS
, D_CXX_OBJC
},
676 { "const", RID_CONST
, 0 },
677 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
678 { "continue", RID_CONTINUE
, 0 },
679 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX0X
},
680 { "default", RID_DEFAULT
, 0 },
681 { "delete", RID_DELETE
, D_CXXONLY
},
683 { "double", RID_DOUBLE
, 0 },
684 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
685 { "else", RID_ELSE
, 0 },
686 { "enum", RID_ENUM
, 0 },
687 { "explicit", RID_EXPLICIT
, D_CXXONLY
},
688 { "export", RID_EXPORT
, D_CXXONLY
},
689 { "extern", RID_EXTERN
, 0 },
690 { "false", RID_FALSE
, D_CXXONLY
},
691 { "float", RID_FLOAT
, 0 },
692 { "for", RID_FOR
, 0 },
693 { "friend", RID_FRIEND
, D_CXXONLY
},
694 { "goto", RID_GOTO
, 0 },
696 { "inline", RID_INLINE
, D_EXT89
},
697 { "int", RID_INT
, 0 },
698 { "long", RID_LONG
, 0 },
699 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
700 { "namespace", RID_NAMESPACE
, D_CXXONLY
},
701 { "new", RID_NEW
, D_CXXONLY
},
702 { "operator", RID_OPERATOR
, D_CXXONLY
},
703 { "private", RID_PRIVATE
, D_CXX_OBJC
},
704 { "protected", RID_PROTECTED
, D_CXX_OBJC
},
705 { "public", RID_PUBLIC
, D_CXX_OBJC
},
706 { "register", RID_REGISTER
, 0 },
707 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
708 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
709 { "return", RID_RETURN
, 0 },
710 { "short", RID_SHORT
, 0 },
711 { "signed", RID_SIGNED
, 0 },
712 { "sizeof", RID_SIZEOF
, 0 },
713 { "static", RID_STATIC
, 0 },
714 { "static_assert", RID_STATIC_ASSERT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
715 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
716 { "struct", RID_STRUCT
, 0 },
717 { "switch", RID_SWITCH
, 0 },
718 { "template", RID_TEMPLATE
, D_CXXONLY
},
719 { "this", RID_THIS
, D_CXXONLY
},
720 { "throw", RID_THROW
, D_CXX_OBJC
},
721 { "true", RID_TRUE
, D_CXXONLY
},
722 { "try", RID_TRY
, D_CXX_OBJC
},
723 { "typedef", RID_TYPEDEF
, 0 },
724 { "typename", RID_TYPENAME
, D_CXXONLY
},
725 { "typeid", RID_TYPEID
, D_CXXONLY
},
726 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
727 { "union", RID_UNION
, 0 },
728 { "unsigned", RID_UNSIGNED
, 0 },
729 { "using", RID_USING
, D_CXXONLY
},
730 { "virtual", RID_VIRTUAL
, D_CXXONLY
},
731 { "void", RID_VOID
, 0 },
732 { "volatile", RID_VOLATILE
, 0 },
733 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
734 { "while", RID_WHILE
, 0 },
735 /* These Objective-C keywords are recognized only immediately after
737 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
738 { "defs", RID_AT_DEFS
, D_OBJC
},
739 { "encode", RID_AT_ENCODE
, D_OBJC
},
740 { "end", RID_AT_END
, D_OBJC
},
741 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
742 { "interface", RID_AT_INTERFACE
, D_OBJC
},
743 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
744 { "selector", RID_AT_SELECTOR
, D_OBJC
},
745 { "finally", RID_AT_FINALLY
, D_OBJC
},
746 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
747 /* These are recognized only in protocol-qualifier context
749 { "bycopy", RID_BYCOPY
, D_OBJC
},
750 { "byref", RID_BYREF
, D_OBJC
},
751 { "in", RID_IN
, D_OBJC
},
752 { "inout", RID_INOUT
, D_OBJC
},
753 { "oneway", RID_ONEWAY
, D_OBJC
},
754 { "out", RID_OUT
, D_OBJC
},
757 const unsigned int num_c_common_reswords
=
758 sizeof c_common_reswords
/ sizeof (struct c_common_resword
);
760 /* Table of machine-independent attributes common to all C-like languages. */
761 const struct attribute_spec c_common_attribute_table
[] =
763 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
764 { "packed", 0, 0, false, false, false,
765 handle_packed_attribute
},
766 { "nocommon", 0, 0, true, false, false,
767 handle_nocommon_attribute
},
768 { "common", 0, 0, true, false, false,
769 handle_common_attribute
},
770 /* FIXME: logically, noreturn attributes should be listed as
771 "false, true, true" and apply to function types. But implementing this
772 would require all the places in the compiler that use TREE_THIS_VOLATILE
773 on a decl to identify non-returning functions to be located and fixed
774 to check the function type instead. */
775 { "noreturn", 0, 0, true, false, false,
776 handle_noreturn_attribute
},
777 { "volatile", 0, 0, true, false, false,
778 handle_noreturn_attribute
},
779 { "noinline", 0, 0, true, false, false,
780 handle_noinline_attribute
},
781 { "always_inline", 0, 0, true, false, false,
782 handle_always_inline_attribute
},
783 { "gnu_inline", 0, 0, true, false, false,
784 handle_gnu_inline_attribute
},
785 { "artificial", 0, 0, true, false, false,
786 handle_artificial_attribute
},
787 { "flatten", 0, 0, true, false, false,
788 handle_flatten_attribute
},
789 { "used", 0, 0, true, false, false,
790 handle_used_attribute
},
791 { "unused", 0, 0, false, false, false,
792 handle_unused_attribute
},
793 { "externally_visible", 0, 0, true, false, false,
794 handle_externally_visible_attribute
},
795 /* The same comments as for noreturn attributes apply to const ones. */
796 { "const", 0, 0, true, false, false,
797 handle_const_attribute
},
798 { "transparent_union", 0, 0, false, false, false,
799 handle_transparent_union_attribute
},
800 { "constructor", 0, 1, true, false, false,
801 handle_constructor_attribute
},
802 { "destructor", 0, 1, true, false, false,
803 handle_destructor_attribute
},
804 { "mode", 1, 1, false, true, false,
805 handle_mode_attribute
},
806 { "section", 1, 1, true, false, false,
807 handle_section_attribute
},
808 { "aligned", 0, 1, false, false, false,
809 handle_aligned_attribute
},
810 { "weak", 0, 0, true, false, false,
811 handle_weak_attribute
},
812 { "alias", 1, 1, true, false, false,
813 handle_alias_attribute
},
814 { "weakref", 0, 1, true, false, false,
815 handle_weakref_attribute
},
816 { "no_instrument_function", 0, 0, true, false, false,
817 handle_no_instrument_function_attribute
},
818 { "malloc", 0, 0, true, false, false,
819 handle_malloc_attribute
},
820 { "returns_twice", 0, 0, true, false, false,
821 handle_returns_twice_attribute
},
822 { "no_stack_limit", 0, 0, true, false, false,
823 handle_no_limit_stack_attribute
},
824 { "pure", 0, 0, true, false, false,
825 handle_pure_attribute
},
826 /* For internal use (marking of builtins) only. The name contains space
827 to prevent its usage in source code. */
828 { "no vops", 0, 0, true, false, false,
829 handle_novops_attribute
},
830 { "deprecated", 0, 0, false, false, false,
831 handle_deprecated_attribute
},
832 { "vector_size", 1, 1, false, true, false,
833 handle_vector_size_attribute
},
834 { "visibility", 1, 1, false, false, false,
835 handle_visibility_attribute
},
836 { "tls_model", 1, 1, true, false, false,
837 handle_tls_model_attribute
},
838 { "nonnull", 0, -1, false, true, true,
839 handle_nonnull_attribute
},
840 { "nothrow", 0, 0, true, false, false,
841 handle_nothrow_attribute
},
842 { "may_alias", 0, 0, false, true, false, NULL
},
843 { "cleanup", 1, 1, true, false, false,
844 handle_cleanup_attribute
},
845 { "warn_unused_result", 0, 0, false, true, true,
846 handle_warn_unused_result_attribute
},
847 { "sentinel", 0, 1, false, true, true,
848 handle_sentinel_attribute
},
849 /* For internal use (marking of builtins) only. The name contains space
850 to prevent its usage in source code. */
851 { "type generic", 0, 0, false, true, true,
852 handle_type_generic_attribute
},
853 { "alloc_size", 1, 2, false, true, true,
854 handle_alloc_size_attribute
},
855 { "cold", 0, 0, true, false, false,
856 handle_cold_attribute
},
857 { "hot", 0, 0, true, false, false,
858 handle_hot_attribute
},
859 { "warning", 1, 1, true, false, false,
860 handle_error_attribute
},
861 { "error", 1, 1, true, false, false,
862 handle_error_attribute
},
863 { "option", 1, -1, true, false, false,
864 handle_option_attribute
},
865 { "optimize", 1, -1, true, false, false,
866 handle_optimize_attribute
},
867 { NULL
, 0, 0, false, false, false, NULL
}
870 /* Give the specifications for the format attributes, used by C and all
873 const struct attribute_spec c_common_format_attribute_table
[] =
875 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
876 { "format", 3, 3, false, true, true,
877 handle_format_attribute
},
878 { "format_arg", 1, 1, false, true, true,
879 handle_format_arg_attribute
},
880 { NULL
, 0, 0, false, false, false, NULL
}
883 /* Push current bindings for the function name VAR_DECLS. */
886 start_fname_decls (void)
889 tree saved
= NULL_TREE
;
891 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
893 tree decl
= *fname_vars
[ix
].decl
;
897 saved
= tree_cons (decl
, build_int_cst (NULL_TREE
, ix
), saved
);
898 *fname_vars
[ix
].decl
= NULL_TREE
;
901 if (saved
|| saved_function_name_decls
)
902 /* Normally they'll have been NULL, so only push if we've got a
903 stack, or they are non-NULL. */
904 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
905 saved_function_name_decls
);
908 /* Finish up the current bindings, adding them into the current function's
909 statement tree. This must be done _before_ finish_stmt_tree is called.
910 If there is no current function, we must be at file scope and no statements
911 are involved. Pop the previous bindings. */
914 finish_fname_decls (void)
917 tree stmts
= NULL_TREE
;
918 tree stack
= saved_function_name_decls
;
920 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
921 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
925 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
927 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
928 bodyp
= &BIND_EXPR_BODY (*bodyp
);
930 append_to_statement_list_force (*bodyp
, &stmts
);
934 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
935 *fname_vars
[ix
].decl
= NULL_TREE
;
939 /* We had saved values, restore them. */
942 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
944 tree decl
= TREE_PURPOSE (saved
);
945 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
947 *fname_vars
[ix
].decl
= decl
;
949 stack
= TREE_CHAIN (stack
);
951 saved_function_name_decls
= stack
;
954 /* Return the text name of the current function, suitably prettified
955 by PRETTY_P. Return string must be freed by caller. */
958 fname_as_string (int pretty_p
)
960 const char *name
= "top level";
963 cpp_string cstr
= { 0, 0 }, strname
;
971 if (current_function_decl
)
972 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
974 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
976 namep
= XNEWVEC (char, len
);
977 snprintf (namep
, len
, "\"%s\"", name
);
978 strname
.text
= (unsigned char *) namep
;
979 strname
.len
= len
- 1;
981 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
984 return (const char *) cstr
.text
;
990 /* Expand DECL if it declares an entity not handled by the
994 c_expand_decl (tree decl
)
996 if (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
))
998 /* Let the back-end know about this variable. */
999 if (!anon_aggr_type_p (TREE_TYPE (decl
)))
1000 emit_local_var (decl
);
1002 expand_anon_union_decl (decl
, NULL_TREE
,
1003 DECL_ANON_UNION_ELEMS (decl
));
1012 /* Return the VAR_DECL for a const char array naming the current
1013 function. If the VAR_DECL has not yet been created, create it
1014 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1015 ID is its name (unfortunately C and C++ hold the RID values of
1016 keywords in different places, so we can't derive RID from ID in
1017 this language independent code. */
1020 fname_decl (unsigned int rid
, tree id
)
1023 tree decl
= NULL_TREE
;
1025 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
1026 if (fname_vars
[ix
].rid
== rid
)
1029 decl
= *fname_vars
[ix
].decl
;
1032 /* If a tree is built here, it would normally have the lineno of
1033 the current statement. Later this tree will be moved to the
1034 beginning of the function and this line number will be wrong.
1035 To avoid this problem set the lineno to 0 here; that prevents
1036 it from appearing in the RTL. */
1038 location_t saved_location
= input_location
;
1039 input_location
= UNKNOWN_LOCATION
;
1041 stmts
= push_stmt_list ();
1042 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
1043 stmts
= pop_stmt_list (stmts
);
1044 if (!IS_EMPTY_STMT (stmts
))
1045 saved_function_name_decls
1046 = tree_cons (decl
, stmts
, saved_function_name_decls
);
1047 *fname_vars
[ix
].decl
= decl
;
1048 input_location
= saved_location
;
1050 if (!ix
&& !current_function_decl
)
1051 pedwarn (0, "%qD is not defined outside of function scope", decl
);
1056 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1059 fix_string_type (tree value
)
1061 int length
= TREE_STRING_LENGTH (value
);
1063 tree e_type
, i_type
, a_type
;
1065 /* Compute the number of elements, for the array type. */
1066 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
1069 e_type
= char_type_node
;
1071 else if (TREE_TYPE (value
) == char16_array_type_node
)
1073 nchars
= length
/ (TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
);
1074 e_type
= char16_type_node
;
1076 else if (TREE_TYPE (value
) == char32_array_type_node
)
1078 nchars
= length
/ (TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
);
1079 e_type
= char32_type_node
;
1083 nchars
= length
/ (TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
);
1084 e_type
= wchar_type_node
;
1087 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1088 limit in C++98 Annex B is very large (65536) and is not normative,
1089 so we do not diagnose it (warn_overlength_strings is forced off
1090 in c_common_post_options). */
1091 if (warn_overlength_strings
)
1093 const int nchars_max
= flag_isoc99
? 4095 : 509;
1094 const int relevant_std
= flag_isoc99
? 99 : 90;
1095 if (nchars
- 1 > nchars_max
)
1096 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1097 separate the %d from the 'C'. 'ISO' should not be
1098 translated, but it may be moved after 'C%d' in languages
1099 where modifiers follow nouns. */
1100 pedwarn (OPT_Woverlength_strings
,
1101 "string length %qd is greater than the length %qd "
1102 "ISO C%d compilers are required to support",
1103 nchars
- 1, nchars_max
, relevant_std
);
1106 /* Create the array type for the string constant. The ISO C++
1107 standard says that a string literal has type `const char[N]' or
1108 `const wchar_t[N]'. We use the same logic when invoked as a C
1109 front-end with -Wwrite-strings.
1110 ??? We should change the type of an expression depending on the
1111 state of a warning flag. We should just be warning -- see how
1112 this is handled in the C++ front-end for the deprecated implicit
1113 conversion from string literals to `char*' or `wchar_t*'.
1115 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1116 array type being the unqualified version of that type.
1117 Therefore, if we are constructing an array of const char, we must
1118 construct the matching unqualified array type first. The C front
1119 end does not require this, but it does no harm, so we do it
1121 i_type
= build_index_type (build_int_cst (NULL_TREE
, nchars
- 1));
1122 a_type
= build_array_type (e_type
, i_type
);
1123 if (c_dialect_cxx() || warn_write_strings
)
1124 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
1126 TREE_TYPE (value
) = a_type
;
1127 TREE_CONSTANT (value
) = 1;
1128 TREE_READONLY (value
) = 1;
1129 TREE_STATIC (value
) = 1;
1133 /* Print a warning if a constant expression had overflow in folding.
1134 Invoke this function on every expression that the language
1135 requires to be a constant expression.
1136 Note the ANSI C standard says it is erroneous for a
1137 constant expression to overflow. */
1140 constant_expression_warning (tree value
)
1142 if (warn_overflow
&& pedantic
1143 && (TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1144 || TREE_CODE (value
) == FIXED_CST
1145 || TREE_CODE (value
) == VECTOR_CST
1146 || TREE_CODE (value
) == COMPLEX_CST
)
1147 && TREE_OVERFLOW (value
))
1148 pedwarn (OPT_Woverflow
, "overflow in constant expression");
1151 /* The same as above but print an unconditional error. */
1153 constant_expression_error (tree value
)
1155 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1156 || TREE_CODE (value
) == FIXED_CST
1157 || TREE_CODE (value
) == VECTOR_CST
1158 || TREE_CODE (value
) == COMPLEX_CST
)
1159 && TREE_OVERFLOW (value
))
1160 error ("overflow in constant expression");
1163 /* Print a warning if an expression had overflow in folding and its
1166 Invoke this function on every expression that
1167 (1) appears in the source code, and
1168 (2) is a constant expression that overflowed, and
1169 (3) is not already checked by convert_and_check;
1170 however, do not invoke this function on operands of explicit casts
1171 or when the expression is the result of an operator and any operand
1172 already overflowed. */
1175 overflow_warning (tree value
)
1177 if (skip_evaluation
) return;
1179 switch (TREE_CODE (value
))
1182 warning (OPT_Woverflow
, "integer overflow in expression");
1186 warning (OPT_Woverflow
, "floating point overflow in expression");
1190 warning (OPT_Woverflow
, "fixed-point overflow in expression");
1194 warning (OPT_Woverflow
, "vector overflow in expression");
1198 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
1199 warning (OPT_Woverflow
, "complex integer overflow in expression");
1200 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
1201 warning (OPT_Woverflow
, "complex floating point overflow in expression");
1210 /* Warn about use of a logical || / && operator being used in a
1211 context where it is likely that the bitwise equivalent was intended
1212 by the programmer. CODE is the TREE_CODE of the operator, ARG1
1213 and ARG2 the arguments. */
1216 warn_logical_operator (enum tree_code code
, tree arg1
, tree
1221 case TRUTH_ANDIF_EXPR
:
1222 case TRUTH_ORIF_EXPR
:
1224 case TRUTH_AND_EXPR
:
1225 if (!TREE_NO_WARNING (arg1
)
1226 && INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
1227 && !CONSTANT_CLASS_P (arg1
)
1228 && TREE_CODE (arg2
) == INTEGER_CST
1229 && !integer_zerop (arg2
))
1231 warning (OPT_Wlogical_op
,
1232 "logical %<%s%> with non-zero constant "
1233 "will always evaluate as true",
1234 ((code
== TRUTH_ANDIF_EXPR
)
1235 || (code
== TRUTH_AND_EXPR
)) ? "&&" : "||");
1236 TREE_NO_WARNING (arg1
) = true;
1245 /* Print a warning about casts that might indicate violation
1246 of strict aliasing rules if -Wstrict-aliasing is used and
1247 strict aliasing mode is in effect. OTYPE is the original
1248 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1251 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
1253 if (!(flag_strict_aliasing
1254 && POINTER_TYPE_P (type
)
1255 && POINTER_TYPE_P (otype
)
1256 && !VOID_TYPE_P (TREE_TYPE (type
)))
1257 /* If the type we are casting to is a ref-all pointer
1258 dereferencing it is always valid. */
1259 || TYPE_REF_CAN_ALIAS_ALL (type
))
1262 if ((warn_strict_aliasing
> 1) && TREE_CODE (expr
) == ADDR_EXPR
1263 && (DECL_P (TREE_OPERAND (expr
, 0))
1264 || handled_component_p (TREE_OPERAND (expr
, 0))))
1266 /* Casting the address of an object to non void pointer. Warn
1267 if the cast breaks type based aliasing. */
1268 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)) && warn_strict_aliasing
== 2)
1270 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
1271 "might break strict-aliasing rules");
1276 /* warn_strict_aliasing >= 3. This includes the default (3).
1277 Only warn if the cast is dereferenced immediately. */
1278 alias_set_type set1
=
1279 get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1280 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1282 if (set1
!= set2
&& set2
!= 0
1283 && (set1
== 0 || !alias_sets_conflict_p (set1
, set2
)))
1285 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1286 "pointer will break strict-aliasing rules");
1289 else if (warn_strict_aliasing
== 2
1290 && !alias_sets_must_conflict_p (set1
, set2
))
1292 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1293 "pointer might break strict-aliasing rules");
1299 if ((warn_strict_aliasing
== 1) && !VOID_TYPE_P (TREE_TYPE (otype
)))
1301 /* At this level, warn for any conversions, even if an address is
1302 not taken in the same statement. This will likely produce many
1303 false positives, but could be useful to pinpoint problems that
1304 are not revealed at higher levels. */
1305 alias_set_type set1
= get_alias_set (TREE_TYPE (otype
));
1306 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1307 if (!COMPLETE_TYPE_P (type
)
1308 || !alias_sets_must_conflict_p (set1
, set2
))
1310 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1311 "pointer might break strict-aliasing rules");
1319 /* Print a warning about if (); or if () .. else; constructs
1320 via the special empty statement node that we create. INNER_THEN
1321 and INNER_ELSE are the statement lists of the if and the else
1325 empty_if_body_warning (tree inner_then
, tree inner_else
)
1327 if (TREE_CODE (inner_then
) == STATEMENT_LIST
1328 && STATEMENT_LIST_TAIL (inner_then
))
1329 inner_then
= STATEMENT_LIST_TAIL (inner_then
)->stmt
;
1331 if (inner_else
&& TREE_CODE (inner_else
) == STATEMENT_LIST
1332 && STATEMENT_LIST_TAIL (inner_else
))
1333 inner_else
= STATEMENT_LIST_TAIL (inner_else
)->stmt
;
1335 if (IS_EMPTY_STMT (inner_then
) && !inner_else
)
1336 warning (OPT_Wempty_body
, "%Hsuggest braces around empty body "
1337 "in an %<if%> statement", EXPR_LOCUS (inner_then
));
1339 else if (inner_else
&& IS_EMPTY_STMT (inner_else
))
1340 warning (OPT_Wempty_body
, "%Hsuggest braces around empty body "
1341 "in an %<else%> statement", EXPR_LOCUS (inner_else
));
1344 /* Warn for unlikely, improbable, or stupid DECL declarations
1348 check_main_parameter_types (tree decl
)
1353 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); args
;
1354 args
= TREE_CHAIN (args
))
1356 tree type
= args
? TREE_VALUE (args
) : 0;
1358 if (type
== void_type_node
|| type
== error_mark_node
)
1365 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
1366 pedwarn (0, "first argument of %q+D should be %<int%>", decl
);
1370 if (TREE_CODE (type
) != POINTER_TYPE
1371 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1372 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1374 pedwarn (0, "second argument of %q+D should be %<char **%>",
1379 if (TREE_CODE (type
) != POINTER_TYPE
1380 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1381 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1383 pedwarn (0, "third argument of %q+D should probably be "
1384 "%<char **%>", decl
);
1389 /* It is intentional that this message does not mention the third
1390 argument because it's only mentioned in an appendix of the
1392 if (argct
> 0 && (argct
< 2 || argct
> 3))
1393 pedwarn (0, "%q+D takes only zero or two arguments", decl
);
1396 /* True if pointers to distinct types T1 and T2 can be converted to
1397 each other without an explicit cast. Only returns true for opaque
1400 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
1402 if (TREE_CODE (t1
) == VECTOR_TYPE
&& TREE_CODE (t2
) == VECTOR_TYPE
1403 && (targetm
.vector_opaque_p (t1
) || targetm
.vector_opaque_p (t2
))
1404 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1410 /* True if vector types T1 and T2 can be converted to each other
1411 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1412 can only be converted with -flax-vector-conversions yet that is not
1413 in effect, emit a note telling the user about that option if such
1414 a note has not previously been emitted. */
1416 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
1418 static bool emitted_lax_note
= false;
1419 bool convertible_lax
;
1421 if ((targetm
.vector_opaque_p (t1
) || targetm
.vector_opaque_p (t2
))
1422 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1426 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1427 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
1428 TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
1429 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1430 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
1432 if (!convertible_lax
|| flag_lax_vector_conversions
)
1433 return convertible_lax
;
1435 if (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
1436 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1439 if (emit_lax_note
&& !emitted_lax_note
)
1441 emitted_lax_note
= true;
1442 inform ("use -flax-vector-conversions to permit "
1443 "conversions between vectors with differing "
1444 "element types or numbers of subparts");
1450 /* This is a helper function of build_binary_op.
1452 For certain operations if both args were extended from the same
1453 smaller type, do the arithmetic in that type and then extend.
1455 BITWISE indicates a bitwise operation.
1456 For them, this optimization is safe only if
1457 both args are zero-extended or both are sign-extended.
1458 Otherwise, we might change the result.
1459 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1460 but calculated in (unsigned short) it would be (unsigned short)-1.
1462 tree
shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
1464 int unsigned0
, unsigned1
;
1469 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1470 excessive narrowing when we call get_narrower below. For
1471 example, suppose that OP0 is of unsigned int extended
1472 from signed char and that RESULT_TYPE is long long int.
1473 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1476 (long long int) (unsigned int) signed_char
1478 which get_narrower would narrow down to
1480 (unsigned int) signed char
1482 If we do not cast OP0 first, get_narrower would return
1483 signed_char, which is inconsistent with the case of the
1485 op0
= convert (result_type
, op0
);
1486 op1
= convert (result_type
, op1
);
1488 arg0
= get_narrower (op0
, &unsigned0
);
1489 arg1
= get_narrower (op1
, &unsigned1
);
1491 /* UNS is 1 if the operation to be done is an unsigned one. */
1492 uns
= TYPE_UNSIGNED (result_type
);
1494 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1495 but it *requires* conversion to FINAL_TYPE. */
1497 if ((TYPE_PRECISION (TREE_TYPE (op0
))
1498 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1499 && TREE_TYPE (op0
) != result_type
)
1500 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1501 if ((TYPE_PRECISION (TREE_TYPE (op1
))
1502 == TYPE_PRECISION (TREE_TYPE (arg1
)))
1503 && TREE_TYPE (op1
) != result_type
)
1504 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1506 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1508 /* For bitwise operations, signedness of nominal type
1509 does not matter. Consider only how operands were extended. */
1513 /* Note that in all three cases below we refrain from optimizing
1514 an unsigned operation on sign-extended args.
1515 That would not be valid. */
1517 /* Both args variable: if both extended in same way
1518 from same width, do it in that width.
1519 Do it unsigned if args were zero-extended. */
1520 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
1521 < TYPE_PRECISION (result_type
))
1522 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1523 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1524 && unsigned0
== unsigned1
1525 && (unsigned0
|| !uns
))
1526 return c_common_signed_or_unsigned_type
1527 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
1529 else if (TREE_CODE (arg0
) == INTEGER_CST
1530 && (unsigned1
|| !uns
)
1531 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1532 < TYPE_PRECISION (result_type
))
1534 = c_common_signed_or_unsigned_type (unsigned1
,
1536 && !POINTER_TYPE_P (type
)
1537 && int_fits_type_p (arg0
, type
))
1540 else if (TREE_CODE (arg1
) == INTEGER_CST
1541 && (unsigned0
|| !uns
)
1542 && (TYPE_PRECISION (TREE_TYPE (arg0
))
1543 < TYPE_PRECISION (result_type
))
1545 = c_common_signed_or_unsigned_type (unsigned0
,
1547 && !POINTER_TYPE_P (type
)
1548 && int_fits_type_p (arg1
, type
))
1554 /* Warns if the conversion of EXPR to TYPE may alter a value.
1555 This is a helper function for warnings_for_convert_and_check. */
1558 conversion_warning (tree type
, tree expr
)
1560 bool give_warning
= false;
1562 unsigned int formal_prec
= TYPE_PRECISION (type
);
1564 if (!warn_conversion
&& !warn_sign_conversion
)
1567 if (TREE_CODE (expr
) == REAL_CST
|| TREE_CODE (expr
) == INTEGER_CST
)
1569 /* Warn for real constant that is not an exact integer converted
1571 if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1572 && TREE_CODE (type
) == INTEGER_TYPE
)
1574 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (TREE_TYPE (expr
))))
1575 give_warning
= true;
1577 /* Warn for an integer constant that does not fit into integer type. */
1578 else if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1579 && TREE_CODE (type
) == INTEGER_TYPE
1580 && !int_fits_type_p (expr
, type
))
1582 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (TREE_TYPE (expr
)))
1583 warning (OPT_Wsign_conversion
,
1584 "negative integer implicitly converted to unsigned type");
1585 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (TREE_TYPE (expr
)))
1586 warning (OPT_Wsign_conversion
,
1587 "conversion of unsigned constant value to negative integer");
1589 give_warning
= true;
1591 else if (TREE_CODE (type
) == REAL_TYPE
)
1593 /* Warn for an integer constant that does not fit into real type. */
1594 if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
)
1596 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
1597 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1598 give_warning
= true;
1600 /* Warn for a real constant that does not fit into a smaller
1602 else if (TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
1603 && formal_prec
< TYPE_PRECISION (TREE_TYPE (expr
)))
1605 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
1606 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
1607 give_warning
= true;
1612 warning (OPT_Wconversion
,
1613 "conversion to %qT alters %qT constant value",
1614 type
, TREE_TYPE (expr
));
1616 else /* 'expr' is not a constant. */
1618 tree expr_type
= TREE_TYPE (expr
);
1620 /* Warn for real types converted to integer types. */
1621 if (TREE_CODE (expr_type
) == REAL_TYPE
1622 && TREE_CODE (type
) == INTEGER_TYPE
)
1623 give_warning
= true;
1625 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1626 && TREE_CODE (type
) == INTEGER_TYPE
)
1628 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1629 expr
= get_unwidened (expr
, 0);
1630 expr_type
= TREE_TYPE (expr
);
1632 /* Don't warn for short y; short x = ((int)y & 0xff); */
1633 if (TREE_CODE (expr
) == BIT_AND_EXPR
1634 || TREE_CODE (expr
) == BIT_IOR_EXPR
1635 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
1637 /* It both args were extended from a shortest type, use
1638 that type if that is safe. */
1639 expr_type
= shorten_binary_op (expr_type
,
1640 TREE_OPERAND (expr
, 0),
1641 TREE_OPERAND (expr
, 1),
1644 /* If one of the operands is a non-negative constant
1645 that fits in the target type, then the type of the
1646 other operand does not matter. */
1647 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
1649 tree op0
= TREE_OPERAND (expr
, 0);
1650 tree op1
= TREE_OPERAND (expr
, 1);
1651 if ((TREE_CODE (op0
) == INTEGER_CST
1652 && int_fits_type_p (op0
, c_common_signed_type (type
))
1653 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
1654 || (TREE_CODE (op1
) == INTEGER_CST
1655 && int_fits_type_p (op1
, c_common_signed_type (type
))
1656 && int_fits_type_p (op1
, c_common_unsigned_type (type
))))
1660 /* Warn for integer types converted to smaller integer types. */
1661 if (formal_prec
< TYPE_PRECISION (expr_type
))
1662 give_warning
= true;
1664 /* When they are the same width but different signedness,
1665 then the value may change. */
1666 else if ((formal_prec
== TYPE_PRECISION (expr_type
)
1667 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
1668 /* Even when converted to a bigger type, if the type is
1669 unsigned but expr is signed, then negative values
1671 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
1672 warning (OPT_Wsign_conversion
,
1673 "conversion to %qT from %qT may change the sign of the result",
1677 /* Warn for integer types converted to real types if and only if
1678 all the range of values of the integer type cannot be
1679 represented by the real type. */
1680 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
1681 && TREE_CODE (type
) == REAL_TYPE
)
1683 tree type_low_bound
= TYPE_MIN_VALUE (expr_type
);
1684 tree type_high_bound
= TYPE_MAX_VALUE (expr_type
);
1685 REAL_VALUE_TYPE real_low_bound
= real_value_from_int_cst (0, type_low_bound
);
1686 REAL_VALUE_TYPE real_high_bound
= real_value_from_int_cst (0, type_high_bound
);
1688 if (!exact_real_truncate (TYPE_MODE (type
), &real_low_bound
)
1689 || !exact_real_truncate (TYPE_MODE (type
), &real_high_bound
))
1690 give_warning
= true;
1693 /* Warn for real types converted to smaller real types. */
1694 else if (TREE_CODE (expr_type
) == REAL_TYPE
1695 && TREE_CODE (type
) == REAL_TYPE
1696 && formal_prec
< TYPE_PRECISION (expr_type
))
1697 give_warning
= true;
1701 warning (OPT_Wconversion
,
1702 "conversion to %qT from %qT may alter its value",
1707 /* Produce warnings after a conversion. RESULT is the result of
1708 converting EXPR to TYPE. This is a helper function for
1709 convert_and_check and cp_convert_and_check. */
1712 warnings_for_convert_and_check (tree type
, tree expr
, tree result
)
1714 if (TREE_CODE (expr
) == INTEGER_CST
1715 && (TREE_CODE (type
) == INTEGER_TYPE
1716 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1717 && !int_fits_type_p (expr
, type
))
1719 /* Do not diagnose overflow in a constant expression merely
1720 because a conversion overflowed. */
1721 if (TREE_OVERFLOW (result
))
1722 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
1724 if (TYPE_UNSIGNED (type
))
1726 /* This detects cases like converting -129 or 256 to
1728 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
1729 warning (OPT_Woverflow
,
1730 "large integer implicitly truncated to unsigned type");
1732 conversion_warning (type
, expr
);
1734 else if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
1735 warning (OPT_Woverflow
,
1736 "overflow in implicit constant conversion");
1737 /* No warning for converting 0x80000000 to int. */
1739 && (TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
1740 || TYPE_PRECISION (TREE_TYPE (expr
))
1741 != TYPE_PRECISION (type
)))
1742 warning (OPT_Woverflow
,
1743 "overflow in implicit constant conversion");
1746 conversion_warning (type
, expr
);
1748 else if ((TREE_CODE (result
) == INTEGER_CST
1749 || TREE_CODE (result
) == FIXED_CST
) && TREE_OVERFLOW (result
))
1750 warning (OPT_Woverflow
,
1751 "overflow in implicit constant conversion");
1753 conversion_warning (type
, expr
);
1757 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1758 Invoke this function on every expression that is converted implicitly,
1759 i.e. because of language rules and not because of an explicit cast. */
1762 convert_and_check (tree type
, tree expr
)
1766 if (TREE_TYPE (expr
) == type
)
1769 result
= convert (type
, expr
);
1771 if (!skip_evaluation
&& !TREE_OVERFLOW_P (expr
) && result
!= error_mark_node
)
1772 warnings_for_convert_and_check (type
, expr
, result
);
1777 /* A node in a list that describes references to variables (EXPR), which are
1778 either read accesses if WRITER is zero, or write accesses, in which case
1779 WRITER is the parent of EXPR. */
1786 /* Used to implement a cache the results of a call to verify_tree. We only
1787 use this for SAVE_EXPRs. */
1790 struct tlist_cache
*next
;
1791 struct tlist
*cache_before_sp
;
1792 struct tlist
*cache_after_sp
;
1796 /* Obstack to use when allocating tlist structures, and corresponding
1798 static struct obstack tlist_obstack
;
1799 static char *tlist_firstobj
= 0;
1801 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1803 static struct tlist
*warned_ids
;
1804 /* SAVE_EXPRs need special treatment. We process them only once and then
1805 cache the results. */
1806 static struct tlist_cache
*save_expr_cache
;
1808 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
1809 static void merge_tlist (struct tlist
**, struct tlist
*, int);
1810 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
1811 static int warning_candidate_p (tree
);
1812 static void warn_for_collisions (struct tlist
*);
1813 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
1814 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
1816 /* Create a new struct tlist and fill in its fields. */
1817 static struct tlist
*
1818 new_tlist (struct tlist
*next
, tree t
, tree writer
)
1821 l
= XOBNEW (&tlist_obstack
, struct tlist
);
1828 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1829 is nonnull, we ignore any node we find which has a writer equal to it. */
1832 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
1836 struct tlist
*next
= add
->next
;
1839 if (!exclude_writer
|| add
->writer
!= exclude_writer
)
1840 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1845 /* Merge the nodes of ADD into TO. This merging process is done so that for
1846 each variable that already exists in TO, no new node is added; however if
1847 there is a write access recorded in ADD, and an occurrence on TO is only
1848 a read access, then the occurrence in TO will be modified to record the
1852 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
1854 struct tlist
**end
= to
;
1857 end
= &(*end
)->next
;
1863 struct tlist
*next
= add
->next
;
1865 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1866 if (tmp2
->expr
== add
->expr
)
1870 tmp2
->writer
= add
->writer
;
1874 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1875 end
= &(*end
)->next
;
1882 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1883 references in list LIST conflict with it, excluding reads if ONLY writers
1887 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
1892 /* Avoid duplicate warnings. */
1893 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1894 if (tmp
->expr
== written
)
1899 if (list
->expr
== written
1900 && list
->writer
!= writer
1901 && (!only_writes
|| list
->writer
)
1902 && DECL_NAME (list
->expr
))
1904 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1905 warning (OPT_Wsequence_point
, "operation on %qE may be undefined",
1912 /* Given a list LIST of references to variables, find whether any of these
1913 can cause conflicts due to missing sequence points. */
1916 warn_for_collisions (struct tlist
*list
)
1920 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1923 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1927 /* Return nonzero if X is a tree that can be verified by the sequence point
1930 warning_candidate_p (tree x
)
1932 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1935 /* Walk the tree X, and record accesses to variables. If X is written by the
1936 parent tree, WRITER is the parent.
1937 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1938 expression or its only operand forces a sequence point, then everything up
1939 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1941 Once we return, we will have emitted warnings if any subexpression before
1942 such a sequence point could be undefined. On a higher level, however, the
1943 sequence point may not be relevant, and we'll merge the two lists.
1945 Example: (b++, a) + b;
1946 The call that processes the COMPOUND_EXPR will store the increment of B
1947 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1948 processes the PLUS_EXPR will need to merge the two lists so that
1949 eventually, all accesses end up on the same list (and we'll warn about the
1950 unordered subexpressions b++ and b.
1952 A note on merging. If we modify the former example so that our expression
1955 care must be taken not simply to add all three expressions into the final
1956 PNO_SP list. The function merge_tlist takes care of that by merging the
1957 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1958 way, so that no more than one access to B is recorded. */
1961 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
1964 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1965 enum tree_code code
;
1966 enum tree_code_class cl
;
1968 /* X may be NULL if it is the operand of an empty statement expression
1974 code
= TREE_CODE (x
);
1975 cl
= TREE_CODE_CLASS (code
);
1977 if (warning_candidate_p (x
))
1979 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1989 case TRUTH_ANDIF_EXPR
:
1990 case TRUTH_ORIF_EXPR
:
1991 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1992 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1993 warn_for_collisions (tmp_nosp
);
1994 merge_tlist (pbefore_sp
, tmp_before
, 0);
1995 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1996 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1997 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2001 tmp_before
= tmp_list2
= 0;
2002 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
2003 warn_for_collisions (tmp_list2
);
2004 merge_tlist (pbefore_sp
, tmp_before
, 0);
2005 merge_tlist (pbefore_sp
, tmp_list2
, 1);
2007 tmp_list3
= tmp_nosp
= 0;
2008 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
2009 warn_for_collisions (tmp_nosp
);
2010 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2012 tmp_list3
= tmp_list2
= 0;
2013 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
2014 warn_for_collisions (tmp_list2
);
2015 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2016 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2017 two first, to avoid warning for (a ? b++ : b++). */
2018 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
2019 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2022 case PREDECREMENT_EXPR
:
2023 case PREINCREMENT_EXPR
:
2024 case POSTDECREMENT_EXPR
:
2025 case POSTINCREMENT_EXPR
:
2026 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
2030 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2031 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2032 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
2033 /* Expressions inside the LHS are not ordered wrt. the sequence points
2034 in the RHS. Example:
2036 Despite the fact that the modification of "a" is in the before_sp
2037 list (tmp_before), it conflicts with the use of "a" in the LHS.
2038 We can handle this by adding the contents of tmp_list3
2039 to those of tmp_before, and redoing the collision warnings for that
2041 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
2042 warn_for_collisions (tmp_before
);
2043 /* Exclude the LHS itself here; we first have to merge it into the
2044 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2045 didn't exclude the LHS, we'd get it twice, once as a read and once
2047 add_tlist (pno_sp
, tmp_list3
, x
, 0);
2048 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
2050 merge_tlist (pbefore_sp
, tmp_before
, 0);
2051 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
2052 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
2053 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
2057 /* We need to warn about conflicts among arguments and conflicts between
2058 args and the function address. Side effects of the function address,
2059 however, are not ordered by the sequence point of the call. */
2061 call_expr_arg_iterator iter
;
2063 tmp_before
= tmp_nosp
= 0;
2064 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2065 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
2067 tmp_list2
= tmp_list3
= 0;
2068 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
2069 merge_tlist (&tmp_list3
, tmp_list2
, 0);
2070 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
2072 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
2073 warn_for_collisions (tmp_before
);
2074 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
2079 /* Scan all the list, e.g. indices of multi dimensional array. */
2082 tmp_before
= tmp_nosp
= 0;
2083 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2084 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2085 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2092 struct tlist_cache
*t
;
2093 for (t
= save_expr_cache
; t
; t
= t
->next
)
2099 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
2100 t
->next
= save_expr_cache
;
2102 save_expr_cache
= t
;
2104 tmp_before
= tmp_nosp
= 0;
2105 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2106 warn_for_collisions (tmp_nosp
);
2111 struct tlist
*t
= tmp_nosp
;
2113 merge_tlist (&tmp_list3
, t
, 0);
2115 t
->cache_before_sp
= tmp_before
;
2116 t
->cache_after_sp
= tmp_list3
;
2118 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
2119 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
2124 /* For other expressions, simply recurse on their operands.
2125 Manual tail recursion for unary expressions.
2126 Other non-expressions need not be processed. */
2127 if (cl
== tcc_unary
)
2129 x
= TREE_OPERAND (x
, 0);
2133 else if (IS_EXPR_CODE_CLASS (cl
))
2136 int max
= TREE_OPERAND_LENGTH (x
);
2137 for (lp
= 0; lp
< max
; lp
++)
2139 tmp_before
= tmp_nosp
= 0;
2140 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
2141 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2142 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2149 /* Try to warn for undefined behavior in EXPR due to missing sequence
2153 verify_sequence_points (tree expr
)
2155 struct tlist
*before_sp
= 0, *after_sp
= 0;
2158 save_expr_cache
= 0;
2159 if (tlist_firstobj
== 0)
2161 gcc_obstack_init (&tlist_obstack
);
2162 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
2165 verify_tree (expr
, &before_sp
, &after_sp
, 0);
2166 warn_for_collisions (after_sp
);
2167 obstack_free (&tlist_obstack
, tlist_firstobj
);
2170 /* Validate the expression after `case' and apply default promotions. */
2173 check_case_value (tree value
)
2175 if (value
== NULL_TREE
)
2178 /* ??? Can we ever get nops here for a valid case value? We
2180 STRIP_TYPE_NOPS (value
);
2181 /* In C++, the following is allowed:
2184 switch (...) { case i: ... }
2186 So, we try to reduce the VALUE to a constant that way. */
2187 if (c_dialect_cxx ())
2189 value
= decl_constant_value (value
);
2190 STRIP_TYPE_NOPS (value
);
2191 value
= fold (value
);
2194 if (TREE_CODE (value
) == INTEGER_CST
)
2195 /* Promote char or short to int. */
2196 value
= perform_integral_promotions (value
);
2197 else if (value
!= error_mark_node
)
2199 error ("case label does not reduce to an integer constant");
2200 value
= error_mark_node
;
2203 constant_expression_warning (value
);
2208 /* See if the case values LOW and HIGH are in the range of the original
2209 type (i.e. before the default conversion to int) of the switch testing
2211 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2212 the type before promoting it. CASE_LOW_P is a pointer to the lower
2213 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2214 if the case is not a case range.
2215 The caller has to make sure that we are not called with NULL for
2216 CASE_LOW_P (i.e. the default case).
2217 Returns true if the case label is in range of ORIG_TYPE (saturated or
2218 untouched) or false if the label is out of range. */
2221 check_case_bounds (tree type
, tree orig_type
,
2222 tree
*case_low_p
, tree
*case_high_p
)
2224 tree min_value
, max_value
;
2225 tree case_low
= *case_low_p
;
2226 tree case_high
= case_high_p
? *case_high_p
: case_low
;
2228 /* If there was a problem with the original type, do nothing. */
2229 if (orig_type
== error_mark_node
)
2232 min_value
= TYPE_MIN_VALUE (orig_type
);
2233 max_value
= TYPE_MAX_VALUE (orig_type
);
2235 /* Case label is less than minimum for type. */
2236 if (tree_int_cst_compare (case_low
, min_value
) < 0
2237 && tree_int_cst_compare (case_high
, min_value
) < 0)
2239 warning (0, "case label value is less than minimum value for type");
2243 /* Case value is greater than maximum for type. */
2244 if (tree_int_cst_compare (case_low
, max_value
) > 0
2245 && tree_int_cst_compare (case_high
, max_value
) > 0)
2247 warning (0, "case label value exceeds maximum value for type");
2251 /* Saturate lower case label value to minimum. */
2252 if (tree_int_cst_compare (case_high
, min_value
) >= 0
2253 && tree_int_cst_compare (case_low
, min_value
) < 0)
2255 warning (0, "lower value in case label range"
2256 " less than minimum value for type");
2257 case_low
= min_value
;
2260 /* Saturate upper case label value to maximum. */
2261 if (tree_int_cst_compare (case_low
, max_value
) <= 0
2262 && tree_int_cst_compare (case_high
, max_value
) > 0)
2264 warning (0, "upper value in case label range"
2265 " exceeds maximum value for type");
2266 case_high
= max_value
;
2269 if (*case_low_p
!= case_low
)
2270 *case_low_p
= convert (type
, case_low
);
2271 if (case_high_p
&& *case_high_p
!= case_high
)
2272 *case_high_p
= convert (type
, case_high
);
2277 /* Return an integer type with BITS bits of precision,
2278 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2281 c_common_type_for_size (unsigned int bits
, int unsignedp
)
2283 if (bits
== TYPE_PRECISION (integer_type_node
))
2284 return unsignedp
? unsigned_type_node
: integer_type_node
;
2286 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2287 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2289 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2290 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2292 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2293 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2295 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2296 return (unsignedp
? long_long_unsigned_type_node
2297 : long_long_integer_type_node
);
2299 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2300 return (unsignedp
? widest_unsigned_literal_type_node
2301 : widest_integer_literal_type_node
);
2303 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2304 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2306 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2307 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2309 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2310 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2312 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2313 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2318 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2319 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2320 and saturating if SATP is nonzero, otherwise not saturating. */
2323 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
2324 int unsignedp
, int satp
)
2326 enum machine_mode mode
;
2328 mode
= unsignedp
? UQQmode
: QQmode
;
2330 mode
= unsignedp
? UHAmode
: HAmode
;
2332 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
2333 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2336 if (mode
== VOIDmode
|| !targetm
.scalar_mode_supported_p (mode
))
2338 sorry ("GCC cannot support operators with integer types and "
2339 "fixed-point types that have too many integral and "
2340 "fractional bits together");
2344 return c_common_type_for_mode (mode
, satp
);
2347 /* Used for communication between c_common_type_for_mode and
2348 c_register_builtin_type. */
2349 static GTY(()) tree registered_builtin_types
;
2351 /* Return a data type that has machine mode MODE.
2352 If the mode is an integer,
2353 then UNSIGNEDP selects between signed and unsigned types.
2354 If the mode is a fixed-point mode,
2355 then UNSIGNEDP selects between saturating and nonsaturating types. */
2358 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
2362 if (mode
== TYPE_MODE (integer_type_node
))
2363 return unsignedp
? unsigned_type_node
: integer_type_node
;
2365 if (mode
== TYPE_MODE (signed_char_type_node
))
2366 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2368 if (mode
== TYPE_MODE (short_integer_type_node
))
2369 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2371 if (mode
== TYPE_MODE (long_integer_type_node
))
2372 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2374 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2375 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2377 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2378 return unsignedp
? widest_unsigned_literal_type_node
2379 : widest_integer_literal_type_node
;
2382 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2385 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2388 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2391 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2393 #if HOST_BITS_PER_WIDE_INT >= 64
2394 if (mode
== TYPE_MODE (intTI_type_node
))
2395 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2398 if (mode
== TYPE_MODE (float_type_node
))
2399 return float_type_node
;
2401 if (mode
== TYPE_MODE (double_type_node
))
2402 return double_type_node
;
2404 if (mode
== TYPE_MODE (long_double_type_node
))
2405 return long_double_type_node
;
2407 if (mode
== TYPE_MODE (void_type_node
))
2408 return void_type_node
;
2410 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2412 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2413 : make_signed_type (GET_MODE_PRECISION (mode
)));
2415 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2417 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2418 : make_signed_type (GET_MODE_PRECISION (mode
)));
2420 if (COMPLEX_MODE_P (mode
))
2422 enum machine_mode inner_mode
;
2425 if (mode
== TYPE_MODE (complex_float_type_node
))
2426 return complex_float_type_node
;
2427 if (mode
== TYPE_MODE (complex_double_type_node
))
2428 return complex_double_type_node
;
2429 if (mode
== TYPE_MODE (complex_long_double_type_node
))
2430 return complex_long_double_type_node
;
2432 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
2433 return complex_integer_type_node
;
2435 inner_mode
= GET_MODE_INNER (mode
);
2436 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2437 if (inner_type
!= NULL_TREE
)
2438 return build_complex_type (inner_type
);
2440 else if (VECTOR_MODE_P (mode
))
2442 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
2443 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2444 if (inner_type
!= NULL_TREE
)
2445 return build_vector_type_for_mode (inner_type
, mode
);
2448 if (mode
== TYPE_MODE (dfloat32_type_node
))
2449 return dfloat32_type_node
;
2450 if (mode
== TYPE_MODE (dfloat64_type_node
))
2451 return dfloat64_type_node
;
2452 if (mode
== TYPE_MODE (dfloat128_type_node
))
2453 return dfloat128_type_node
;
2455 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
2457 if (mode
== TYPE_MODE (short_fract_type_node
))
2458 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
2459 if (mode
== TYPE_MODE (fract_type_node
))
2460 return unsignedp
? sat_fract_type_node
: fract_type_node
;
2461 if (mode
== TYPE_MODE (long_fract_type_node
))
2462 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
2463 if (mode
== TYPE_MODE (long_long_fract_type_node
))
2464 return unsignedp
? sat_long_long_fract_type_node
2465 : long_long_fract_type_node
;
2467 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
2468 return unsignedp
? sat_unsigned_short_fract_type_node
2469 : unsigned_short_fract_type_node
;
2470 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
2471 return unsignedp
? sat_unsigned_fract_type_node
2472 : unsigned_fract_type_node
;
2473 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
2474 return unsignedp
? sat_unsigned_long_fract_type_node
2475 : unsigned_long_fract_type_node
;
2476 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
2477 return unsignedp
? sat_unsigned_long_long_fract_type_node
2478 : unsigned_long_long_fract_type_node
;
2480 if (mode
== TYPE_MODE (short_accum_type_node
))
2481 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
2482 if (mode
== TYPE_MODE (accum_type_node
))
2483 return unsignedp
? sat_accum_type_node
: accum_type_node
;
2484 if (mode
== TYPE_MODE (long_accum_type_node
))
2485 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
2486 if (mode
== TYPE_MODE (long_long_accum_type_node
))
2487 return unsignedp
? sat_long_long_accum_type_node
2488 : long_long_accum_type_node
;
2490 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
2491 return unsignedp
? sat_unsigned_short_accum_type_node
2492 : unsigned_short_accum_type_node
;
2493 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
2494 return unsignedp
? sat_unsigned_accum_type_node
2495 : unsigned_accum_type_node
;
2496 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
2497 return unsignedp
? sat_unsigned_long_accum_type_node
2498 : unsigned_long_accum_type_node
;
2499 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
2500 return unsignedp
? sat_unsigned_long_long_accum_type_node
2501 : unsigned_long_long_accum_type_node
;
2504 return unsignedp
? sat_qq_type_node
: qq_type_node
;
2506 return unsignedp
? sat_hq_type_node
: hq_type_node
;
2508 return unsignedp
? sat_sq_type_node
: sq_type_node
;
2510 return unsignedp
? sat_dq_type_node
: dq_type_node
;
2512 return unsignedp
? sat_tq_type_node
: tq_type_node
;
2514 if (mode
== UQQmode
)
2515 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
2516 if (mode
== UHQmode
)
2517 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
2518 if (mode
== USQmode
)
2519 return unsignedp
? sat_usq_type_node
: usq_type_node
;
2520 if (mode
== UDQmode
)
2521 return unsignedp
? sat_udq_type_node
: udq_type_node
;
2522 if (mode
== UTQmode
)
2523 return unsignedp
? sat_utq_type_node
: utq_type_node
;
2526 return unsignedp
? sat_ha_type_node
: ha_type_node
;
2528 return unsignedp
? sat_sa_type_node
: sa_type_node
;
2530 return unsignedp
? sat_da_type_node
: da_type_node
;
2532 return unsignedp
? sat_ta_type_node
: ta_type_node
;
2534 if (mode
== UHAmode
)
2535 return unsignedp
? sat_uha_type_node
: uha_type_node
;
2536 if (mode
== USAmode
)
2537 return unsignedp
? sat_usa_type_node
: usa_type_node
;
2538 if (mode
== UDAmode
)
2539 return unsignedp
? sat_uda_type_node
: uda_type_node
;
2540 if (mode
== UTAmode
)
2541 return unsignedp
? sat_uta_type_node
: uta_type_node
;
2544 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
2545 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
2546 return TREE_VALUE (t
);
2552 c_common_unsigned_type (tree type
)
2554 return c_common_signed_or_unsigned_type (1, type
);
2557 /* Return a signed type the same as TYPE in other respects. */
2560 c_common_signed_type (tree type
)
2562 return c_common_signed_or_unsigned_type (0, type
);
2565 /* Return a type the same as TYPE except unsigned or
2566 signed according to UNSIGNEDP. */
2569 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
2573 /* This block of code emulates the behavior of the old
2574 c_common_unsigned_type. In particular, it returns
2575 long_unsigned_type_node if passed a long, even when a int would
2576 have the same size. This is necessary for warnings to work
2577 correctly in archs where sizeof(int) == sizeof(long) */
2579 type1
= TYPE_MAIN_VARIANT (type
);
2580 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
2581 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2582 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
2583 return unsignedp
? unsigned_type_node
: integer_type_node
;
2584 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
2585 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2586 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
2587 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2588 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
2589 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2590 if (type1
== widest_integer_literal_type_node
|| type1
== widest_unsigned_literal_type_node
)
2591 return unsignedp
? widest_unsigned_literal_type_node
: widest_integer_literal_type_node
;
2592 #if HOST_BITS_PER_WIDE_INT >= 64
2593 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
2594 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2596 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
2597 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2598 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
2599 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2600 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
2601 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2602 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
2603 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2605 #define C_COMMON_FIXED_TYPES(NAME) \
2606 if (type1 == short_ ## NAME ## _type_node \
2607 || type1 == unsigned_short_ ## NAME ## _type_node) \
2608 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2609 : short_ ## NAME ## _type_node; \
2610 if (type1 == NAME ## _type_node \
2611 || type1 == unsigned_ ## NAME ## _type_node) \
2612 return unsignedp ? unsigned_ ## NAME ## _type_node \
2613 : NAME ## _type_node; \
2614 if (type1 == long_ ## NAME ## _type_node \
2615 || type1 == unsigned_long_ ## NAME ## _type_node) \
2616 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2617 : long_ ## NAME ## _type_node; \
2618 if (type1 == long_long_ ## NAME ## _type_node \
2619 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2620 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2621 : long_long_ ## NAME ## _type_node;
2623 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
2624 if (type1 == NAME ## _type_node \
2625 || type1 == u ## NAME ## _type_node) \
2626 return unsignedp ? u ## NAME ## _type_node \
2627 : NAME ## _type_node;
2629 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
2630 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2631 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2632 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2633 : sat_ ## short_ ## NAME ## _type_node; \
2634 if (type1 == sat_ ## NAME ## _type_node \
2635 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2636 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2637 : sat_ ## NAME ## _type_node; \
2638 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2639 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2640 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2641 : sat_ ## long_ ## NAME ## _type_node; \
2642 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2643 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2644 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2645 : sat_ ## long_long_ ## NAME ## _type_node;
2647 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
2648 if (type1 == sat_ ## NAME ## _type_node \
2649 || type1 == sat_ ## u ## NAME ## _type_node) \
2650 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2651 : sat_ ## NAME ## _type_node;
2653 C_COMMON_FIXED_TYPES (fract
);
2654 C_COMMON_FIXED_TYPES_SAT (fract
);
2655 C_COMMON_FIXED_TYPES (accum
);
2656 C_COMMON_FIXED_TYPES_SAT (accum
);
2658 C_COMMON_FIXED_MODE_TYPES (qq
);
2659 C_COMMON_FIXED_MODE_TYPES (hq
);
2660 C_COMMON_FIXED_MODE_TYPES (sq
);
2661 C_COMMON_FIXED_MODE_TYPES (dq
);
2662 C_COMMON_FIXED_MODE_TYPES (tq
);
2663 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
2664 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
2665 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
2666 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
2667 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
2668 C_COMMON_FIXED_MODE_TYPES (ha
);
2669 C_COMMON_FIXED_MODE_TYPES (sa
);
2670 C_COMMON_FIXED_MODE_TYPES (da
);
2671 C_COMMON_FIXED_MODE_TYPES (ta
);
2672 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
2673 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
2674 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
2675 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
2677 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2678 the precision; they have precision set to match their range, but
2679 may use a wider mode to match an ABI. If we change modes, we may
2680 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2681 the precision as well, so as to yield correct results for
2682 bit-field types. C++ does not have these separate bit-field
2683 types, and producing a signed or unsigned variant of an
2684 ENUMERAL_TYPE may cause other problems as well. */
2686 if (!INTEGRAL_TYPE_P (type
)
2687 || TYPE_UNSIGNED (type
) == unsignedp
)
2690 #define TYPE_OK(node) \
2691 (TYPE_MODE (type) == TYPE_MODE (node) \
2692 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
2693 if (TYPE_OK (signed_char_type_node
))
2694 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2695 if (TYPE_OK (integer_type_node
))
2696 return unsignedp
? unsigned_type_node
: integer_type_node
;
2697 if (TYPE_OK (short_integer_type_node
))
2698 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2699 if (TYPE_OK (long_integer_type_node
))
2700 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2701 if (TYPE_OK (long_long_integer_type_node
))
2702 return (unsignedp
? long_long_unsigned_type_node
2703 : long_long_integer_type_node
);
2704 if (TYPE_OK (widest_integer_literal_type_node
))
2705 return (unsignedp
? widest_unsigned_literal_type_node
2706 : widest_integer_literal_type_node
);
2708 #if HOST_BITS_PER_WIDE_INT >= 64
2709 if (TYPE_OK (intTI_type_node
))
2710 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2712 if (TYPE_OK (intDI_type_node
))
2713 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2714 if (TYPE_OK (intSI_type_node
))
2715 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2716 if (TYPE_OK (intHI_type_node
))
2717 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2718 if (TYPE_OK (intQI_type_node
))
2719 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2722 if (c_dialect_cxx ())
2725 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
2728 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2731 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
2733 /* Extended integer types of the same width as a standard type have
2734 lesser rank, so those of the same width as int promote to int or
2735 unsigned int and are valid for printf formats expecting int or
2736 unsigned int. To avoid such special cases, avoid creating
2737 extended integer types for bit-fields if a standard integer type
2739 if (width
== TYPE_PRECISION (integer_type_node
))
2740 return unsignedp
? unsigned_type_node
: integer_type_node
;
2741 if (width
== TYPE_PRECISION (signed_char_type_node
))
2742 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2743 if (width
== TYPE_PRECISION (short_integer_type_node
))
2744 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2745 if (width
== TYPE_PRECISION (long_integer_type_node
))
2746 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2747 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
2748 return (unsignedp
? long_long_unsigned_type_node
2749 : long_long_integer_type_node
);
2750 return build_nonstandard_integer_type (width
, unsignedp
);
2753 /* The C version of the register_builtin_type langhook. */
2756 c_register_builtin_type (tree type
, const char* name
)
2760 decl
= build_decl (TYPE_DECL
, get_identifier (name
), type
);
2761 DECL_ARTIFICIAL (decl
) = 1;
2762 if (!TYPE_NAME (type
))
2763 TYPE_NAME (type
) = decl
;
2766 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
2770 /* Return the minimum number of bits needed to represent VALUE in a
2771 signed or unsigned type, UNSIGNEDP says which. */
2774 min_precision (tree value
, int unsignedp
)
2778 /* If the value is negative, compute its negative minus 1. The latter
2779 adjustment is because the absolute value of the largest negative value
2780 is one larger than the largest positive value. This is equivalent to
2781 a bit-wise negation, so use that operation instead. */
2783 if (tree_int_cst_sgn (value
) < 0)
2784 value
= fold_build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
);
2786 /* Return the number of bits needed, taking into account the fact
2787 that we need one more bit for a signed than unsigned type. */
2789 if (integer_zerop (value
))
2792 log
= tree_floor_log2 (value
);
2794 return log
+ 1 + !unsignedp
;
2797 /* Print an error message for invalid operands to arith operation
2798 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */
2801 binary_op_error (enum tree_code code
, tree type0
, tree type1
)
2808 opname
= "+"; break;
2810 opname
= "-"; break;
2812 opname
= "*"; break;
2814 opname
= "max"; break;
2816 opname
= "min"; break;
2818 opname
= "=="; break;
2820 opname
= "!="; break;
2822 opname
= "<="; break;
2824 opname
= ">="; break;
2826 opname
= "<"; break;
2828 opname
= ">"; break;
2830 opname
= "<<"; break;
2832 opname
= ">>"; break;
2833 case TRUNC_MOD_EXPR
:
2834 case FLOOR_MOD_EXPR
:
2835 opname
= "%"; break;
2836 case TRUNC_DIV_EXPR
:
2837 case FLOOR_DIV_EXPR
:
2838 opname
= "/"; break;
2840 opname
= "&"; break;
2842 opname
= "|"; break;
2843 case TRUTH_ANDIF_EXPR
:
2844 opname
= "&&"; break;
2845 case TRUTH_ORIF_EXPR
:
2846 opname
= "||"; break;
2848 opname
= "^"; break;
2852 error ("invalid operands to binary %s (have %qT and %qT)", opname
,
2856 /* Subroutine of build_binary_op, used for comparison operations.
2857 See if the operands have both been converted from subword integer types
2858 and, if so, perhaps change them both back to their original type.
2859 This function is also responsible for converting the two operands
2860 to the proper common type for comparison.
2862 The arguments of this function are all pointers to local variables
2863 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2864 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2866 If this function returns nonzero, it means that the comparison has
2867 a constant value. What this function returns is an expression for
2871 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
2872 enum tree_code
*rescode_ptr
)
2875 tree op0
= *op0_ptr
;
2876 tree op1
= *op1_ptr
;
2877 int unsignedp0
, unsignedp1
;
2879 tree primop0
, primop1
;
2880 enum tree_code code
= *rescode_ptr
;
2882 /* Throw away any conversions to wider types
2883 already present in the operands. */
2885 primop0
= get_narrower (op0
, &unsignedp0
);
2886 primop1
= get_narrower (op1
, &unsignedp1
);
2888 /* Handle the case that OP0 does not *contain* a conversion
2889 but it *requires* conversion to FINAL_TYPE. */
2891 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2892 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2893 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2894 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2896 /* If one of the operands must be floated, we cannot optimize. */
2897 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2898 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2900 /* If first arg is constant, swap the args (changing operation
2901 so value is preserved), for canonicalization. Don't do this if
2902 the second arg is 0. */
2904 if (TREE_CONSTANT (primop0
)
2905 && !integer_zerop (primop1
) && !real_zerop (primop1
)
2906 && !fixed_zerop (primop1
))
2909 int temi
= unsignedp0
;
2917 unsignedp0
= unsignedp1
;
2940 *rescode_ptr
= code
;
2943 /* If comparing an integer against a constant more bits wide,
2944 maybe we can deduce a value of 1 or 0 independent of the data.
2945 Or else truncate the constant now
2946 rather than extend the variable at run time.
2948 This is only interesting if the constant is the wider arg.
2949 Also, it is not safe if the constant is unsigned and the
2950 variable arg is signed, since in this case the variable
2951 would be sign-extended and then regarded as unsigned.
2952 Our technique fails in this case because the lowest/highest
2953 possible unsigned results don't follow naturally from the
2954 lowest/highest possible values of the variable operand.
2955 For just EQ_EXPR and NE_EXPR there is another technique that
2956 could be used: see if the constant can be faithfully represented
2957 in the other operand's type, by truncating it and reextending it
2958 and see if that preserves the constant's value. */
2960 if (!real1
&& !real2
2961 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
2962 && TREE_CODE (primop1
) == INTEGER_CST
2963 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2965 int min_gt
, max_gt
, min_lt
, max_lt
;
2966 tree maxval
, minval
;
2967 /* 1 if comparison is nominally unsigned. */
2968 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
2971 type
= c_common_signed_or_unsigned_type (unsignedp0
,
2972 TREE_TYPE (primop0
));
2974 maxval
= TYPE_MAX_VALUE (type
);
2975 minval
= TYPE_MIN_VALUE (type
);
2977 if (unsignedp
&& !unsignedp0
)
2978 *restype_ptr
= c_common_signed_type (*restype_ptr
);
2980 if (TREE_TYPE (primop1
) != *restype_ptr
)
2982 /* Convert primop1 to target type, but do not introduce
2983 additional overflow. We know primop1 is an int_cst. */
2984 primop1
= force_fit_type_double (*restype_ptr
,
2985 TREE_INT_CST_LOW (primop1
),
2986 TREE_INT_CST_HIGH (primop1
), 0,
2987 TREE_OVERFLOW (primop1
));
2989 if (type
!= *restype_ptr
)
2991 minval
= convert (*restype_ptr
, minval
);
2992 maxval
= convert (*restype_ptr
, maxval
);
2995 if (unsignedp
&& unsignedp0
)
2997 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2998 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2999 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
3000 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
3004 min_gt
= INT_CST_LT (primop1
, minval
);
3005 max_gt
= INT_CST_LT (primop1
, maxval
);
3006 min_lt
= INT_CST_LT (minval
, primop1
);
3007 max_lt
= INT_CST_LT (maxval
, primop1
);
3011 /* This used to be a switch, but Genix compiler can't handle that. */
3012 if (code
== NE_EXPR
)
3014 if (max_lt
|| min_gt
)
3015 val
= truthvalue_true_node
;
3017 else if (code
== EQ_EXPR
)
3019 if (max_lt
|| min_gt
)
3020 val
= truthvalue_false_node
;
3022 else if (code
== LT_EXPR
)
3025 val
= truthvalue_true_node
;
3027 val
= truthvalue_false_node
;
3029 else if (code
== GT_EXPR
)
3032 val
= truthvalue_true_node
;
3034 val
= truthvalue_false_node
;
3036 else if (code
== LE_EXPR
)
3039 val
= truthvalue_true_node
;
3041 val
= truthvalue_false_node
;
3043 else if (code
== GE_EXPR
)
3046 val
= truthvalue_true_node
;
3048 val
= truthvalue_false_node
;
3051 /* If primop0 was sign-extended and unsigned comparison specd,
3052 we did a signed comparison above using the signed type bounds.
3053 But the comparison we output must be unsigned.
3055 Also, for inequalities, VAL is no good; but if the signed
3056 comparison had *any* fixed result, it follows that the
3057 unsigned comparison just tests the sign in reverse
3058 (positive values are LE, negative ones GE).
3059 So we can generate an unsigned comparison
3060 against an extreme value of the signed type. */
3062 if (unsignedp
&& !unsignedp0
)
3069 primop1
= TYPE_MIN_VALUE (type
);
3075 primop1
= TYPE_MAX_VALUE (type
);
3082 type
= c_common_unsigned_type (type
);
3085 if (TREE_CODE (primop0
) != INTEGER_CST
)
3087 if (val
== truthvalue_false_node
)
3088 warning (OPT_Wtype_limits
, "comparison is always false due to limited range of data type");
3089 if (val
== truthvalue_true_node
)
3090 warning (OPT_Wtype_limits
, "comparison is always true due to limited range of data type");
3095 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3096 if (TREE_SIDE_EFFECTS (primop0
))
3097 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
3101 /* Value is not predetermined, but do the comparison
3102 in the type of the operand that is not constant.
3103 TYPE is already properly set. */
3106 /* If either arg is decimal float and the other is float, find the
3107 proper common type to use for comparison. */
3108 else if (real1
&& real2
3109 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3110 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
3111 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3113 else if (real1
&& real2
3114 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3115 == TYPE_PRECISION (TREE_TYPE (primop1
))))
3116 type
= TREE_TYPE (primop0
);
3118 /* If args' natural types are both narrower than nominal type
3119 and both extend in the same manner, compare them
3120 in the type of the wider arg.
3121 Otherwise must actually extend both to the nominal
3122 common type lest different ways of extending
3124 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3126 else if (unsignedp0
== unsignedp1
&& real1
== real2
3127 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
3128 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
3130 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3131 type
= c_common_signed_or_unsigned_type (unsignedp0
3132 || TYPE_UNSIGNED (*restype_ptr
),
3134 /* Make sure shorter operand is extended the right way
3135 to match the longer operand. */
3137 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
3138 TREE_TYPE (primop0
)),
3141 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
3142 TREE_TYPE (primop1
)),
3147 /* Here we must do the comparison on the nominal type
3148 using the args exactly as we received them. */
3149 type
= *restype_ptr
;
3153 if (!real1
&& !real2
&& integer_zerop (primop1
)
3154 && TYPE_UNSIGNED (*restype_ptr
))
3160 /* All unsigned values are >= 0, so we warn. However,
3161 if OP0 is a constant that is >= 0, the signedness of
3162 the comparison isn't an issue, so suppress the
3164 if (warn_type_limits
&& !in_system_header
3165 && !(TREE_CODE (primop0
) == INTEGER_CST
3166 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3168 warning (OPT_Wtype_limits
,
3169 "comparison of unsigned expression >= 0 is always true");
3170 value
= truthvalue_true_node
;
3174 if (warn_type_limits
&& !in_system_header
3175 && !(TREE_CODE (primop0
) == INTEGER_CST
3176 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3178 warning (OPT_Wtype_limits
,
3179 "comparison of unsigned expression < 0 is always false");
3180 value
= truthvalue_false_node
;
3189 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3190 if (TREE_SIDE_EFFECTS (primop0
))
3191 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3198 *op0_ptr
= convert (type
, primop0
);
3199 *op1_ptr
= convert (type
, primop1
);
3201 *restype_ptr
= truthvalue_type_node
;
3206 /* Return a tree for the sum or difference (RESULTCODE says which)
3207 of pointer PTROP and integer INTOP. */
3210 pointer_int_sum (enum tree_code resultcode
, tree ptrop
, tree intop
)
3214 /* The result is a pointer of the same type that is being added. */
3215 tree result_type
= TREE_TYPE (ptrop
);
3217 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3219 pedwarn (pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3220 "pointer of type %<void *%> used in arithmetic");
3221 size_exp
= integer_one_node
;
3223 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3225 pedwarn (pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3226 "pointer to a function used in arithmetic");
3227 size_exp
= integer_one_node
;
3229 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3231 pedwarn (pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3232 "pointer to member function used in arithmetic");
3233 size_exp
= integer_one_node
;
3236 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3238 /* We are manipulating pointer values, so we don't need to warn
3239 about relying on undefined signed overflow. We disable the
3240 warning here because we use integer types so fold won't know that
3241 they are really pointers. */
3242 fold_defer_overflow_warnings ();
3244 /* If what we are about to multiply by the size of the elements
3245 contains a constant term, apply distributive law
3246 and multiply that constant term separately.
3247 This helps produce common subexpressions. */
3248 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3249 && !TREE_CONSTANT (intop
)
3250 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3251 && TREE_CONSTANT (size_exp
)
3252 /* If the constant comes from pointer subtraction,
3253 skip this optimization--it would cause an error. */
3254 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
3255 /* If the constant is unsigned, and smaller than the pointer size,
3256 then we must skip this optimization. This is because it could cause
3257 an overflow error if the constant is negative but INTOP is not. */
3258 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
3259 || (TYPE_PRECISION (TREE_TYPE (intop
))
3260 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
3262 enum tree_code subcode
= resultcode
;
3263 tree int_type
= TREE_TYPE (intop
);
3264 if (TREE_CODE (intop
) == MINUS_EXPR
)
3265 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3266 /* Convert both subexpression types to the type of intop,
3267 because weird cases involving pointer arithmetic
3268 can result in a sum or difference with different type args. */
3269 ptrop
= build_binary_op (subcode
, ptrop
,
3270 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
3271 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
3274 /* Convert the integer argument to a type the same size as sizetype
3275 so the multiply won't overflow spuriously. */
3276 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
3277 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
3278 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
3279 TYPE_UNSIGNED (sizetype
)), intop
);
3281 /* Replace the integer argument with a suitable product by the object size.
3282 Do this multiplication as signed, then convert to the appropriate
3283 type for the pointer operation. */
3284 intop
= convert (sizetype
,
3285 build_binary_op (MULT_EXPR
, intop
,
3286 convert (TREE_TYPE (intop
), size_exp
), 1));
3288 /* Create the sum or difference. */
3289 if (resultcode
== MINUS_EXPR
)
3290 intop
= fold_build1 (NEGATE_EXPR
, sizetype
, intop
);
3292 ret
= fold_build2 (POINTER_PLUS_EXPR
, result_type
, ptrop
, intop
);
3294 fold_undefer_and_ignore_overflow_warnings ();
3299 /* Return whether EXPR is a declaration whose address can never be
3303 decl_with_nonnull_addr_p (const_tree expr
)
3305 return (DECL_P (expr
)
3306 && (TREE_CODE (expr
) == PARM_DECL
3307 || TREE_CODE (expr
) == LABEL_DECL
3308 || !DECL_WEAK (expr
)));
3311 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3312 or for an `if' or `while' statement or ?..: exp. It should already
3313 have been validated to be of suitable type; otherwise, a bad
3314 diagnostic may result.
3316 This preparation consists of taking the ordinary
3317 representation of an expression expr and producing a valid tree
3318 boolean expression describing whether expr is nonzero. We could
3319 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3320 but we optimize comparisons, &&, ||, and !.
3322 The resulting type should always be `truthvalue_type_node'. */
3325 c_common_truthvalue_conversion (tree expr
)
3327 switch (TREE_CODE (expr
))
3329 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
3330 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3331 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
3332 case ORDERED_EXPR
: case UNORDERED_EXPR
:
3333 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3335 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
3336 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
3338 case TRUTH_ANDIF_EXPR
:
3339 case TRUTH_ORIF_EXPR
:
3340 case TRUTH_AND_EXPR
:
3342 case TRUTH_XOR_EXPR
:
3343 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3345 return build2 (TREE_CODE (expr
), truthvalue_type_node
,
3346 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
3347 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)));
3349 case TRUTH_NOT_EXPR
:
3350 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3352 return build1 (TREE_CODE (expr
), truthvalue_type_node
,
3353 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
3359 return integer_zerop (expr
) ? truthvalue_false_node
3360 : truthvalue_true_node
;
3363 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3364 ? truthvalue_true_node
3365 : truthvalue_false_node
;
3368 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3369 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3370 ? truthvalue_true_node
3371 : truthvalue_false_node
;
3374 expr
= build_unary_op (ADDR_EXPR
, expr
, 0);
3379 tree inner
= TREE_OPERAND (expr
, 0);
3380 if (decl_with_nonnull_addr_p (inner
))
3382 /* Common Ada/Pascal programmer's mistake. */
3383 warning (OPT_Waddress
,
3384 "the address of %qD will always evaluate as %<true%>",
3386 return truthvalue_true_node
;
3389 /* If we still have a decl, it is possible for its address to
3390 be NULL, so we cannot optimize. */
3393 gcc_assert (DECL_WEAK (inner
));
3397 if (TREE_SIDE_EFFECTS (inner
))
3398 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3399 inner
, truthvalue_true_node
);
3401 return truthvalue_true_node
;
3405 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3406 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3407 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
3408 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
3414 /* These don't change whether an object is nonzero or zero. */
3415 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
3419 /* These don't change whether an object is zero or nonzero, but
3420 we can't ignore them if their second arg has side-effects. */
3421 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3422 return build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3423 TREE_OPERAND (expr
, 1),
3424 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
3426 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
3429 /* Distribute the conversion into the arms of a COND_EXPR. */
3430 return fold_build3 (COND_EXPR
, truthvalue_type_node
,
3431 TREE_OPERAND (expr
, 0),
3432 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
3433 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 2)));
3436 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3437 since that affects how `default_conversion' will behave. */
3438 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
3439 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
3441 /* If this is widening the argument, we can ignore it. */
3442 if (TYPE_PRECISION (TREE_TYPE (expr
))
3443 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
3444 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
3448 if (!TREE_NO_WARNING (expr
)
3449 && warn_parentheses
)
3451 warning (OPT_Wparentheses
,
3452 "suggest parentheses around assignment used as truth value");
3453 TREE_NO_WARNING (expr
) = 1;
3461 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
3463 tree t
= save_expr (expr
);
3464 return (build_binary_op
3465 ((TREE_SIDE_EFFECTS (expr
)
3466 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3467 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
3468 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
3472 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
3474 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
3476 (TREE_TYPE (expr
))));
3477 return build_binary_op (NE_EXPR
, expr
, fixed_zero_node
, 1);
3480 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
3483 static void def_builtin_1 (enum built_in_function fncode
,
3485 enum built_in_class fnclass
,
3486 tree fntype
, tree libtype
,
3487 bool both_p
, bool fallback_p
, bool nonansi_p
,
3488 tree fnattrs
, bool implicit_p
);
3491 /* Apply the TYPE_QUALS to the new DECL. */
3494 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
3496 tree type
= TREE_TYPE (decl
);
3498 if (type
== error_mark_node
)
3501 if (((type_quals
& TYPE_QUAL_CONST
)
3502 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
3503 /* An object declared 'const' is only readonly after it is
3504 initialized. We don't have any way of expressing this currently,
3505 so we need to be conservative and unset TREE_READONLY for types
3506 with constructors. Otherwise aliasing code will ignore stores in
3507 an inline constructor. */
3508 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
3509 TREE_READONLY (decl
) = 1;
3510 if (type_quals
& TYPE_QUAL_VOLATILE
)
3512 TREE_SIDE_EFFECTS (decl
) = 1;
3513 TREE_THIS_VOLATILE (decl
) = 1;
3515 if (type_quals
& TYPE_QUAL_RESTRICT
)
3517 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
3518 /* Allow 'restrict' on arrays of pointers.
3519 FIXME currently we just ignore it. */
3520 type
= TREE_TYPE (type
);
3522 || !POINTER_TYPE_P (type
)
3523 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
3524 error ("invalid use of %<restrict%>");
3525 else if (flag_strict_aliasing
&& type
== TREE_TYPE (decl
))
3526 /* Indicate we need to make a unique alias set for this pointer.
3527 We can't do it here because it might be pointing to an
3529 DECL_POINTER_ALIAS_SET (decl
) = -2;
3533 /* Hash function for the problem of multiple type definitions in
3534 different files. This must hash all types that will compare
3535 equal via comptypes to the same value. In practice it hashes
3536 on some of the simple stuff and leaves the details to comptypes. */
3539 c_type_hash (const void *p
)
3543 const_tree
const t
= (const_tree
) p
;
3545 switch (TREE_CODE (t
))
3547 /* For pointers, hash on pointee type plus some swizzling. */
3549 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
3550 /* Hash on number of elements and total size. */
3553 t2
= TYPE_VALUES (t
);
3557 t2
= TYPE_FIELDS (t
);
3559 case QUAL_UNION_TYPE
:
3561 t2
= TYPE_FIELDS (t
);
3565 t2
= TYPE_FIELDS (t
);
3570 for (; t2
; t2
= TREE_CHAIN (t2
))
3572 /* We might have a VLA here. */
3573 if (TREE_CODE (TYPE_SIZE (t
)) != INTEGER_CST
)
3576 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
3577 return ((size
<< 24) | (i
<< shift
));
3580 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
3582 /* Return the typed-based alias set for T, which may be an expression
3583 or a type. Return -1 if we don't do anything special. */
3586 c_common_get_alias_set (tree t
)
3591 /* Permit type-punning when accessing a union, provided the access
3592 is directly through the union. For example, this code does not
3593 permit taking the address of a union member and then storing
3594 through it. Even the type-punning allowed here is a GCC
3595 extension, albeit a common and useful one; the C standard says
3596 that such accesses have implementation-defined behavior. */
3598 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
3599 u
= TREE_OPERAND (u
, 0))
3600 if (TREE_CODE (u
) == COMPONENT_REF
3601 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
3604 /* That's all the expressions we handle specially. */
3608 /* The C standard guarantees that any object may be accessed via an
3609 lvalue that has character type. */
3610 if (t
== char_type_node
3611 || t
== signed_char_type_node
3612 || t
== unsigned_char_type_node
)
3615 /* The C standard specifically allows aliasing between signed and
3616 unsigned variants of the same type. We treat the signed
3617 variant as canonical. */
3618 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
3620 tree t1
= c_common_signed_type (t
);
3622 /* t1 == t can happen for boolean nodes which are always unsigned. */
3624 return get_alias_set (t1
);
3626 else if (POINTER_TYPE_P (t
))
3630 /* Unfortunately, there is no canonical form of a pointer type.
3631 In particular, if we have `typedef int I', then `int *', and
3632 `I *' are different types. So, we have to pick a canonical
3633 representative. We do this below.
3635 Technically, this approach is actually more conservative that
3636 it needs to be. In particular, `const int *' and `int *'
3637 should be in different alias sets, according to the C and C++
3638 standard, since their types are not the same, and so,
3639 technically, an `int **' and `const int **' cannot point at
3642 But, the standard is wrong. In particular, this code is
3647 const int* const* cipp = ipp;
3649 And, it doesn't make sense for that to be legal unless you
3650 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3651 the pointed-to types. This issue has been reported to the
3653 t1
= build_type_no_quals (t
);
3655 return get_alias_set (t1
);
3658 /* Handle the case of multiple type nodes referring to "the same" type,
3659 which occurs with IMA. These share an alias set. FIXME: Currently only
3660 C90 is handled. (In C99 type compatibility is not transitive, which
3661 complicates things mightily. The alias set splay trees can theoretically
3662 represent this, but insertion is tricky when you consider all the
3663 different orders things might arrive in.) */
3665 if (c_language
!= clk_c
|| flag_isoc99
)
3668 /* Save time if there's only one input file. */
3669 if (num_in_fnames
== 1)
3672 /* Pointers need special handling if they point to any type that
3673 needs special handling (below). */
3674 if (TREE_CODE (t
) == POINTER_TYPE
)
3677 /* Find bottom type under any nested POINTERs. */
3678 for (t2
= TREE_TYPE (t
);
3679 TREE_CODE (t2
) == POINTER_TYPE
;
3680 t2
= TREE_TYPE (t2
))
3682 if (TREE_CODE (t2
) != RECORD_TYPE
3683 && TREE_CODE (t2
) != ENUMERAL_TYPE
3684 && TREE_CODE (t2
) != QUAL_UNION_TYPE
3685 && TREE_CODE (t2
) != UNION_TYPE
)
3687 if (TYPE_SIZE (t2
) == 0)
3690 /* These are the only cases that need special handling. */
3691 if (TREE_CODE (t
) != RECORD_TYPE
3692 && TREE_CODE (t
) != ENUMERAL_TYPE
3693 && TREE_CODE (t
) != QUAL_UNION_TYPE
3694 && TREE_CODE (t
) != UNION_TYPE
3695 && TREE_CODE (t
) != POINTER_TYPE
)
3698 if (TYPE_SIZE (t
) == 0)
3701 /* Look up t in hash table. Only one of the compatible types within each
3702 alias set is recorded in the table. */
3703 if (!type_hash_table
)
3704 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
3705 (htab_eq
) lang_hooks
.types_compatible_p
,
3707 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
3710 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
3711 return TYPE_ALIAS_SET ((tree
)*slot
);
3714 /* Our caller will assign and record (in t) a new alias set; all we need
3715 to do is remember t in the hash table. */
3721 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3722 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3723 flag controls whether we should diagnose possibly ill-formed
3724 constructs or not. */
3727 c_sizeof_or_alignof_type (tree type
, bool is_sizeof
, int complain
)
3729 const char *op_name
;
3731 enum tree_code type_code
= TREE_CODE (type
);
3733 op_name
= is_sizeof
? "sizeof" : "__alignof__";
3735 if (type_code
== FUNCTION_TYPE
)
3739 if (complain
&& (pedantic
|| warn_pointer_arith
))
3740 pedwarn (pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3741 "invalid application of %<sizeof%> to a function type");
3743 return error_mark_node
;
3744 value
= size_one_node
;
3747 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
3749 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
3751 if (type_code
== VOID_TYPE
3752 && complain
&& (pedantic
|| warn_pointer_arith
))
3753 pedwarn (pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3754 "invalid application of %qs to a void type", op_name
);
3756 return error_mark_node
;
3757 value
= size_one_node
;
3759 else if (!COMPLETE_TYPE_P (type
))
3762 error ("invalid application of %qs to incomplete type %qT ",
3764 value
= size_zero_node
;
3769 /* Convert in case a char is more than one unit. */
3770 value
= size_binop (CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
3771 size_int (TYPE_PRECISION (char_type_node
)
3774 value
= size_int (TYPE_ALIGN_UNIT (type
));
3777 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3778 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3779 never happen. However, this node should really have type
3780 `size_t', which is just a typedef for an ordinary integer type. */
3781 value
= fold_convert (size_type_node
, value
);
3782 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)));
3787 /* Implement the __alignof keyword: Return the minimum required
3788 alignment of EXPR, measured in bytes. For VAR_DECLs,
3789 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3790 from an "aligned" __attribute__ specification). */
3793 c_alignof_expr (tree expr
)
3797 if (VAR_OR_FUNCTION_DECL_P (expr
))
3798 t
= size_int (DECL_ALIGN_UNIT (expr
));
3800 else if (TREE_CODE (expr
) == COMPONENT_REF
3801 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
3803 error ("%<__alignof%> applied to a bit-field");
3806 else if (TREE_CODE (expr
) == COMPONENT_REF
3807 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
3808 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
3810 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3812 tree t
= TREE_OPERAND (expr
, 0);
3814 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3816 while (CONVERT_EXPR_P (t
)
3817 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
3821 t
= TREE_OPERAND (t
, 0);
3822 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
3823 if (thisalign
> bestalign
)
3824 best
= t
, bestalign
= thisalign
;
3826 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
3829 return c_alignof (TREE_TYPE (expr
));
3831 return fold_convert (size_type_node
, t
);
3834 /* Handle C and C++ default attributes. */
3836 enum built_in_attribute
3838 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3839 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3840 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3841 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3842 #include "builtin-attrs.def"
3843 #undef DEF_ATTR_NULL_TREE
3845 #undef DEF_ATTR_IDENT
3846 #undef DEF_ATTR_TREE_LIST
3850 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
3852 static void c_init_attributes (void);
3856 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3857 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3858 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3859 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3860 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3861 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3862 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3863 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3864 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3865 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3866 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3867 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3868 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3869 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3870 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3872 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3873 #include "builtin-types.def"
3874 #undef DEF_PRIMITIVE_TYPE
3875 #undef DEF_FUNCTION_TYPE_0
3876 #undef DEF_FUNCTION_TYPE_1
3877 #undef DEF_FUNCTION_TYPE_2
3878 #undef DEF_FUNCTION_TYPE_3
3879 #undef DEF_FUNCTION_TYPE_4
3880 #undef DEF_FUNCTION_TYPE_5
3881 #undef DEF_FUNCTION_TYPE_6
3882 #undef DEF_FUNCTION_TYPE_7
3883 #undef DEF_FUNCTION_TYPE_VAR_0
3884 #undef DEF_FUNCTION_TYPE_VAR_1
3885 #undef DEF_FUNCTION_TYPE_VAR_2
3886 #undef DEF_FUNCTION_TYPE_VAR_3
3887 #undef DEF_FUNCTION_TYPE_VAR_4
3888 #undef DEF_FUNCTION_TYPE_VAR_5
3889 #undef DEF_POINTER_TYPE
3893 typedef enum c_builtin_type builtin_type
;
3895 /* A temporary array for c_common_nodes_and_builtins. Used in
3896 communication with def_fn_type. */
3897 static tree builtin_types
[(int) BT_LAST
+ 1];
3899 /* A helper function for c_common_nodes_and_builtins. Build function type
3900 for DEF with return type RET and N arguments. If VAR is true, then the
3901 function should be variadic after those N arguments.
3903 Takes special care not to ICE if any of the types involved are
3904 error_mark_node, which indicates that said type is not in fact available
3905 (see builtin_type_for_size). In which case the function type as a whole
3906 should be error_mark_node. */
3909 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
3911 tree args
= NULL
, t
;
3916 for (i
= 0; i
< n
; ++i
)
3918 builtin_type a
= (builtin_type
) va_arg (list
, int);
3919 t
= builtin_types
[a
];
3920 if (t
== error_mark_node
)
3922 args
= tree_cons (NULL_TREE
, t
, args
);
3926 args
= nreverse (args
);
3928 args
= chainon (args
, void_list_node
);
3930 t
= builtin_types
[ret
];
3931 if (t
== error_mark_node
)
3933 t
= build_function_type (t
, args
);
3936 builtin_types
[def
] = t
;
3939 /* Build builtin functions common to both C and C++ language
3943 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
3945 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3946 builtin_types[ENUM] = VALUE;
3947 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3948 def_fn_type (ENUM, RETURN, 0, 0);
3949 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3950 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3951 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3952 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3953 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3954 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3955 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3956 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3957 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3958 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3959 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3961 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3962 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3964 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3965 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3966 def_fn_type (ENUM, RETURN, 1, 0);
3967 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3968 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3969 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3970 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3971 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3972 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3973 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3974 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3975 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3976 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3977 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3978 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3980 #include "builtin-types.def"
3982 #undef DEF_PRIMITIVE_TYPE
3983 #undef DEF_FUNCTION_TYPE_1
3984 #undef DEF_FUNCTION_TYPE_2
3985 #undef DEF_FUNCTION_TYPE_3
3986 #undef DEF_FUNCTION_TYPE_4
3987 #undef DEF_FUNCTION_TYPE_5
3988 #undef DEF_FUNCTION_TYPE_6
3989 #undef DEF_FUNCTION_TYPE_VAR_0
3990 #undef DEF_FUNCTION_TYPE_VAR_1
3991 #undef DEF_FUNCTION_TYPE_VAR_2
3992 #undef DEF_FUNCTION_TYPE_VAR_3
3993 #undef DEF_FUNCTION_TYPE_VAR_4
3994 #undef DEF_FUNCTION_TYPE_VAR_5
3995 #undef DEF_POINTER_TYPE
3996 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
3998 c_init_attributes ();
4000 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4001 NONANSI_P, ATTRS, IMPLICIT, COND) \
4003 def_builtin_1 (ENUM, NAME, CLASS, \
4004 builtin_types[(int) TYPE], \
4005 builtin_types[(int) LIBTYPE], \
4006 BOTH_P, FALLBACK_P, NONANSI_P, \
4007 built_in_attributes[(int) ATTRS], IMPLICIT);
4008 #include "builtins.def"
4011 targetm
.init_builtins ();
4013 build_common_builtin_nodes ();
4019 /* Build tree nodes and builtin functions common to both C and C++ language
4023 c_common_nodes_and_builtins (void)
4025 int char16_type_size
;
4026 int char32_type_size
;
4027 int wchar_type_size
;
4028 tree array_domain_type
;
4029 tree va_list_ref_type_node
;
4030 tree va_list_arg_type_node
;
4032 /* Define `int' and `char' first so that dbx will output them first. */
4033 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
4034 record_builtin_type (RID_CHAR
, "char", char_type_node
);
4036 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4037 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4038 but not C. Are the conditionals here needed? */
4039 if (c_dialect_cxx ())
4040 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
4041 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
4042 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
4043 record_builtin_type (RID_MAX
, "long unsigned int",
4044 long_unsigned_type_node
);
4045 if (c_dialect_cxx ())
4046 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
4047 record_builtin_type (RID_MAX
, "long long int",
4048 long_long_integer_type_node
);
4049 record_builtin_type (RID_MAX
, "long long unsigned int",
4050 long_long_unsigned_type_node
);
4051 if (c_dialect_cxx ())
4052 record_builtin_type (RID_MAX
, "long long unsigned",
4053 long_long_unsigned_type_node
);
4054 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
4055 record_builtin_type (RID_MAX
, "short unsigned int",
4056 short_unsigned_type_node
);
4057 if (c_dialect_cxx ())
4058 record_builtin_type (RID_MAX
, "unsigned short",
4059 short_unsigned_type_node
);
4061 /* Define both `signed char' and `unsigned char'. */
4062 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
4063 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
4065 /* These are types that c_common_type_for_size and
4066 c_common_type_for_mode use. */
4067 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4069 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4071 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4073 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4075 #if HOST_BITS_PER_WIDE_INT >= 64
4076 if (targetm
.scalar_mode_supported_p (TImode
))
4077 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4078 get_identifier ("__int128_t"),
4081 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4082 unsigned_intQI_type_node
));
4083 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4084 unsigned_intHI_type_node
));
4085 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4086 unsigned_intSI_type_node
));
4087 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4088 unsigned_intDI_type_node
));
4089 #if HOST_BITS_PER_WIDE_INT >= 64
4090 if (targetm
.scalar_mode_supported_p (TImode
))
4091 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4092 get_identifier ("__uint128_t"),
4093 unsigned_intTI_type_node
));
4096 /* Create the widest literal types. */
4097 widest_integer_literal_type_node
4098 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
4099 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4100 widest_integer_literal_type_node
));
4102 widest_unsigned_literal_type_node
4103 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
4104 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
4105 widest_unsigned_literal_type_node
));
4107 /* `unsigned long' is the standard type for sizeof.
4108 Note that stddef.h uses `unsigned long',
4109 and this must agree, even if long and int are the same size. */
4111 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
4112 signed_size_type_node
= c_common_signed_type (size_type_node
);
4113 set_sizetype (size_type_node
);
4116 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
4118 build_common_tree_nodes_2 (flag_short_double
);
4120 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
4121 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
4122 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
4124 /* Only supported decimal floating point extension if the target
4125 actually supports underlying modes. */
4126 if (targetm
.scalar_mode_supported_p (SDmode
)
4127 && targetm
.scalar_mode_supported_p (DDmode
)
4128 && targetm
.scalar_mode_supported_p (TDmode
))
4130 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
4131 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
4132 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
4135 if (targetm
.fixed_point_supported_p ())
4137 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
4138 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
4139 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
4140 record_builtin_type (RID_MAX
, "long long _Fract",
4141 long_long_fract_type_node
);
4142 record_builtin_type (RID_MAX
, "unsigned short _Fract",
4143 unsigned_short_fract_type_node
);
4144 record_builtin_type (RID_MAX
, "unsigned _Fract",
4145 unsigned_fract_type_node
);
4146 record_builtin_type (RID_MAX
, "unsigned long _Fract",
4147 unsigned_long_fract_type_node
);
4148 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
4149 unsigned_long_long_fract_type_node
);
4150 record_builtin_type (RID_MAX
, "_Sat short _Fract",
4151 sat_short_fract_type_node
);
4152 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
4153 record_builtin_type (RID_MAX
, "_Sat long _Fract",
4154 sat_long_fract_type_node
);
4155 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
4156 sat_long_long_fract_type_node
);
4157 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
4158 sat_unsigned_short_fract_type_node
);
4159 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
4160 sat_unsigned_fract_type_node
);
4161 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
4162 sat_unsigned_long_fract_type_node
);
4163 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
4164 sat_unsigned_long_long_fract_type_node
);
4165 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
4166 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
4167 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
4168 record_builtin_type (RID_MAX
, "long long _Accum",
4169 long_long_accum_type_node
);
4170 record_builtin_type (RID_MAX
, "unsigned short _Accum",
4171 unsigned_short_accum_type_node
);
4172 record_builtin_type (RID_MAX
, "unsigned _Accum",
4173 unsigned_accum_type_node
);
4174 record_builtin_type (RID_MAX
, "unsigned long _Accum",
4175 unsigned_long_accum_type_node
);
4176 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
4177 unsigned_long_long_accum_type_node
);
4178 record_builtin_type (RID_MAX
, "_Sat short _Accum",
4179 sat_short_accum_type_node
);
4180 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
4181 record_builtin_type (RID_MAX
, "_Sat long _Accum",
4182 sat_long_accum_type_node
);
4183 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
4184 sat_long_long_accum_type_node
);
4185 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
4186 sat_unsigned_short_accum_type_node
);
4187 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
4188 sat_unsigned_accum_type_node
);
4189 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
4190 sat_unsigned_long_accum_type_node
);
4191 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
4192 sat_unsigned_long_long_accum_type_node
);
4196 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4197 get_identifier ("complex int"),
4198 complex_integer_type_node
));
4199 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4200 get_identifier ("complex float"),
4201 complex_float_type_node
));
4202 lang_hooks
.decls
.pushdecl (build_decl (TYPE_DECL
,
4203 get_identifier ("complex double"),
4204 complex_double_type_node
));
4205 lang_hooks
.decls
.pushdecl
4206 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
4207 complex_long_double_type_node
));
4209 if (c_dialect_cxx ())
4210 /* For C++, make fileptr_type_node a distinct void * type until
4211 FILE type is defined. */
4212 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
4214 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
4216 /* Set the TYPE_NAME for any variants that were built before
4217 record_builtin_type gave names to the built-in types. */
4219 tree void_name
= TYPE_NAME (void_type_node
);
4220 TYPE_NAME (void_type_node
) = NULL_TREE
;
4221 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
4223 TYPE_NAME (void_type_node
) = void_name
;
4226 /* This node must not be shared. */
4227 void_zero_node
= make_node (INTEGER_CST
);
4228 TREE_TYPE (void_zero_node
) = void_type_node
;
4230 void_list_node
= build_void_list_node ();
4232 /* Make a type to be the domain of a few array types
4233 whose domains don't really matter.
4234 200 is small enough that it always fits in size_t
4235 and large enough that it can hold most function names for the
4236 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4237 array_domain_type
= build_index_type (size_int (200));
4239 /* Make a type for arrays of characters.
4240 With luck nothing will ever really depend on the length of this
4242 char_array_type_node
4243 = build_array_type (char_type_node
, array_domain_type
);
4245 /* Likewise for arrays of ints. */
4247 = build_array_type (integer_type_node
, array_domain_type
);
4249 string_type_node
= build_pointer_type (char_type_node
);
4250 const_string_type_node
4251 = build_pointer_type (build_qualified_type
4252 (char_type_node
, TYPE_QUAL_CONST
));
4254 /* This is special for C++ so functions can be overloaded. */
4255 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
4256 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
4257 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
4258 if (c_dialect_cxx ())
4260 if (TYPE_UNSIGNED (wchar_type_node
))
4261 wchar_type_node
= make_unsigned_type (wchar_type_size
);
4263 wchar_type_node
= make_signed_type (wchar_type_size
);
4264 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
4268 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
4269 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
4272 /* This is for wide string constants. */
4273 wchar_array_type_node
4274 = build_array_type (wchar_type_node
, array_domain_type
);
4276 /* Define 'char16_t'. */
4277 char16_type_node
= get_identifier (CHAR16_TYPE
);
4278 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
4279 char16_type_size
= TYPE_PRECISION (char16_type_node
);
4280 if (c_dialect_cxx ())
4282 char16_type_node
= make_unsigned_type (char16_type_size
);
4284 if (cxx_dialect
== cxx0x
)
4285 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
4288 /* This is for UTF-16 string constants. */
4289 char16_array_type_node
4290 = build_array_type (char16_type_node
, array_domain_type
);
4292 /* Define 'char32_t'. */
4293 char32_type_node
= get_identifier (CHAR32_TYPE
);
4294 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
4295 char32_type_size
= TYPE_PRECISION (char32_type_node
);
4296 if (c_dialect_cxx ())
4298 char32_type_node
= make_unsigned_type (char32_type_size
);
4300 if (cxx_dialect
== cxx0x
)
4301 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
4304 /* This is for UTF-32 string constants. */
4305 char32_array_type_node
4306 = build_array_type (char32_type_node
, array_domain_type
);
4309 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
4312 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
4314 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
4316 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
4318 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
4319 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
4321 lang_hooks
.decls
.pushdecl
4322 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
4323 va_list_type_node
));
4324 #ifdef TARGET_ENUM_VA_LIST
4329 for (l
= 0; TARGET_ENUM_VA_LIST (l
, &pname
, &ptype
); ++l
)
4331 lang_hooks
.decls
.pushdecl
4332 (build_decl (TYPE_DECL
, get_identifier (pname
),
4339 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4341 va_list_arg_type_node
= va_list_ref_type_node
=
4342 build_pointer_type (TREE_TYPE (va_list_type_node
));
4346 va_list_arg_type_node
= va_list_type_node
;
4347 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
4350 if (!flag_preprocess_only
)
4351 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
4353 main_identifier_node
= get_identifier ("main");
4355 /* Create the built-in __null node. It is important that this is
4357 null_node
= make_node (INTEGER_CST
);
4358 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
4360 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4361 memset (builtin_types
, 0, sizeof (builtin_types
));
4364 /* Look up the function in built_in_decls that corresponds to DECL
4365 and set ASMSPEC as its user assembler name. DECL must be a
4366 function decl that declares a builtin. */
4369 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
4372 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
4373 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
4376 builtin
= built_in_decls
[DECL_FUNCTION_CODE (decl
)];
4377 set_user_assembler_name (builtin
, asmspec
);
4378 if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMCPY
)
4379 init_block_move_fn (asmspec
);
4380 else if (DECL_FUNCTION_CODE (decl
) == BUILT_IN_MEMSET
)
4381 init_block_clear_fn (asmspec
);
4384 /* The number of named compound-literals generated thus far. */
4385 static GTY(()) int compound_literal_number
;
4387 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4390 set_compound_literal_name (tree decl
)
4393 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
4394 compound_literal_number
);
4395 compound_literal_number
++;
4396 DECL_NAME (decl
) = get_identifier (name
);
4400 build_va_arg (tree expr
, tree type
)
4402 return build1 (VA_ARG_EXPR
, type
, expr
);
4406 /* Linked list of disabled built-in functions. */
4408 typedef struct disabled_builtin
4411 struct disabled_builtin
*next
;
4413 static disabled_builtin
*disabled_builtins
= NULL
;
4415 static bool builtin_function_disabled_p (const char *);
4417 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4418 begins with "__builtin_", give an error. */
4421 disable_builtin_function (const char *name
)
4423 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
4424 error ("cannot disable built-in function %qs", name
);
4427 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
4428 new_disabled_builtin
->name
= name
;
4429 new_disabled_builtin
->next
= disabled_builtins
;
4430 disabled_builtins
= new_disabled_builtin
;
4435 /* Return true if the built-in function NAME has been disabled, false
4439 builtin_function_disabled_p (const char *name
)
4441 disabled_builtin
*p
;
4442 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
4444 if (strcmp (name
, p
->name
) == 0)
4451 /* Worker for DEF_BUILTIN.
4452 Possibly define a builtin function with one or two names.
4453 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4454 nonansi_p and flag_no_nonansi_builtin. */
4457 def_builtin_1 (enum built_in_function fncode
,
4459 enum built_in_class fnclass
,
4460 tree fntype
, tree libtype
,
4461 bool both_p
, bool fallback_p
, bool nonansi_p
,
4462 tree fnattrs
, bool implicit_p
)
4465 const char *libname
;
4467 if (fntype
== error_mark_node
)
4470 gcc_assert ((!both_p
&& !fallback_p
)
4471 || !strncmp (name
, "__builtin_",
4472 strlen ("__builtin_")));
4474 libname
= name
+ strlen ("__builtin_");
4475 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
4476 (fallback_p
? libname
: NULL
),
4479 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
4480 && !(nonansi_p
&& flag_no_nonansi_builtin
))
4481 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
4484 built_in_decls
[(int) fncode
] = decl
;
4486 implicit_built_in_decls
[(int) fncode
] = decl
;
4489 /* Nonzero if the type T promotes to int. This is (nearly) the
4490 integral promotions defined in ISO C99 6.3.1.1/2. */
4493 c_promoting_integer_type_p (const_tree t
)
4495 switch (TREE_CODE (t
))
4498 return (TYPE_MAIN_VARIANT (t
) == char_type_node
4499 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
4500 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
4501 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
4502 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
4503 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
4506 /* ??? Technically all enumerations not larger than an int
4507 promote to an int. But this is used along code paths
4508 that only want to notice a size change. */
4509 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
4519 /* Return 1 if PARMS specifies a fixed number of parameters
4520 and none of their types is affected by default promotions. */
4523 self_promoting_args_p (const_tree parms
)
4526 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
4528 tree type
= TREE_VALUE (t
);
4530 if (type
== error_mark_node
)
4533 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
4539 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
4542 if (c_promoting_integer_type_p (type
))
4548 /* Recursively remove any '*' or '&' operator from TYPE. */
4550 strip_pointer_operator (tree t
)
4552 while (POINTER_TYPE_P (t
))
4557 /* Recursively remove pointer or array type from TYPE. */
4559 strip_pointer_or_array_types (tree t
)
4561 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
4566 /* Used to compare case labels. K1 and K2 are actually tree nodes
4567 representing case labels, or NULL_TREE for a `default' label.
4568 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4569 K2, and 0 if K1 and K2 are equal. */
4572 case_compare (splay_tree_key k1
, splay_tree_key k2
)
4574 /* Consider a NULL key (such as arises with a `default' label) to be
4575 smaller than anything else. */
4581 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4584 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4585 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4586 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4587 case label was declared using the usual C/C++ syntax, rather than
4588 the GNU case range extension. CASES is a tree containing all the
4589 case ranges processed so far; COND is the condition for the
4590 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
4591 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
4594 c_add_case_label (splay_tree cases
, tree cond
, tree orig_type
,
4595 tree low_value
, tree high_value
)
4600 splay_tree_node node
;
4602 /* Create the LABEL_DECL itself. */
4603 label
= create_artificial_label ();
4605 /* If there was an error processing the switch condition, bail now
4606 before we get more confused. */
4607 if (!cond
|| cond
== error_mark_node
)
4610 if ((low_value
&& TREE_TYPE (low_value
)
4611 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
4612 || (high_value
&& TREE_TYPE (high_value
)
4613 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
4615 error ("pointers are not permitted as case values");
4619 /* Case ranges are a GNU extension. */
4621 pedwarn (OPT_pedantic
,
4622 "range expressions in switch statements are non-standard");
4624 type
= TREE_TYPE (cond
);
4627 low_value
= check_case_value (low_value
);
4628 low_value
= convert_and_check (type
, low_value
);
4629 if (low_value
== error_mark_node
)
4634 high_value
= check_case_value (high_value
);
4635 high_value
= convert_and_check (type
, high_value
);
4636 if (high_value
== error_mark_node
)
4640 if (low_value
&& high_value
)
4642 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4643 really a case range, even though it was written that way.
4644 Remove the HIGH_VALUE to simplify later processing. */
4645 if (tree_int_cst_equal (low_value
, high_value
))
4646 high_value
= NULL_TREE
;
4647 else if (!tree_int_cst_lt (low_value
, high_value
))
4648 warning (0, "empty range specified");
4651 /* See if the case is in range of the type of the original testing
4652 expression. If both low_value and high_value are out of range,
4653 don't insert the case label and return NULL_TREE. */
4655 && !check_case_bounds (type
, orig_type
,
4656 &low_value
, high_value
? &high_value
: NULL
))
4659 /* Look up the LOW_VALUE in the table of case labels we already
4661 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
4662 /* If there was not an exact match, check for overlapping ranges.
4663 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4664 that's a `default' label and the only overlap is an exact match. */
4665 if (!node
&& (low_value
|| high_value
))
4667 splay_tree_node low_bound
;
4668 splay_tree_node high_bound
;
4670 /* Even though there wasn't an exact match, there might be an
4671 overlap between this case range and another case range.
4672 Since we've (inductively) not allowed any overlapping case
4673 ranges, we simply need to find the greatest low case label
4674 that is smaller that LOW_VALUE, and the smallest low case
4675 label that is greater than LOW_VALUE. If there is an overlap
4676 it will occur in one of these two ranges. */
4677 low_bound
= splay_tree_predecessor (cases
,
4678 (splay_tree_key
) low_value
);
4679 high_bound
= splay_tree_successor (cases
,
4680 (splay_tree_key
) low_value
);
4682 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4683 the LOW_VALUE, so there is no need to check unless the
4684 LOW_BOUND is in fact itself a case range. */
4686 && CASE_HIGH ((tree
) low_bound
->value
)
4687 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
4690 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4691 range is bigger than the low end of the current range, so we
4692 are only interested if the current range is a real range, and
4693 not an ordinary case label. */
4696 && (tree_int_cst_compare ((tree
) high_bound
->key
,
4701 /* If there was an overlap, issue an error. */
4704 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
4708 error ("duplicate (or overlapping) case value");
4709 error ("%Jthis is the first entry overlapping that value", duplicate
);
4713 error ("duplicate case value") ;
4714 error ("%Jpreviously used here", duplicate
);
4718 error ("multiple default labels in one switch");
4719 error ("%Jthis is the first default label", duplicate
);
4724 /* Add a CASE_LABEL to the statement-tree. */
4725 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
4726 /* Register this case label in the splay tree. */
4727 splay_tree_insert (cases
,
4728 (splay_tree_key
) low_value
,
4729 (splay_tree_value
) case_label
);
4734 /* Add a label so that the back-end doesn't think that the beginning of
4735 the switch is unreachable. Note that we do not add a case label, as
4736 that just leads to duplicates and thence to failure later on. */
4739 tree t
= create_artificial_label ();
4740 add_stmt (build_stmt (LABEL_EXPR
, t
));
4742 return error_mark_node
;
4745 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4746 Used to verify that case values match up with enumerator values. */
4749 match_case_to_enum_1 (tree key
, tree type
, tree label
)
4751 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
4753 /* ??? Not working too hard to print the double-word value.
4754 Should perhaps be done with %lwd in the diagnostic routines? */
4755 if (TREE_INT_CST_HIGH (key
) == 0)
4756 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
4757 TREE_INT_CST_LOW (key
));
4758 else if (!TYPE_UNSIGNED (type
)
4759 && TREE_INT_CST_HIGH (key
) == -1
4760 && TREE_INT_CST_LOW (key
) != 0)
4761 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
4762 -TREE_INT_CST_LOW (key
));
4764 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
4765 (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (key
),
4766 (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (key
));
4768 if (TYPE_NAME (type
) == 0)
4769 warning (warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
4770 "%Jcase value %qs not in enumerated type",
4771 CASE_LABEL (label
), buf
);
4773 warning (warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
4774 "%Jcase value %qs not in enumerated type %qT",
4775 CASE_LABEL (label
), buf
, type
);
4778 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4779 Used to verify that case values match up with enumerator values. */
4782 match_case_to_enum (splay_tree_node node
, void *data
)
4784 tree label
= (tree
) node
->value
;
4785 tree type
= (tree
) data
;
4787 /* Skip default case. */
4788 if (!CASE_LOW (label
))
4791 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4792 when we did our enum->case scan. Reset our scratch bit after. */
4793 if (!CASE_LOW_SEEN (label
))
4794 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
4796 CASE_LOW_SEEN (label
) = 0;
4798 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4799 not set, that means that CASE_HIGH did not appear when we did our
4800 enum->case scan. Reset our scratch bit after. */
4801 if (CASE_HIGH (label
))
4803 if (!CASE_HIGH_SEEN (label
))
4804 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
4806 CASE_HIGH_SEEN (label
) = 0;
4812 /* Handle -Wswitch*. Called from the front end after parsing the
4813 switch construct. */
4814 /* ??? Should probably be somewhere generic, since other languages
4815 besides C and C++ would want this. At the moment, however, C/C++
4816 are the only tree-ssa languages that support enumerations at all,
4817 so the point is moot. */
4820 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
4821 tree type
, tree cond
)
4823 splay_tree_node default_node
;
4824 splay_tree_node node
;
4826 int saved_warn_switch
;
4828 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
4831 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
4833 warning (OPT_Wswitch_default
, "%Hswitch missing default case",
4836 /* From here on, we only care about about enumerated types. */
4837 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
4840 /* If the switch expression was an enumerated type, check that
4841 exactly all enumeration literals are covered by the cases.
4842 The check is made when -Wswitch was specified and there is no
4843 default case, or when -Wswitch-enum was specified. */
4845 if (!warn_switch_enum
4846 && !(warn_switch
&& !default_node
))
4849 /* Clearing COND if it is not an integer constant simplifies
4850 the tests inside the loop below. */
4851 if (TREE_CODE (cond
) != INTEGER_CST
)
4854 /* The time complexity here is O(N*lg(N)) worst case, but for the
4855 common case of monotonically increasing enumerators, it is
4856 O(N), since the nature of the splay tree will keep the next
4857 element adjacent to the root at all times. */
4859 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
4861 tree value
= TREE_VALUE (chain
);
4862 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
4865 /* Mark the CASE_LOW part of the case entry as seen. */
4866 tree label
= (tree
) node
->value
;
4867 CASE_LOW_SEEN (label
) = 1;
4871 /* Even though there wasn't an exact match, there might be a
4872 case range which includes the enumerator's value. */
4873 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
4874 if (node
&& CASE_HIGH ((tree
) node
->value
))
4876 tree label
= (tree
) node
->value
;
4877 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
4880 /* If we match the upper bound exactly, mark the CASE_HIGH
4881 part of the case entry as seen. */
4883 CASE_HIGH_SEEN (label
) = 1;
4888 /* We've now determined that this enumerated literal isn't
4889 handled by the case labels of the switch statement. */
4891 /* If the switch expression is a constant, we only really care
4892 about whether that constant is handled by the switch. */
4893 if (cond
&& tree_int_cst_compare (cond
, value
))
4896 /* If there is a default_node, the only relevant option is
4897 Wswitch-enum. Otherwise, if both are enabled then we prefer
4898 to warn using -Wswitch because -Wswitch is enabled by -Wall
4899 while -Wswitch-enum is explicit. */
4900 warning ((default_node
|| !warn_switch
)
4901 ? OPT_Wswitch_enum
: OPT_Wswitch
,
4902 "%Henumeration value %qE not handled in switch",
4903 &switch_location
, TREE_PURPOSE (chain
));
4906 /* Warn if there are case expressions that don't correspond to
4907 enumerators. This can occur since C and C++ don't enforce
4908 type-checking of assignments to enumeration variables.
4910 The time complexity here is now always O(N) worst case, since
4911 we should have marked both the lower bound and upper bound of
4912 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4913 above. This scan also resets those fields. */
4915 /* If there is a default_node, the only relevant option is
4916 Wswitch-enum. Otherwise, if both are enabled then we prefer
4917 to warn using -Wswitch because -Wswitch is enabled by -Wall
4918 while -Wswitch-enum is explicit. */
4919 saved_warn_switch
= warn_switch
;
4922 splay_tree_foreach (cases
, match_case_to_enum
, type
);
4923 warn_switch
= saved_warn_switch
;
4927 /* Finish an expression taking the address of LABEL (an
4928 IDENTIFIER_NODE). Returns an expression for the address. */
4931 finish_label_address_expr (tree label
)
4935 pedwarn (OPT_pedantic
, "taking the address of a label is non-standard");
4937 if (label
== error_mark_node
)
4938 return error_mark_node
;
4940 label
= lookup_label (label
);
4941 if (label
== NULL_TREE
)
4942 result
= null_pointer_node
;
4945 TREE_USED (label
) = 1;
4946 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
4947 /* The current function in not necessarily uninlinable.
4948 Computed gotos are incompatible with inlining, but the value
4949 here could be used only in a diagnostic, for example. */
4955 /* Hook used by expand_expr to expand language-specific tree codes. */
4956 /* The only things that should go here are bits needed to expand
4957 constant initializers. Everything else should be handled by the
4958 gimplification routines. */
4961 c_expand_expr (tree exp
, rtx target
, enum machine_mode tmode
,
4962 int modifiera
/* Actually enum expand_modifier. */,
4965 enum expand_modifier modifier
= (enum expand_modifier
) modifiera
;
4966 switch (TREE_CODE (exp
))
4968 case COMPOUND_LITERAL_EXPR
:
4970 /* Initialize the anonymous variable declared in the compound
4971 literal, then return the variable. */
4972 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
4973 emit_local_var (decl
);
4974 return expand_expr_real (decl
, target
, tmode
, modifier
, alt_rtl
);
4982 /* Hook used by staticp to handle language-specific tree codes. */
4985 c_staticp (tree exp
)
4987 return (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
4988 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
))
4993 /* Given a boolean expression ARG, return a tree representing an increment
4994 or decrement (as indicated by CODE) of ARG. The front end must check for
4995 invalid cases (e.g., decrement in C++). */
4997 boolean_increment (enum tree_code code
, tree arg
)
5000 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
5002 arg
= stabilize_reference (arg
);
5005 case PREINCREMENT_EXPR
:
5006 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5008 case POSTINCREMENT_EXPR
:
5009 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5010 arg
= save_expr (arg
);
5011 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5012 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5014 case PREDECREMENT_EXPR
:
5015 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5016 invert_truthvalue (arg
));
5018 case POSTDECREMENT_EXPR
:
5019 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5020 invert_truthvalue (arg
));
5021 arg
= save_expr (arg
);
5022 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5023 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5028 TREE_SIDE_EFFECTS (val
) = 1;
5032 /* Built-in macros for stddef.h, that require macros defined in this
5035 c_stddef_cpp_builtins(void)
5037 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
5038 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
5039 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
5040 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
5041 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
5042 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
5043 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
5044 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
5048 c_init_attributes (void)
5050 /* Fill in the built_in_attributes array. */
5051 #define DEF_ATTR_NULL_TREE(ENUM) \
5052 built_in_attributes[(int) ENUM] = NULL_TREE;
5053 #define DEF_ATTR_INT(ENUM, VALUE) \
5054 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5055 #define DEF_ATTR_IDENT(ENUM, STRING) \
5056 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5057 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5058 built_in_attributes[(int) ENUM] \
5059 = tree_cons (built_in_attributes[(int) PURPOSE], \
5060 built_in_attributes[(int) VALUE], \
5061 built_in_attributes[(int) CHAIN]);
5062 #include "builtin-attrs.def"
5063 #undef DEF_ATTR_NULL_TREE
5065 #undef DEF_ATTR_IDENT
5066 #undef DEF_ATTR_TREE_LIST
5069 /* Attribute handlers common to C front ends. */
5071 /* Handle a "packed" attribute; arguments as in
5072 struct attribute_spec.handler. */
5075 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5076 int flags
, bool *no_add_attrs
)
5080 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5081 *node
= build_variant_type_copy (*node
);
5082 TYPE_PACKED (*node
) = 1;
5084 else if (TREE_CODE (*node
) == FIELD_DECL
)
5086 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
)
5087 warning (OPT_Wattributes
,
5088 "%qE attribute ignored for field of type %qT",
5089 name
, TREE_TYPE (*node
));
5091 DECL_PACKED (*node
) = 1;
5093 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5094 used for DECL_REGISTER. It wouldn't mean anything anyway.
5095 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5096 that changes what the typedef is typing. */
5099 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5100 *no_add_attrs
= true;
5106 /* Handle a "nocommon" attribute; arguments as in
5107 struct attribute_spec.handler. */
5110 handle_nocommon_attribute (tree
*node
, tree name
,
5111 tree
ARG_UNUSED (args
),
5112 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5114 if (TREE_CODE (*node
) == VAR_DECL
)
5115 DECL_COMMON (*node
) = 0;
5118 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5119 *no_add_attrs
= true;
5125 /* Handle a "common" attribute; arguments as in
5126 struct attribute_spec.handler. */
5129 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5130 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5132 if (TREE_CODE (*node
) == VAR_DECL
)
5133 DECL_COMMON (*node
) = 1;
5136 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5137 *no_add_attrs
= true;
5143 /* Handle a "noreturn" attribute; arguments as in
5144 struct attribute_spec.handler. */
5147 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5148 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5150 tree type
= TREE_TYPE (*node
);
5152 /* See FIXME comment in c_common_attribute_table. */
5153 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5154 TREE_THIS_VOLATILE (*node
) = 1;
5155 else if (TREE_CODE (type
) == POINTER_TYPE
5156 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5158 = build_pointer_type
5159 (build_type_variant (TREE_TYPE (type
),
5160 TYPE_READONLY (TREE_TYPE (type
)), 1));
5163 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5164 *no_add_attrs
= true;
5170 /* Handle a "hot" and attribute; arguments as in
5171 struct attribute_spec.handler. */
5174 handle_hot_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5175 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5177 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5179 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node
)) != NULL
)
5181 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5183 *no_add_attrs
= true;
5187 tree old_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
);
5189 /* If we are not at -O3, but are optimizing, turn on -O3
5190 optimizations just for this one function. */
5191 if (((optimize
> 0 && optimize
< 3) || optimize_size
)
5192 && targetm
.target_option
.hot_attribute_sets_optimization
5193 && (!old_opts
|| old_opts
== optimization_default_node
))
5195 /* Create the hot optimization node if needed. */
5196 if (!optimization_hot_node
)
5198 struct cl_optimization current_options
;
5199 static const char *os_argv
[] = { NULL
, "-O3", NULL
};
5201 cl_optimization_save (¤t_options
);
5202 decode_options (2, os_argv
);
5203 optimization_hot_node
= build_optimization_node ();
5204 cl_optimization_restore (¤t_options
);
5207 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
)
5208 = optimization_hot_node
;
5210 /* Most of the rest of the hot processing is done later with
5211 lookup_attribute. */
5216 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5217 *no_add_attrs
= true;
5222 /* Handle a "cold" and attribute; arguments as in
5223 struct attribute_spec.handler. */
5226 handle_cold_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5227 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5229 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5231 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node
)) != NULL
)
5233 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5235 *no_add_attrs
= true;
5239 tree old_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
);
5241 /* If we are optimizing, but not optimizing for space, turn on -Os
5242 optimizations just for this one function. */
5243 if (optimize
&& !optimize_size
5244 && targetm
.target_option
.cold_attribute_sets_optimization
5245 && (!old_opts
|| old_opts
== optimization_default_node
))
5247 /* Create the cold optimization node if needed. */
5248 if (!optimization_cold_node
)
5250 struct cl_optimization current_options
;
5251 static const char *os_argv
[] = { NULL
, "-Os", NULL
};
5253 cl_optimization_save (¤t_options
);
5254 decode_options (2, os_argv
);
5255 optimization_cold_node
= build_optimization_node ();
5256 cl_optimization_restore (¤t_options
);
5259 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
)
5260 = optimization_cold_node
;
5262 /* Most of the rest of the cold processing is done later with
5263 lookup_attribute. */
5268 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5269 *no_add_attrs
= true;
5275 /* Handle a "noinline" attribute; arguments as in
5276 struct attribute_spec.handler. */
5279 handle_noinline_attribute (tree
*node
, tree name
,
5280 tree
ARG_UNUSED (args
),
5281 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5283 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5284 DECL_UNINLINABLE (*node
) = 1;
5287 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5288 *no_add_attrs
= true;
5294 /* Handle a "always_inline" attribute; arguments as in
5295 struct attribute_spec.handler. */
5298 handle_always_inline_attribute (tree
*node
, tree name
,
5299 tree
ARG_UNUSED (args
),
5300 int ARG_UNUSED (flags
),
5303 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5305 /* Set the attribute and mark it for disregarding inline
5307 DECL_DISREGARD_INLINE_LIMITS (*node
) = 1;
5311 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5312 *no_add_attrs
= true;
5318 /* Handle a "gnu_inline" attribute; arguments as in
5319 struct attribute_spec.handler. */
5322 handle_gnu_inline_attribute (tree
*node
, tree name
,
5323 tree
ARG_UNUSED (args
),
5324 int ARG_UNUSED (flags
),
5327 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
5329 /* Do nothing else, just set the attribute. We'll get at
5330 it later with lookup_attribute. */
5334 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5335 *no_add_attrs
= true;
5341 /* Handle an "artificial" attribute; arguments as in
5342 struct attribute_spec.handler. */
5345 handle_artificial_attribute (tree
*node
, tree name
,
5346 tree
ARG_UNUSED (args
),
5347 int ARG_UNUSED (flags
),
5350 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
5352 /* Do nothing else, just set the attribute. We'll get at
5353 it later with lookup_attribute. */
5357 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5358 *no_add_attrs
= true;
5364 /* Handle a "flatten" attribute; arguments as in
5365 struct attribute_spec.handler. */
5368 handle_flatten_attribute (tree
*node
, tree name
,
5369 tree args ATTRIBUTE_UNUSED
,
5370 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
5372 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5373 /* Do nothing else, just set the attribute. We'll get at
5374 it later with lookup_attribute. */
5378 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5379 *no_add_attrs
= true;
5385 /* Handle a "warning" or "error" attribute; arguments as in
5386 struct attribute_spec.handler. */
5389 handle_error_attribute (tree
*node
, tree name
, tree args
,
5390 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5392 if (TREE_CODE (*node
) == FUNCTION_DECL
5393 || TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5394 /* Do nothing else, just set the attribute. We'll get at
5395 it later with lookup_attribute. */
5399 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5400 *no_add_attrs
= true;
5406 /* Handle a "used" attribute; arguments as in
5407 struct attribute_spec.handler. */
5410 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
5411 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5415 if (TREE_CODE (node
) == FUNCTION_DECL
5416 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
5418 TREE_USED (node
) = 1;
5419 DECL_PRESERVE_P (node
) = 1;
5423 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5424 *no_add_attrs
= true;
5430 /* Handle a "unused" attribute; arguments as in
5431 struct attribute_spec.handler. */
5434 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5435 int flags
, bool *no_add_attrs
)
5441 if (TREE_CODE (decl
) == PARM_DECL
5442 || TREE_CODE (decl
) == VAR_DECL
5443 || TREE_CODE (decl
) == FUNCTION_DECL
5444 || TREE_CODE (decl
) == LABEL_DECL
5445 || TREE_CODE (decl
) == TYPE_DECL
)
5446 TREE_USED (decl
) = 1;
5449 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5450 *no_add_attrs
= true;
5455 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5456 *node
= build_variant_type_copy (*node
);
5457 TREE_USED (*node
) = 1;
5463 /* Handle a "externally_visible" attribute; arguments as in
5464 struct attribute_spec.handler. */
5467 handle_externally_visible_attribute (tree
*pnode
, tree name
,
5468 tree
ARG_UNUSED (args
),
5469 int ARG_UNUSED (flags
),
5474 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
5476 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
5477 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
5479 warning (OPT_Wattributes
,
5480 "%qE attribute have effect only on public objects", name
);
5481 *no_add_attrs
= true;
5486 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5487 *no_add_attrs
= true;
5493 /* Handle a "const" attribute; arguments as in
5494 struct attribute_spec.handler. */
5497 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5498 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5500 tree type
= TREE_TYPE (*node
);
5502 /* See FIXME comment on noreturn in c_common_attribute_table. */
5503 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5504 TREE_READONLY (*node
) = 1;
5505 else if (TREE_CODE (type
) == POINTER_TYPE
5506 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5508 = build_pointer_type
5509 (build_type_variant (TREE_TYPE (type
), 1,
5510 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
5513 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5514 *no_add_attrs
= true;
5520 /* Handle a "transparent_union" attribute; arguments as in
5521 struct attribute_spec.handler. */
5524 handle_transparent_union_attribute (tree
*node
, tree name
,
5525 tree
ARG_UNUSED (args
), int flags
,
5530 *no_add_attrs
= true;
5532 if (TREE_CODE (*node
) == TYPE_DECL
)
5533 node
= &TREE_TYPE (*node
);
5536 if (TREE_CODE (type
) == UNION_TYPE
)
5538 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5539 the code in finish_struct. */
5540 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5542 if (TYPE_FIELDS (type
) == NULL_TREE
5543 || TYPE_MODE (type
) != DECL_MODE (TYPE_FIELDS (type
)))
5546 /* A type variant isn't good enough, since we don't a cast
5547 to such a type removed as a no-op. */
5548 *node
= type
= build_duplicate_type (type
);
5551 TYPE_TRANSPARENT_UNION (type
) = 1;
5556 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5560 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
5561 get the requested priority for a constructor or destructor,
5562 possibly issuing diagnostics for invalid or reserved
5565 static priority_type
5566 get_priority (tree args
, bool is_destructor
)
5572 return DEFAULT_INIT_PRIORITY
;
5574 if (!SUPPORTS_INIT_PRIORITY
)
5577 error ("destructor priorities are not supported");
5579 error ("constructor priorities are not supported");
5580 return DEFAULT_INIT_PRIORITY
;
5583 arg
= TREE_VALUE (args
);
5584 if (!host_integerp (arg
, /*pos=*/0)
5585 || !INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
5588 pri
= tree_low_cst (TREE_VALUE (args
), /*pos=*/0);
5589 if (pri
< 0 || pri
> MAX_INIT_PRIORITY
)
5592 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
5596 "destructor priorities from 0 to %d are reserved "
5597 "for the implementation",
5598 MAX_RESERVED_INIT_PRIORITY
);
5601 "constructor priorities from 0 to %d are reserved "
5602 "for the implementation",
5603 MAX_RESERVED_INIT_PRIORITY
);
5609 error ("destructor priorities must be integers from 0 to %d inclusive",
5612 error ("constructor priorities must be integers from 0 to %d inclusive",
5614 return DEFAULT_INIT_PRIORITY
;
5617 /* Handle a "constructor" attribute; arguments as in
5618 struct attribute_spec.handler. */
5621 handle_constructor_attribute (tree
*node
, tree name
, tree args
,
5622 int ARG_UNUSED (flags
),
5626 tree type
= TREE_TYPE (decl
);
5628 if (TREE_CODE (decl
) == FUNCTION_DECL
5629 && TREE_CODE (type
) == FUNCTION_TYPE
5630 && decl_function_context (decl
) == 0)
5632 priority_type priority
;
5633 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
5634 priority
= get_priority (args
, /*is_destructor=*/false);
5635 SET_DECL_INIT_PRIORITY (decl
, priority
);
5636 TREE_USED (decl
) = 1;
5640 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5641 *no_add_attrs
= true;
5647 /* Handle a "destructor" attribute; arguments as in
5648 struct attribute_spec.handler. */
5651 handle_destructor_attribute (tree
*node
, tree name
, tree args
,
5652 int ARG_UNUSED (flags
),
5656 tree type
= TREE_TYPE (decl
);
5658 if (TREE_CODE (decl
) == FUNCTION_DECL
5659 && TREE_CODE (type
) == FUNCTION_TYPE
5660 && decl_function_context (decl
) == 0)
5662 priority_type priority
;
5663 DECL_STATIC_DESTRUCTOR (decl
) = 1;
5664 priority
= get_priority (args
, /*is_destructor=*/true);
5665 SET_DECL_FINI_PRIORITY (decl
, priority
);
5666 TREE_USED (decl
) = 1;
5670 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5671 *no_add_attrs
= true;
5677 /* Handle a "mode" attribute; arguments as in
5678 struct attribute_spec.handler. */
5681 handle_mode_attribute (tree
*node
, tree name
, tree args
,
5682 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5686 *no_add_attrs
= true;
5688 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
5689 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5693 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
5694 int len
= strlen (p
);
5695 enum machine_mode mode
= VOIDmode
;
5699 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
5700 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
5702 char *newp
= (char *) alloca (len
- 1);
5704 strcpy (newp
, &p
[2]);
5705 newp
[len
- 4] = '\0';
5709 /* Change this type to have a type with the specified mode.
5710 First check for the special modes. */
5711 if (!strcmp (p
, "byte"))
5713 else if (!strcmp (p
, "word"))
5715 else if (!strcmp (p
, "pointer"))
5717 else if (!strcmp (p
, "libgcc_cmp_return"))
5718 mode
= targetm
.libgcc_cmp_return_mode ();
5719 else if (!strcmp (p
, "libgcc_shift_count"))
5720 mode
= targetm
.libgcc_shift_count_mode ();
5721 else if (!strcmp (p
, "unwind_word"))
5722 mode
= targetm
.unwind_word_mode ();
5724 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
5725 if (!strcmp (p
, GET_MODE_NAME (j
)))
5727 mode
= (enum machine_mode
) j
;
5731 if (mode
== VOIDmode
)
5733 error ("unknown machine mode %qs", p
);
5738 switch (GET_MODE_CLASS (mode
))
5741 case MODE_PARTIAL_INT
:
5743 case MODE_DECIMAL_FLOAT
:
5748 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
5751 case MODE_COMPLEX_INT
:
5752 case MODE_COMPLEX_FLOAT
:
5753 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
5756 case MODE_VECTOR_INT
:
5757 case MODE_VECTOR_FLOAT
:
5758 case MODE_VECTOR_FRACT
:
5759 case MODE_VECTOR_UFRACT
:
5760 case MODE_VECTOR_ACCUM
:
5761 case MODE_VECTOR_UACCUM
:
5762 warning (OPT_Wattributes
, "specifying vector types with "
5763 "__attribute__ ((mode)) is deprecated");
5764 warning (OPT_Wattributes
,
5765 "use __attribute__ ((vector_size)) instead");
5766 valid_mode
= vector_mode_valid_p (mode
);
5774 error ("unable to emulate %qs", p
);
5778 if (POINTER_TYPE_P (type
))
5780 tree (*fn
)(tree
, enum machine_mode
, bool);
5782 if (!targetm
.valid_pointer_mode (mode
))
5784 error ("invalid pointer mode %qs", p
);
5788 if (TREE_CODE (type
) == POINTER_TYPE
)
5789 fn
= build_pointer_type_for_mode
;
5791 fn
= build_reference_type_for_mode
;
5792 typefm
= fn (TREE_TYPE (type
), mode
, false);
5796 /* For fixed-point modes, we need to test if the signness of type
5797 and the machine mode are consistent. */
5798 if (ALL_FIXED_POINT_MODE_P (mode
)
5799 && TYPE_UNSIGNED (type
) != UNSIGNED_FIXED_POINT_MODE_P (mode
))
5801 error ("signness of type and machine mode %qs don't match", p
);
5804 /* For fixed-point modes, we need to pass saturating info. */
5805 typefm
= lang_hooks
.types
.type_for_mode (mode
,
5806 ALL_FIXED_POINT_MODE_P (mode
) ? TYPE_SATURATING (type
)
5807 : TYPE_UNSIGNED (type
));
5810 if (typefm
== NULL_TREE
)
5812 error ("no data type for mode %qs", p
);
5815 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
5817 /* For enumeral types, copy the precision from the integer
5818 type returned above. If not an INTEGER_TYPE, we can't use
5819 this mode for this type. */
5820 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
5822 error ("cannot use mode %qs for enumeral types", p
);
5826 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
5828 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
5833 /* We cannot build a type variant, as there's code that assumes
5834 that TYPE_MAIN_VARIANT has the same mode. This includes the
5835 debug generators. Instead, create a subrange type. This
5836 results in all of the enumeral values being emitted only once
5837 in the original, and the subtype gets them by reference. */
5838 if (TYPE_UNSIGNED (type
))
5839 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
5841 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
5842 TREE_TYPE (typefm
) = type
;
5845 else if (VECTOR_MODE_P (mode
)
5846 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
5847 : TREE_CODE (type
) != TREE_CODE (typefm
))
5849 error ("mode %qs applied to inappropriate type", p
);
5859 /* Handle a "section" attribute; arguments as in
5860 struct attribute_spec.handler. */
5863 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
5864 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5868 if (targetm
.have_named_sections
)
5870 user_defined_section_attribute
= true;
5872 if ((TREE_CODE (decl
) == FUNCTION_DECL
5873 || TREE_CODE (decl
) == VAR_DECL
)
5874 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5876 if (TREE_CODE (decl
) == VAR_DECL
5877 && current_function_decl
!= NULL_TREE
5878 && !TREE_STATIC (decl
))
5880 error ("%Jsection attribute cannot be specified for "
5881 "local variables", decl
);
5882 *no_add_attrs
= true;
5885 /* The decl may have already been given a section attribute
5886 from a previous declaration. Ensure they match. */
5887 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
5888 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
5889 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
5891 error ("section of %q+D conflicts with previous declaration",
5893 *no_add_attrs
= true;
5895 else if (TREE_CODE (decl
) == VAR_DECL
5896 && !targetm
.have_tls
&& targetm
.emutls
.tmpl_section
5897 && DECL_THREAD_LOCAL_P (decl
))
5899 error ("section of %q+D cannot be overridden", *node
);
5900 *no_add_attrs
= true;
5903 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
5907 error ("section attribute not allowed for %q+D", *node
);
5908 *no_add_attrs
= true;
5913 error ("%Jsection attributes are not supported for this target", *node
);
5914 *no_add_attrs
= true;
5920 /* Handle a "aligned" attribute; arguments as in
5921 struct attribute_spec.handler. */
5924 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
5925 int flags
, bool *no_add_attrs
)
5927 tree decl
= NULL_TREE
;
5930 tree align_expr
= (args
? TREE_VALUE (args
)
5931 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
5937 type
= &TREE_TYPE (decl
);
5938 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5940 else if (TYPE_P (*node
))
5941 type
= node
, is_type
= 1;
5943 if (TREE_CODE (align_expr
) != INTEGER_CST
)
5945 error ("requested alignment is not a constant");
5946 *no_add_attrs
= true;
5948 else if ((i
= tree_log2 (align_expr
)) == -1)
5950 error ("requested alignment is not a power of 2");
5951 *no_add_attrs
= true;
5953 else if (i
> HOST_BITS_PER_INT
- 2)
5955 error ("requested alignment is too large");
5956 *no_add_attrs
= true;
5960 /* If we have a TYPE_DECL, then copy the type, so that we
5961 don't accidentally modify a builtin type. See pushdecl. */
5962 if (decl
&& TREE_TYPE (decl
) != error_mark_node
5963 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
5965 tree tt
= TREE_TYPE (decl
);
5966 *type
= build_variant_type_copy (*type
);
5967 DECL_ORIGINAL_TYPE (decl
) = tt
;
5968 TYPE_NAME (*type
) = decl
;
5969 TREE_USED (*type
) = TREE_USED (decl
);
5970 TREE_TYPE (decl
) = *type
;
5972 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5973 *type
= build_variant_type_copy (*type
);
5975 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
5976 TYPE_USER_ALIGN (*type
) = 1;
5978 else if (! VAR_OR_FUNCTION_DECL_P (decl
)
5979 && TREE_CODE (decl
) != FIELD_DECL
)
5981 error ("alignment may not be specified for %q+D", decl
);
5982 *no_add_attrs
= true;
5984 else if (TREE_CODE (decl
) == FUNCTION_DECL
5985 && DECL_ALIGN (decl
) > (1 << i
) * BITS_PER_UNIT
)
5987 if (DECL_USER_ALIGN (decl
))
5988 error ("alignment for %q+D was previously specified as %d "
5989 "and may not be decreased", decl
,
5990 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
5992 error ("alignment for %q+D must be at least %d", decl
,
5993 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
5994 *no_add_attrs
= true;
5998 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
5999 DECL_USER_ALIGN (decl
) = 1;
6005 /* Handle a "weak" attribute; arguments as in
6006 struct attribute_spec.handler. */
6009 handle_weak_attribute (tree
*node
, tree name
,
6010 tree
ARG_UNUSED (args
),
6011 int ARG_UNUSED (flags
),
6012 bool * ARG_UNUSED (no_add_attrs
))
6014 if (TREE_CODE (*node
) == FUNCTION_DECL
6015 && DECL_DECLARED_INLINE_P (*node
))
6017 error ("inline function %q+D cannot be declared weak", *node
);
6018 *no_add_attrs
= true;
6020 else if (TREE_CODE (*node
) == FUNCTION_DECL
6021 || TREE_CODE (*node
) == VAR_DECL
)
6022 declare_weak (*node
);
6024 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6029 /* Handle an "alias" attribute; arguments as in
6030 struct attribute_spec.handler. */
6033 handle_alias_attribute (tree
*node
, tree name
, tree args
,
6034 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6038 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
6039 || (TREE_CODE (decl
) != FUNCTION_DECL
6040 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
6041 /* A static variable declaration is always a tentative definition,
6042 but the alias is a non-tentative definition which overrides. */
6043 || (TREE_CODE (decl
) != FUNCTION_DECL
6044 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
6046 error ("%q+D defined both normally and as an alias", decl
);
6047 *no_add_attrs
= true;
6050 /* Note that the very first time we process a nested declaration,
6051 decl_function_context will not be set. Indeed, *would* never
6052 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6053 we do below. After such frobbery, pushdecl would set the context.
6054 In any case, this is never what we want. */
6055 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
6059 id
= TREE_VALUE (args
);
6060 if (TREE_CODE (id
) != STRING_CST
)
6062 error ("alias argument not a string");
6063 *no_add_attrs
= true;
6066 id
= get_identifier (TREE_STRING_POINTER (id
));
6067 /* This counts as a use of the object pointed to. */
6070 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6071 DECL_INITIAL (decl
) = error_mark_node
;
6074 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
6075 DECL_EXTERNAL (decl
) = 1;
6077 DECL_EXTERNAL (decl
) = 0;
6078 TREE_STATIC (decl
) = 1;
6083 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6084 *no_add_attrs
= true;
6090 /* Handle a "weakref" attribute; arguments as in struct
6091 attribute_spec.handler. */
6094 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6095 int flags
, bool *no_add_attrs
)
6097 tree attr
= NULL_TREE
;
6099 /* We must ignore the attribute when it is associated with
6100 local-scoped decls, since attribute alias is ignored and many
6101 such symbols do not even have a DECL_WEAK field. */
6102 if (decl_function_context (*node
) || current_function_decl
)
6104 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6105 *no_add_attrs
= true;
6109 /* The idea here is that `weakref("name")' mutates into `weakref,
6110 alias("name")', and weakref without arguments, in turn,
6111 implicitly adds weak. */
6115 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
6116 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
6118 *no_add_attrs
= true;
6120 decl_attributes (node
, attr
, flags
);
6124 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
6125 error ("%Jweakref attribute must appear before alias attribute",
6128 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6129 and that isn't supported; and because it wants to add it to
6130 the list of weak decls, which isn't helpful. */
6131 DECL_WEAK (*node
) = 1;
6137 /* Handle an "visibility" attribute; arguments as in
6138 struct attribute_spec.handler. */
6141 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
6142 int ARG_UNUSED (flags
),
6143 bool *ARG_UNUSED (no_add_attrs
))
6146 tree id
= TREE_VALUE (args
);
6147 enum symbol_visibility vis
;
6151 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
6153 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
6155 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
6159 else if (TYPE_FIELDS (*node
))
6161 error ("%qE attribute ignored because %qT is already defined",
6166 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
6168 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6172 if (TREE_CODE (id
) != STRING_CST
)
6174 error ("visibility argument not a string");
6178 /* If this is a type, set the visibility on the type decl. */
6181 decl
= TYPE_NAME (decl
);
6184 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6186 warning (OPT_Wattributes
, "%qE attribute ignored on types",
6192 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
6193 vis
= VISIBILITY_DEFAULT
;
6194 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
6195 vis
= VISIBILITY_INTERNAL
;
6196 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
6197 vis
= VISIBILITY_HIDDEN
;
6198 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
6199 vis
= VISIBILITY_PROTECTED
;
6202 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6203 vis
= VISIBILITY_DEFAULT
;
6206 if (DECL_VISIBILITY_SPECIFIED (decl
)
6207 && vis
!= DECL_VISIBILITY (decl
))
6209 tree attributes
= (TYPE_P (*node
)
6210 ? TYPE_ATTRIBUTES (*node
)
6211 : DECL_ATTRIBUTES (decl
));
6212 if (lookup_attribute ("visibility", attributes
))
6213 error ("%qD redeclared with different visibility", decl
);
6214 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6215 && lookup_attribute ("dllimport", attributes
))
6216 error ("%qD was declared %qs which implies default visibility",
6218 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6219 && lookup_attribute ("dllexport", attributes
))
6220 error ("%qD was declared %qs which implies default visibility",
6224 DECL_VISIBILITY (decl
) = vis
;
6225 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
6227 /* Go ahead and attach the attribute to the node as well. This is needed
6228 so we can determine whether we have VISIBILITY_DEFAULT because the
6229 visibility was not specified, or because it was explicitly overridden
6230 from the containing scope. */
6235 /* Determine the ELF symbol visibility for DECL, which is either a
6236 variable or a function. It is an error to use this function if a
6237 definition of DECL is not available in this translation unit.
6238 Returns true if the final visibility has been determined by this
6239 function; false if the caller is free to make additional
6243 c_determine_visibility (tree decl
)
6245 gcc_assert (TREE_CODE (decl
) == VAR_DECL
6246 || TREE_CODE (decl
) == FUNCTION_DECL
);
6248 /* If the user explicitly specified the visibility with an
6249 attribute, honor that. DECL_VISIBILITY will have been set during
6250 the processing of the attribute. We check for an explicit
6251 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6252 to distinguish the use of an attribute from the use of a "#pragma
6253 GCC visibility push(...)"; in the latter case we still want other
6254 considerations to be able to overrule the #pragma. */
6255 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
6256 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6257 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
6258 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
6261 /* Set default visibility to whatever the user supplied with
6262 visibility_specified depending on #pragma GCC visibility. */
6263 if (!DECL_VISIBILITY_SPECIFIED (decl
))
6265 DECL_VISIBILITY (decl
) = default_visibility
;
6266 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
6271 /* Handle an "tls_model" attribute; arguments as in
6272 struct attribute_spec.handler. */
6275 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
6276 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6280 enum tls_model kind
;
6282 *no_add_attrs
= true;
6284 if (!DECL_THREAD_LOCAL_P (decl
))
6286 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6290 kind
= DECL_TLS_MODEL (decl
);
6291 id
= TREE_VALUE (args
);
6292 if (TREE_CODE (id
) != STRING_CST
)
6294 error ("tls_model argument not a string");
6298 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
6299 kind
= TLS_MODEL_LOCAL_EXEC
;
6300 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
6301 kind
= TLS_MODEL_INITIAL_EXEC
;
6302 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
6303 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
6304 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
6305 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
6307 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6309 DECL_TLS_MODEL (decl
) = kind
;
6313 /* Handle a "no_instrument_function" attribute; arguments as in
6314 struct attribute_spec.handler. */
6317 handle_no_instrument_function_attribute (tree
*node
, tree name
,
6318 tree
ARG_UNUSED (args
),
6319 int ARG_UNUSED (flags
),
6324 if (TREE_CODE (decl
) != FUNCTION_DECL
)
6326 error ("%J%qE attribute applies only to functions", decl
, name
);
6327 *no_add_attrs
= true;
6329 else if (DECL_INITIAL (decl
))
6331 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
6332 *no_add_attrs
= true;
6335 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
6340 /* Handle a "malloc" attribute; arguments as in
6341 struct attribute_spec.handler. */
6344 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6345 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6347 if (TREE_CODE (*node
) == FUNCTION_DECL
6348 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
6349 DECL_IS_MALLOC (*node
) = 1;
6352 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6353 *no_add_attrs
= true;
6359 /* Handle a "alloc_size" attribute; arguments as in
6360 struct attribute_spec.handler. */
6363 handle_alloc_size_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6364 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6366 unsigned arg_count
= type_num_arguments (*node
);
6367 for (; args
; args
= TREE_CHAIN (args
))
6369 tree position
= TREE_VALUE (args
);
6371 if (TREE_CODE (position
) != INTEGER_CST
6372 || TREE_INT_CST_HIGH (position
)
6373 || TREE_INT_CST_LOW (position
) < 1
6374 || TREE_INT_CST_LOW (position
) > arg_count
)
6376 warning (OPT_Wattributes
,
6377 "alloc_size parameter outside range");
6378 *no_add_attrs
= true;
6385 /* Handle a "returns_twice" attribute; arguments as in
6386 struct attribute_spec.handler. */
6389 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6390 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6392 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6393 DECL_IS_RETURNS_TWICE (*node
) = 1;
6396 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6397 *no_add_attrs
= true;
6403 /* Handle a "no_limit_stack" attribute; arguments as in
6404 struct attribute_spec.handler. */
6407 handle_no_limit_stack_attribute (tree
*node
, tree name
,
6408 tree
ARG_UNUSED (args
),
6409 int ARG_UNUSED (flags
),
6414 if (TREE_CODE (decl
) != FUNCTION_DECL
)
6416 error ("%J%qE attribute applies only to functions", decl
, name
);
6417 *no_add_attrs
= true;
6419 else if (DECL_INITIAL (decl
))
6421 error ("%Jcan%'t set %qE attribute after definition", decl
, name
);
6422 *no_add_attrs
= true;
6425 DECL_NO_LIMIT_STACK (decl
) = 1;
6430 /* Handle a "pure" attribute; arguments as in
6431 struct attribute_spec.handler. */
6434 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6435 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6437 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6438 DECL_PURE_P (*node
) = 1;
6439 /* ??? TODO: Support types. */
6442 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6443 *no_add_attrs
= true;
6449 /* Handle a "no vops" attribute; arguments as in
6450 struct attribute_spec.handler. */
6453 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
6454 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
6455 bool *ARG_UNUSED (no_add_attrs
))
6457 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
6458 DECL_IS_NOVOPS (*node
) = 1;
6462 /* Handle a "deprecated" attribute; arguments as in
6463 struct attribute_spec.handler. */
6466 handle_deprecated_attribute (tree
*node
, tree name
,
6467 tree
ARG_UNUSED (args
), int flags
,
6470 tree type
= NULL_TREE
;
6472 tree what
= NULL_TREE
;
6477 type
= TREE_TYPE (decl
);
6479 if (TREE_CODE (decl
) == TYPE_DECL
6480 || TREE_CODE (decl
) == PARM_DECL
6481 || TREE_CODE (decl
) == VAR_DECL
6482 || TREE_CODE (decl
) == FUNCTION_DECL
6483 || TREE_CODE (decl
) == FIELD_DECL
)
6484 TREE_DEPRECATED (decl
) = 1;
6488 else if (TYPE_P (*node
))
6490 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6491 *node
= build_variant_type_copy (*node
);
6492 TREE_DEPRECATED (*node
) = 1;
6500 *no_add_attrs
= true;
6501 if (type
&& TYPE_NAME (type
))
6503 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
6504 what
= TYPE_NAME (*node
);
6505 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
6506 && DECL_NAME (TYPE_NAME (type
)))
6507 what
= DECL_NAME (TYPE_NAME (type
));
6510 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
6512 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6518 /* Handle a "vector_size" attribute; arguments as in
6519 struct attribute_spec.handler. */
6522 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
6523 int ARG_UNUSED (flags
),
6526 unsigned HOST_WIDE_INT vecsize
, nunits
;
6527 enum machine_mode orig_mode
;
6528 tree type
= *node
, new_type
, size
;
6530 *no_add_attrs
= true;
6532 size
= TREE_VALUE (args
);
6534 if (!host_integerp (size
, 1))
6536 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6540 /* Get the vector size (in bytes). */
6541 vecsize
= tree_low_cst (size
, 1);
6543 /* We need to provide for vector pointers, vector arrays, and
6544 functions returning vectors. For example:
6546 __attribute__((vector_size(16))) short *foo;
6548 In this case, the mode is SI, but the type being modified is
6549 HI, so we need to look further. */
6551 while (POINTER_TYPE_P (type
)
6552 || TREE_CODE (type
) == FUNCTION_TYPE
6553 || TREE_CODE (type
) == METHOD_TYPE
6554 || TREE_CODE (type
) == ARRAY_TYPE
6555 || TREE_CODE (type
) == OFFSET_TYPE
)
6556 type
= TREE_TYPE (type
);
6558 /* Get the mode of the type being modified. */
6559 orig_mode
= TYPE_MODE (type
);
6561 if ((!INTEGRAL_TYPE_P (type
)
6562 && !SCALAR_FLOAT_TYPE_P (type
)
6563 && !FIXED_POINT_TYPE_P (type
))
6564 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
6565 && GET_MODE_CLASS (orig_mode
) != MODE_INT
6566 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode
))
6567 || !host_integerp (TYPE_SIZE_UNIT (type
), 1))
6569 error ("invalid vector type for attribute %qE", name
);
6573 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
6575 error ("vector size not an integral multiple of component size");
6581 error ("zero vector size");
6585 /* Calculate how many units fit in the vector. */
6586 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
6587 if (nunits
& (nunits
- 1))
6589 error ("number of components of the vector not a power of two");
6593 new_type
= build_vector_type (type
, nunits
);
6595 /* Build back pointers if needed. */
6596 *node
= lang_hooks
.types
.reconstruct_complex_type (*node
, new_type
);
6601 /* Handle the "nonnull" attribute. */
6603 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
6604 tree args
, int ARG_UNUSED (flags
),
6608 unsigned HOST_WIDE_INT attr_arg_num
;
6610 /* If no arguments are specified, all pointer arguments should be
6611 non-null. Verify a full prototype is given so that the arguments
6612 will have the correct types when we actually check them later. */
6615 if (!TYPE_ARG_TYPES (type
))
6617 error ("nonnull attribute without arguments on a non-prototype");
6618 *no_add_attrs
= true;
6623 /* Argument list specified. Verify that each argument number references
6624 a pointer argument. */
6625 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
6628 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
6630 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
6632 error ("nonnull argument has invalid operand number (argument %lu)",
6633 (unsigned long) attr_arg_num
);
6634 *no_add_attrs
= true;
6638 argument
= TYPE_ARG_TYPES (type
);
6641 for (ck_num
= 1; ; ck_num
++)
6643 if (!argument
|| ck_num
== arg_num
)
6645 argument
= TREE_CHAIN (argument
);
6649 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
6651 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6652 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
6653 *no_add_attrs
= true;
6657 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
6659 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6660 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
6661 *no_add_attrs
= true;
6670 /* Check the argument list of a function call for null in argument slots
6671 that are marked as requiring a non-null pointer argument. The NARGS
6672 arguments are passed in the array ARGARRAY.
6676 check_function_nonnull (tree attrs
, int nargs
, tree
*argarray
)
6681 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
6683 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
6685 args
= TREE_VALUE (a
);
6687 /* Walk the argument list. If we encounter an argument number we
6688 should check for non-null, do it. If the attribute has no args,
6689 then every pointer argument is checked (in which case the check
6690 for pointer type is done in check_nonnull_arg). */
6691 for (i
= 0; i
< nargs
; i
++)
6693 if (!args
|| nonnull_check_p (args
, i
+ 1))
6694 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
6702 /* Check that the Nth argument of a function call (counting backwards
6703 from the end) is a (pointer)0. The NARGS arguments are passed in the
6707 check_function_sentinel (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
6709 tree attr
= lookup_attribute ("sentinel", attrs
);
6717 /* Skip over the named arguments. */
6718 while (typelist
&& len
< nargs
)
6720 typelist
= TREE_CHAIN (typelist
);
6724 if (TREE_VALUE (attr
))
6726 tree p
= TREE_VALUE (TREE_VALUE (attr
));
6727 pos
= TREE_INT_CST_LOW (p
);
6730 /* The sentinel must be one of the varargs, i.e.
6731 in position >= the number of fixed arguments. */
6732 if ((nargs
- 1 - pos
) < len
)
6734 warning (OPT_Wformat
,
6735 "not enough variable arguments to fit a sentinel");
6739 /* Validate the sentinel. */
6740 sentinel
= argarray
[nargs
- 1 - pos
];
6741 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
6742 || !integer_zerop (sentinel
))
6743 /* Although __null (in C++) is only an integer we allow it
6744 nevertheless, as we are guaranteed that it's exactly
6745 as wide as a pointer, and we don't want to force
6746 users to cast the NULL they have written there.
6747 We warn with -Wstrict-null-sentinel, though. */
6748 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
6749 warning (OPT_Wformat
, "missing sentinel in function call");
6753 /* Helper for check_function_nonnull; given a list of operands which
6754 must be non-null in ARGS, determine if operand PARAM_NUM should be
6758 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
6760 unsigned HOST_WIDE_INT arg_num
= 0;
6762 for (; args
; args
= TREE_CHAIN (args
))
6764 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
6768 if (arg_num
== param_num
)
6774 /* Check that the function argument PARAM (which is operand number
6775 PARAM_NUM) is non-null. This is called by check_function_nonnull
6776 via check_function_arguments_recurse. */
6779 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
6780 unsigned HOST_WIDE_INT param_num
)
6782 /* Just skip checking the argument if it's not a pointer. This can
6783 happen if the "nonnull" attribute was given without an operand
6784 list (which means to check every pointer argument). */
6786 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
6789 if (integer_zerop (param
))
6790 warning (OPT_Wnonnull
, "null argument where non-null required "
6791 "(argument %lu)", (unsigned long) param_num
);
6794 /* Helper for nonnull attribute handling; fetch the operand number
6795 from the attribute argument list. */
6798 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
6800 /* Verify the arg number is a constant. */
6801 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
6802 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
6805 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
6809 /* Handle a "nothrow" attribute; arguments as in
6810 struct attribute_spec.handler. */
6813 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6814 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6816 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6817 TREE_NOTHROW (*node
) = 1;
6818 /* ??? TODO: Support types. */
6821 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6822 *no_add_attrs
= true;
6828 /* Handle a "cleanup" attribute; arguments as in
6829 struct attribute_spec.handler. */
6832 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
6833 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6836 tree cleanup_id
, cleanup_decl
;
6838 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6839 for global destructors in C++. This requires infrastructure that
6840 we don't have generically at the moment. It's also not a feature
6841 we'd be missing too much, since we do have attribute constructor. */
6842 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
6844 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6845 *no_add_attrs
= true;
6849 /* Verify that the argument is a function in scope. */
6850 /* ??? We could support pointers to functions here as well, if
6851 that was considered desirable. */
6852 cleanup_id
= TREE_VALUE (args
);
6853 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
6855 error ("cleanup argument not an identifier");
6856 *no_add_attrs
= true;
6859 cleanup_decl
= lookup_name (cleanup_id
);
6860 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
6862 error ("cleanup argument not a function");
6863 *no_add_attrs
= true;
6867 /* That the function has proper type is checked with the
6868 eventual call to build_function_call. */
6873 /* Handle a "warn_unused_result" attribute. No special handling. */
6876 handle_warn_unused_result_attribute (tree
*node
, tree name
,
6877 tree
ARG_UNUSED (args
),
6878 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6880 /* Ignore the attribute for functions not returning any value. */
6881 if (VOID_TYPE_P (TREE_TYPE (*node
)))
6883 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6884 *no_add_attrs
= true;
6890 /* Handle a "sentinel" attribute. */
6893 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
6894 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6896 tree params
= TYPE_ARG_TYPES (*node
);
6900 warning (OPT_Wattributes
,
6901 "%qE attribute requires prototypes with named arguments", name
);
6902 *no_add_attrs
= true;
6906 while (TREE_CHAIN (params
))
6907 params
= TREE_CHAIN (params
);
6909 if (VOID_TYPE_P (TREE_VALUE (params
)))
6911 warning (OPT_Wattributes
,
6912 "%qE attribute only applies to variadic functions", name
);
6913 *no_add_attrs
= true;
6919 tree position
= TREE_VALUE (args
);
6921 if (TREE_CODE (position
) != INTEGER_CST
)
6923 warning (OPT_Wattributes
,
6924 "requested position is not an integer constant");
6925 *no_add_attrs
= true;
6929 if (tree_int_cst_lt (position
, integer_zero_node
))
6931 warning (OPT_Wattributes
,
6932 "requested position is less than zero");
6933 *no_add_attrs
= true;
6941 /* Handle a "type_generic" attribute. */
6944 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
6945 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
6946 bool * ARG_UNUSED (no_add_attrs
))
6950 /* Ensure we have a function type. */
6951 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
6953 params
= TYPE_ARG_TYPES (*node
);
6954 while (params
&& ! VOID_TYPE_P (TREE_VALUE (params
)))
6955 params
= TREE_CHAIN (params
);
6957 /* Ensure we have a variadic function. */
6958 gcc_assert (!params
);
6963 /* For handling "option" attribute. arguments as in
6964 struct attribute_spec.handler. */
6967 handle_option_attribute (tree
*node
, tree name
, tree args
, int flags
,
6970 /* Ensure we have a function type. */
6971 if (TREE_CODE (*node
) != FUNCTION_DECL
)
6973 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6974 *no_add_attrs
= true;
6976 else if (targetm
.target_option
.valid_attribute_p
6977 == default_target_option_valid_attribute_p
)
6979 warning (OPT_Wattributes
,
6980 "%qE attribute is not supported on this machine",
6982 *no_add_attrs
= true;
6984 else if (! targetm
.target_option
.valid_attribute_p (*node
, name
, args
,
6986 *no_add_attrs
= true;
6991 /* Arguments being collected for optimization. */
6992 typedef const char *const_char_p
; /* For DEF_VEC_P. */
6993 DEF_VEC_P(const_char_p
);
6994 DEF_VEC_ALLOC_P(const_char_p
, gc
);
6995 static GTY(()) VEC(const_char_p
, gc
) *optimize_args
;
6998 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
6999 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7000 false for #pragma GCC optimize. */
7003 parse_optimize_options (tree args
, bool attr_p
)
7008 const char **opt_argv
;
7011 /* Build up argv vector. Just in case the string is stored away, use garbage
7012 collected strings. */
7013 VEC_truncate (const_char_p
, optimize_args
, 0);
7014 VEC_safe_push (const_char_p
, gc
, optimize_args
, NULL
);
7016 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
7018 tree value
= TREE_VALUE (ap
);
7020 if (TREE_CODE (value
) == INTEGER_CST
)
7023 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
7024 VEC_safe_push (const_char_p
, gc
, optimize_args
, ggc_strdup (buffer
));
7027 else if (TREE_CODE (value
) == STRING_CST
)
7029 /* Split string into multiple substrings. */
7030 size_t len
= TREE_STRING_LENGTH (value
);
7031 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
7032 char *end
= p
+ len
;
7036 while (next_p
!= NULL
)
7042 comma
= strchr (p
, ',');
7055 r
= q
= (char *) ggc_alloc (len2
+ 3);
7057 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7059 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
7063 warning (OPT_Wattributes
,
7064 "Bad option %s to optimize attribute.", p
);
7066 warning (OPT_Wpragmas
,
7067 "Bad option %s to pragma attribute", p
);
7075 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7076 itself is -Os, and any other switch begins with a -f. */
7077 if ((*p
>= '0' && *p
<= '9')
7078 || (p
[0] == 's' && p
[1] == '\0'))
7084 memcpy (r
, p
, len2
);
7086 VEC_safe_push (const_char_p
, gc
, optimize_args
, q
);
7092 opt_argc
= VEC_length (const_char_p
, optimize_args
);
7093 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
7095 for (i
= 1; i
< opt_argc
; i
++)
7096 opt_argv
[i
] = VEC_index (const_char_p
, optimize_args
, i
);
7098 /* Now parse the options. */
7099 decode_options (opt_argc
, opt_argv
);
7101 VEC_truncate (const_char_p
, optimize_args
, 0);
7105 /* For handling "optimize" attribute. arguments as in
7106 struct attribute_spec.handler. */
7109 handle_optimize_attribute (tree
*node
, tree name
, tree args
,
7110 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7112 /* Ensure we have a function type. */
7113 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7115 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7116 *no_add_attrs
= true;
7120 struct cl_optimization cur_opts
;
7121 tree old_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
);
7123 /* Save current options. */
7124 cl_optimization_save (&cur_opts
);
7126 /* If we previously had some optimization options, use them as the
7129 cl_optimization_restore (TREE_OPTIMIZATION (old_opts
));
7131 /* Parse options, and update the vector. */
7132 parse_optimize_options (args
, true);
7133 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
)
7134 = build_optimization_node ();
7136 /* Restore current options. */
7137 cl_optimization_restore (&cur_opts
);
7143 /* Check for valid arguments being passed to a function.
7144 ATTRS is a list of attributes. There are NARGS arguments in the array
7145 ARGARRAY. TYPELIST is the list of argument types for the function.
7148 check_function_arguments (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7150 /* Check for null being passed in a pointer argument that must be
7151 non-null. We also need to do this if format checking is enabled. */
7154 check_function_nonnull (attrs
, nargs
, argarray
);
7156 /* Check for errors in format strings. */
7158 if (warn_format
|| warn_missing_format_attribute
)
7159 check_function_format (attrs
, nargs
, argarray
);
7162 check_function_sentinel (attrs
, nargs
, argarray
, typelist
);
7165 /* Generic argument checking recursion routine. PARAM is the argument to
7166 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7167 once the argument is resolved. CTX is context for the callback. */
7169 check_function_arguments_recurse (void (*callback
)
7170 (void *, tree
, unsigned HOST_WIDE_INT
),
7171 void *ctx
, tree param
,
7172 unsigned HOST_WIDE_INT param_num
)
7174 if (CONVERT_EXPR_P (param
)
7175 && (TYPE_PRECISION (TREE_TYPE (param
))
7176 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
7178 /* Strip coercion. */
7179 check_function_arguments_recurse (callback
, ctx
,
7180 TREE_OPERAND (param
, 0), param_num
);
7184 if (TREE_CODE (param
) == CALL_EXPR
)
7186 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
7188 bool found_format_arg
= false;
7190 /* See if this is a call to a known internationalization function
7191 that modifies a format arg. Such a function may have multiple
7192 format_arg attributes (for example, ngettext). */
7194 for (attrs
= TYPE_ATTRIBUTES (type
);
7196 attrs
= TREE_CHAIN (attrs
))
7197 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
7200 tree format_num_expr
;
7203 call_expr_arg_iterator iter
;
7205 /* Extract the argument number, which was previously checked
7207 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
7209 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
7210 && !TREE_INT_CST_HIGH (format_num_expr
));
7212 format_num
= TREE_INT_CST_LOW (format_num_expr
);
7214 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
7216 inner_arg
= next_call_expr_arg (&iter
), i
++)
7217 if (i
== format_num
)
7219 check_function_arguments_recurse (callback
, ctx
,
7220 inner_arg
, param_num
);
7221 found_format_arg
= true;
7226 /* If we found a format_arg attribute and did a recursive check,
7227 we are done with checking this argument. Otherwise, we continue
7228 and this will be considered a non-literal. */
7229 if (found_format_arg
)
7233 if (TREE_CODE (param
) == COND_EXPR
)
7235 /* Check both halves of the conditional expression. */
7236 check_function_arguments_recurse (callback
, ctx
,
7237 TREE_OPERAND (param
, 1), param_num
);
7238 check_function_arguments_recurse (callback
, ctx
,
7239 TREE_OPERAND (param
, 2), param_num
);
7243 (*callback
) (ctx
, param
, param_num
);
7246 /* Checks the number of arguments NARGS against the required number
7247 REQUIRED and issues an error if there is a mismatch. Returns true
7248 if the number of arguments is correct, otherwise false. */
7251 validate_nargs (tree fndecl
, int nargs
, int required
)
7253 if (nargs
< required
)
7255 error ("not enough arguments to function %qE", fndecl
);
7258 else if (nargs
> required
)
7260 error ("too many arguments to function %qE", fndecl
);
7266 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7267 Returns false if there was an error, otherwise true. */
7270 check_builtin_function_arguments (tree fndecl
, int nargs
, tree
*args
)
7272 if (!DECL_BUILT_IN (fndecl
)
7273 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
7276 switch (DECL_FUNCTION_CODE (fndecl
))
7278 case BUILT_IN_CONSTANT_P
:
7279 return validate_nargs (fndecl
, nargs
, 1);
7281 case BUILT_IN_ISFINITE
:
7282 case BUILT_IN_ISINF
:
7283 case BUILT_IN_ISINF_SIGN
:
7284 case BUILT_IN_ISNAN
:
7285 case BUILT_IN_ISNORMAL
:
7286 if (validate_nargs (fndecl
, nargs
, 1))
7288 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
7290 error ("non-floating-point argument in call to "
7291 "function %qE", fndecl
);
7298 case BUILT_IN_ISGREATER
:
7299 case BUILT_IN_ISGREATEREQUAL
:
7300 case BUILT_IN_ISLESS
:
7301 case BUILT_IN_ISLESSEQUAL
:
7302 case BUILT_IN_ISLESSGREATER
:
7303 case BUILT_IN_ISUNORDERED
:
7304 if (validate_nargs (fndecl
, nargs
, 2))
7306 enum tree_code code0
, code1
;
7307 code0
= TREE_CODE (TREE_TYPE (args
[0]));
7308 code1
= TREE_CODE (TREE_TYPE (args
[1]));
7309 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
7310 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
7311 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
7313 error ("non-floating-point arguments in call to "
7314 "function %qE", fndecl
);
7321 case BUILT_IN_FPCLASSIFY
:
7322 if (validate_nargs (fndecl
, nargs
, 6))
7327 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
7329 error ("non-const integer argument %u in call to function %qE",
7334 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
7336 error ("non-floating-point argument in call to function %qE",
7349 /* Function to help qsort sort FIELD_DECLs by name order. */
7352 field_decl_cmp (const void *x_p
, const void *y_p
)
7354 const tree
*const x
= (const tree
*const) x_p
;
7355 const tree
*const y
= (const tree
*const) y_p
;
7357 if (DECL_NAME (*x
) == DECL_NAME (*y
))
7358 /* A nontype is "greater" than a type. */
7359 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
7360 if (DECL_NAME (*x
) == NULL_TREE
)
7362 if (DECL_NAME (*y
) == NULL_TREE
)
7364 if (DECL_NAME (*x
) < DECL_NAME (*y
))
7370 gt_pointer_operator new_value
;
7374 /* This routine compares two fields like field_decl_cmp but using the
7375 pointer operator in resort_data. */
7378 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
7380 const tree
*const x
= (const tree
*const) x_p
;
7381 const tree
*const y
= (const tree
*const) y_p
;
7383 if (DECL_NAME (*x
) == DECL_NAME (*y
))
7384 /* A nontype is "greater" than a type. */
7385 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
7386 if (DECL_NAME (*x
) == NULL_TREE
)
7388 if (DECL_NAME (*y
) == NULL_TREE
)
7391 tree d1
= DECL_NAME (*x
);
7392 tree d2
= DECL_NAME (*y
);
7393 resort_data
.new_value (&d1
, resort_data
.cookie
);
7394 resort_data
.new_value (&d2
, resort_data
.cookie
);
7401 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
7404 resort_sorted_fields (void *obj
,
7405 void * ARG_UNUSED (orig_obj
),
7406 gt_pointer_operator new_value
,
7409 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
7410 resort_data
.new_value
= new_value
;
7411 resort_data
.cookie
= cookie
;
7412 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
7413 resort_field_decl_cmp
);
7416 /* Subroutine of c_parse_error.
7417 Return the result of concatenating LHS and RHS. RHS is really
7418 a string literal, its first character is indicated by RHS_START and
7419 RHS_SIZE is its length (including the terminating NUL character).
7421 The caller is responsible for deleting the returned pointer. */
7424 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
7426 const int lhs_size
= strlen (lhs
);
7427 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
7428 strncpy (result
, lhs
, lhs_size
);
7429 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
7433 /* Issue the error given by GMSGID, indicating that it occurred before
7434 TOKEN, which had the associated VALUE. */
7437 c_parse_error (const char *gmsgid
, enum cpp_ttype token
, tree value
)
7439 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
7441 char *message
= NULL
;
7443 if (token
== CPP_EOF
)
7444 message
= catenate_messages (gmsgid
, " at end of input");
7445 else if (token
== CPP_CHAR
|| token
== CPP_WCHAR
|| token
== CPP_CHAR16
7446 || token
== CPP_CHAR32
)
7448 unsigned int val
= TREE_INT_CST_LOW (value
);
7467 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
7468 message
= catenate_messages (gmsgid
, " before %s'%c'");
7470 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
7472 error (message
, prefix
, val
);
7476 else if (token
== CPP_STRING
|| token
== CPP_WSTRING
|| token
== CPP_STRING16
7477 || token
== CPP_STRING32
)
7478 message
= catenate_messages (gmsgid
, " before string constant");
7479 else if (token
== CPP_NUMBER
)
7480 message
= catenate_messages (gmsgid
, " before numeric constant");
7481 else if (token
== CPP_NAME
)
7483 message
= catenate_messages (gmsgid
, " before %qE");
7484 error (message
, value
);
7488 else if (token
== CPP_PRAGMA
)
7489 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
7490 else if (token
== CPP_PRAGMA_EOL
)
7491 message
= catenate_messages (gmsgid
, " before end of line");
7492 else if (token
< N_TTYPES
)
7494 message
= catenate_messages (gmsgid
, " before %qs token");
7495 error (message
, cpp_type2name (token
));
7507 #undef catenate_messages
7510 /* Walk a gimplified function and warn for functions whose return value is
7511 ignored and attribute((warn_unused_result)) is set. This is done before
7512 inlining, so we don't have to worry about that. */
7515 c_warn_unused_result (gimple_seq seq
)
7518 gimple_stmt_iterator i
;
7520 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
7522 gimple g
= gsi_stmt (i
);
7524 switch (gimple_code (g
))
7527 c_warn_unused_result (gimple_bind_body (g
));
7530 c_warn_unused_result (gimple_try_eval (g
));
7531 c_warn_unused_result (gimple_try_cleanup (g
));
7534 c_warn_unused_result (gimple_catch_handler (g
));
7536 case GIMPLE_EH_FILTER
:
7537 c_warn_unused_result (gimple_eh_filter_failure (g
));
7541 if (gimple_call_lhs (g
))
7544 /* This is a naked call, as opposed to a GIMPLE_CALL with an
7545 LHS. All calls whose value is ignored should be
7546 represented like this. Look for the attribute. */
7547 fdecl
= gimple_call_fn (g
);
7548 if (TREE_CODE (fdecl
) == FUNCTION_DECL
)
7549 ftype
= TREE_TYPE (fdecl
);
7552 ftype
= TREE_TYPE (fdecl
);
7553 /* Look past pointer-to-function to the function type itself. */
7554 ftype
= TREE_TYPE (ftype
);
7557 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
7559 location_t loc
= gimple_location (g
);
7562 warning (0, "%Hignoring return value of %qD, "
7563 "declared with attribute warn_unused_result",
7566 warning (0, "%Hignoring return value of function "
7567 "declared with attribute warn_unused_result",
7573 /* Not a container, not a call, or a call whose value is used. */
7579 /* Convert a character from the host to the target execution character
7580 set. cpplib handles this, mostly. */
7583 c_common_to_target_charset (HOST_WIDE_INT c
)
7585 /* Character constants in GCC proper are sign-extended under -fsigned-char,
7586 zero-extended under -fno-signed-char. cpplib insists that characters
7587 and character constants are always unsigned. Hence we must convert
7589 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
7591 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
7593 if (flag_signed_char
)
7594 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
7595 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
7600 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
7601 component references, with STOP_REF, or alternatively an INDIRECT_REF of
7602 NULL, at the bottom; much like the traditional rendering of offsetof as a
7603 macro. Returns the folded and properly cast result. */
7606 fold_offsetof_1 (tree expr
, tree stop_ref
)
7608 enum tree_code code
= PLUS_EXPR
;
7611 if (expr
== stop_ref
&& TREE_CODE (expr
) != ERROR_MARK
)
7612 return size_zero_node
;
7614 switch (TREE_CODE (expr
))
7620 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
7621 return error_mark_node
;
7624 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7625 return error_mark_node
;
7628 gcc_assert (integer_zerop (expr
));
7629 return size_zero_node
;
7633 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
7634 gcc_assert (base
== error_mark_node
|| base
== size_zero_node
);
7638 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
7639 if (base
== error_mark_node
)
7642 t
= TREE_OPERAND (expr
, 1);
7643 if (DECL_C_BIT_FIELD (t
))
7645 error ("attempt to take address of bit-field structure "
7647 return error_mark_node
;
7649 off
= size_binop (PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
7650 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
), 1)
7655 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
7656 if (base
== error_mark_node
)
7659 t
= TREE_OPERAND (expr
, 1);
7660 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) < 0)
7663 t
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (t
), t
);
7665 t
= convert (sizetype
, t
);
7666 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
7670 /* Handle static members of volatile structs. */
7671 t
= TREE_OPERAND (expr
, 1);
7672 gcc_assert (TREE_CODE (t
) == VAR_DECL
);
7673 return fold_offsetof_1 (t
, stop_ref
);
7679 return size_binop (code
, base
, off
);
7683 fold_offsetof (tree expr
, tree stop_ref
)
7685 /* Convert back from the internal sizetype to size_t. */
7686 return convert (size_type_node
, fold_offsetof_1 (expr
, stop_ref
));
7689 /* Print an error message for an invalid lvalue. USE says
7690 how the lvalue is being used and so selects the error message. */
7693 lvalue_error (enum lvalue_use use
)
7698 error ("lvalue required as left operand of assignment");
7701 error ("lvalue required as increment operand");
7704 error ("lvalue required as decrement operand");
7707 error ("lvalue required as unary %<&%> operand");
7710 error ("lvalue required in asm statement");
7717 /* *PTYPE is an incomplete array. Complete it with a domain based on
7718 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7719 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7720 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
7723 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7725 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
7726 int failure
= 0, quals
;
7727 hashval_t hashcode
= 0;
7729 maxindex
= size_zero_node
;
7732 if (TREE_CODE (initial_value
) == STRING_CST
)
7735 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
7736 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
7738 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7740 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
7742 if (VEC_empty (constructor_elt
, v
))
7746 maxindex
= integer_minus_one_node
;
7751 unsigned HOST_WIDE_INT cnt
;
7752 constructor_elt
*ce
;
7754 if (VEC_index (constructor_elt
, v
, 0)->index
)
7755 maxindex
= fold_convert (sizetype
,
7756 VEC_index (constructor_elt
,
7758 curindex
= maxindex
;
7761 VEC_iterate (constructor_elt
, v
, cnt
, ce
);
7765 curindex
= fold_convert (sizetype
, ce
->index
);
7767 curindex
= size_binop (PLUS_EXPR
, curindex
, size_one_node
);
7769 if (tree_int_cst_lt (maxindex
, curindex
))
7770 maxindex
= curindex
;
7776 /* Make an error message unless that happened already. */
7777 if (initial_value
!= error_mark_node
)
7789 elt
= TREE_TYPE (type
);
7790 quals
= TYPE_QUALS (strip_array_types (elt
));
7794 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
7796 /* Using build_distinct_type_copy and modifying things afterward instead
7797 of using build_array_type to create a new type preserves all of the
7798 TYPE_LANG_FLAG_? bits that the front end may have set. */
7799 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
7800 TREE_TYPE (main_type
) = unqual_elt
;
7801 TYPE_DOMAIN (main_type
) = build_index_type (maxindex
);
7802 layout_type (main_type
);
7804 /* Make sure we have the canonical MAIN_TYPE. */
7805 hashcode
= iterative_hash_object (TYPE_HASH (unqual_elt
), hashcode
);
7806 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type
)),
7808 main_type
= type_hash_canon (hashcode
, main_type
);
7810 /* Fix the canonical type. */
7811 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
7812 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
7813 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
7814 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
7815 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
7816 != TYPE_DOMAIN (main_type
)))
7817 TYPE_CANONICAL (main_type
)
7818 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
7819 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)));
7821 TYPE_CANONICAL (main_type
) = main_type
;
7826 type
= c_build_qualified_type (main_type
, quals
);
7828 if (COMPLETE_TYPE_P (type
)
7829 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
7830 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
7832 error ("size of array is too large");
7833 /* If we proceed with the array type as it is, we'll eventually
7834 crash in tree_low_cst(). */
7835 type
= error_mark_node
;
7843 /* Used to help initialize the builtin-types.def table. When a type of
7844 the correct size doesn't exist, use error_mark_node instead of NULL.
7845 The later results in segfaults even when a decl using the type doesn't
7849 builtin_type_for_size (int size
, bool unsignedp
)
7851 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
7852 return type
? type
: error_mark_node
;
7855 /* A helper function for resolve_overloaded_builtin in resolving the
7856 overloaded __sync_ builtins. Returns a positive power of 2 if the
7857 first operand of PARAMS is a pointer to a supported data type.
7858 Returns 0 if an error is encountered. */
7861 sync_resolve_size (tree function
, tree params
)
7868 error ("too few arguments to function %qE", function
);
7872 type
= TREE_TYPE (TREE_VALUE (params
));
7873 if (TREE_CODE (type
) != POINTER_TYPE
)
7876 type
= TREE_TYPE (type
);
7877 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
7880 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
7881 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
7885 error ("incompatible type for argument %d of %qE", 1, function
);
7889 /* A helper function for resolve_overloaded_builtin. Adds casts to
7890 PARAMS to make arguments match up with those of FUNCTION. Drops
7891 the variadic arguments at the end. Returns false if some error
7892 was encountered; true on success. */
7895 sync_resolve_params (tree orig_function
, tree function
, tree params
)
7897 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
7901 /* We've declared the implementation functions to use "volatile void *"
7902 as the pointer parameter, so we shouldn't get any complaints from the
7903 call to check_function_arguments what ever type the user used. */
7904 arg_types
= TREE_CHAIN (arg_types
);
7905 ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
7908 /* For the rest of the values, we need to cast these to FTYPE, so that we
7909 don't get warnings for passing pointer types, etc. */
7910 while (arg_types
!= void_list_node
)
7914 params
= TREE_CHAIN (params
);
7917 error ("too few arguments to function %qE", orig_function
);
7921 /* ??? Ideally for the first conversion we'd use convert_for_assignment
7922 so that we get warnings for anything that doesn't match the pointer
7923 type. This isn't portable across the C and C++ front ends atm. */
7924 val
= TREE_VALUE (params
);
7925 val
= convert (ptype
, val
);
7926 val
= convert (TREE_VALUE (arg_types
), val
);
7927 TREE_VALUE (params
) = val
;
7929 arg_types
= TREE_CHAIN (arg_types
);
7933 /* The definition of these primitives is variadic, with the remaining
7934 being "an optional list of variables protected by the memory barrier".
7935 No clue what that's supposed to mean, precisely, but we consider all
7936 call-clobbered variables to be protected so we're safe. */
7937 TREE_CHAIN (params
) = NULL
;
7942 /* A helper function for resolve_overloaded_builtin. Adds a cast to
7943 RESULT to make it match the type of the first pointer argument in
7947 sync_resolve_return (tree params
, tree result
)
7949 tree ptype
= TREE_TYPE (TREE_TYPE (TREE_VALUE (params
)));
7950 ptype
= TYPE_MAIN_VARIANT (ptype
);
7951 return convert (ptype
, result
);
7954 /* Some builtin functions are placeholders for other expressions. This
7955 function should be called immediately after parsing the call expression
7956 before surrounding code has committed to the type of the expression.
7958 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7959 PARAMS is the argument list for the call. The return value is non-null
7960 when expansion is complete, and null if normal processing should
7964 resolve_overloaded_builtin (tree function
, tree params
)
7966 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
7967 switch (DECL_BUILT_IN_CLASS (function
))
7969 case BUILT_IN_NORMAL
:
7972 if (targetm
.resolve_overloaded_builtin
)
7973 return targetm
.resolve_overloaded_builtin (function
, params
);
7980 /* Handle BUILT_IN_NORMAL here. */
7983 case BUILT_IN_FETCH_AND_ADD_N
:
7984 case BUILT_IN_FETCH_AND_SUB_N
:
7985 case BUILT_IN_FETCH_AND_OR_N
:
7986 case BUILT_IN_FETCH_AND_AND_N
:
7987 case BUILT_IN_FETCH_AND_XOR_N
:
7988 case BUILT_IN_FETCH_AND_NAND_N
:
7989 case BUILT_IN_ADD_AND_FETCH_N
:
7990 case BUILT_IN_SUB_AND_FETCH_N
:
7991 case BUILT_IN_OR_AND_FETCH_N
:
7992 case BUILT_IN_AND_AND_FETCH_N
:
7993 case BUILT_IN_XOR_AND_FETCH_N
:
7994 case BUILT_IN_NAND_AND_FETCH_N
:
7995 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N
:
7996 case BUILT_IN_VAL_COMPARE_AND_SWAP_N
:
7997 case BUILT_IN_LOCK_TEST_AND_SET_N
:
7998 case BUILT_IN_LOCK_RELEASE_N
:
8000 int n
= sync_resolve_size (function
, params
);
8001 tree new_function
, result
;
8004 return error_mark_node
;
8006 new_function
= built_in_decls
[orig_code
+ exact_log2 (n
) + 1];
8007 if (!sync_resolve_params (function
, new_function
, params
))
8008 return error_mark_node
;
8010 result
= build_function_call (new_function
, params
);
8011 if (orig_code
!= BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8012 && orig_code
!= BUILT_IN_LOCK_RELEASE_N
)
8013 result
= sync_resolve_return (params
, result
);
8023 /* Ignoring their sign, return true if two scalar types are the same. */
8025 same_scalar_type_ignoring_signedness (tree t1
, tree t2
)
8027 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
8029 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
|| c1
== FIXED_POINT_TYPE
)
8030 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
8031 || c2
== FIXED_POINT_TYPE
));
8033 /* Equality works here because c_common_signed_type uses
8034 TYPE_MAIN_VARIANT. */
8035 return c_common_signed_type (t1
)
8036 == c_common_signed_type (t2
);
8039 /* Check for missing format attributes on function pointers. LTYPE is
8040 the new type or left-hand side type. RTYPE is the old type or
8041 right-hand side type. Returns TRUE if LTYPE is missing the desired
8045 check_missing_format_attribute (tree ltype
, tree rtype
)
8047 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
8050 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
8051 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
8056 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
8057 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
8065 /* Subscripting with type char is likely to lose on a machine where
8066 chars are signed. So warn on any machine, but optionally. Don't
8067 warn for unsigned char since that type is safe. Don't warn for
8068 signed char because anyone who uses that must have done so
8069 deliberately. Furthermore, we reduce the false positive load by
8070 warning only for non-constant value of type char. */
8073 warn_array_subscript_with_type_char (tree index
)
8075 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
8076 && TREE_CODE (index
) != INTEGER_CST
)
8077 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
8080 /* Implement -Wparentheses for the unexpected C precedence rules, to
8081 cover cases like x + y << z which readers are likely to
8082 misinterpret. We have seen an expression in which CODE is a binary
8083 operator used to combine expressions headed by CODE_LEFT and
8084 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
8085 means that that side of the expression was not formed using a
8086 binary operator, or it was enclosed in parentheses. */
8089 warn_about_parentheses (enum tree_code code
, enum tree_code code_left
,
8090 enum tree_code code_right
)
8092 if (!warn_parentheses
)
8095 if (code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
8097 if (code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8098 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8099 warning (OPT_Wparentheses
,
8100 "suggest parentheses around + or - inside shift");
8103 if (code
== TRUTH_ORIF_EXPR
)
8105 if (code_left
== TRUTH_ANDIF_EXPR
8106 || code_right
== TRUTH_ANDIF_EXPR
)
8107 warning (OPT_Wparentheses
,
8108 "suggest parentheses around && within ||");
8111 if (code
== BIT_IOR_EXPR
)
8113 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
8114 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8115 || code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
8116 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8117 warning (OPT_Wparentheses
,
8118 "suggest parentheses around arithmetic in operand of |");
8119 /* Check cases like x|y==z */
8120 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8121 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8122 warning (OPT_Wparentheses
,
8123 "suggest parentheses around comparison in operand of |");
8126 if (code
== BIT_XOR_EXPR
)
8128 if (code_left
== BIT_AND_EXPR
8129 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8130 || code_right
== BIT_AND_EXPR
8131 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8132 warning (OPT_Wparentheses
,
8133 "suggest parentheses around arithmetic in operand of ^");
8134 /* Check cases like x^y==z */
8135 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8136 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8137 warning (OPT_Wparentheses
,
8138 "suggest parentheses around comparison in operand of ^");
8141 if (code
== BIT_AND_EXPR
)
8143 if (code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8144 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8145 warning (OPT_Wparentheses
,
8146 "suggest parentheses around + or - in operand of &");
8147 /* Check cases like x&y==z */
8148 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8149 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8150 warning (OPT_Wparentheses
,
8151 "suggest parentheses around comparison in operand of &");
8154 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
8156 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8157 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8158 warning (OPT_Wparentheses
,
8159 "suggest parentheses around comparison in operand of %s",
8160 code
== EQ_EXPR
? "==" : "!=");
8162 else if (TREE_CODE_CLASS (code
) == tcc_comparison
)
8164 if ((TREE_CODE_CLASS (code_left
) == tcc_comparison
8165 && code_left
!= NE_EXPR
&& code_left
!= EQ_EXPR
)
8166 || (TREE_CODE_CLASS (code_right
) == tcc_comparison
8167 && code_right
!= NE_EXPR
&& code_right
!= EQ_EXPR
))
8168 warning (OPT_Wparentheses
, "comparisons like X<=Y<=Z do not "
8169 "have their mathematical meaning");
8173 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8176 warn_for_unused_label (tree label
)
8178 if (!TREE_USED (label
))
8180 if (DECL_INITIAL (label
))
8181 warning (OPT_Wunused_label
, "label %q+D defined but not used", label
);
8183 warning (OPT_Wunused_label
, "label %q+D declared but not defined", label
);
8187 #ifndef TARGET_HAS_TARGETCM
8188 struct gcc_targetcm targetcm
= TARGETCM_INITIALIZER
;
8191 /* Warn for division by zero according to the value of DIVISOR. */
8194 warn_for_div_by_zero (tree divisor
)
8196 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8197 about division by zero. Do not issue a warning if DIVISOR has a
8198 floating-point type, since we consider 0.0/0.0 a valid way of
8199 generating a NaN. */
8200 if (skip_evaluation
== 0
8201 && (integer_zerop (divisor
) || fixed_zerop (divisor
)))
8202 warning (OPT_Wdiv_by_zero
, "division by zero");
8205 /* Subroutine of build_binary_op. Give warnings for comparisons
8206 between signed and unsigned quantities that may fail. Do the
8207 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8208 so that casts will be considered, but default promotions won't
8211 The arguments of this function map directly to local variables
8212 of build_binary_op. */
8215 warn_for_sign_compare (tree orig_op0
, tree orig_op1
,
8217 tree result_type
, enum tree_code resultcode
)
8219 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
8220 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
8221 int unsignedp0
, unsignedp1
;
8223 /* In C++, check for comparison of different enum types. */
8225 && TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
8226 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
8227 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
8228 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
8230 warning (OPT_Wsign_compare
, "comparison between types %qT and %qT",
8231 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
8234 /* Do not warn if the comparison is being done in a signed type,
8235 since the signed type will only be chosen if it can represent
8236 all the values of the unsigned type. */
8237 if (!TYPE_UNSIGNED (result_type
))
8239 /* Do not warn if both operands are unsigned. */
8240 else if (op0_signed
== op1_signed
)
8248 sop
= orig_op0
, uop
= orig_op1
;
8250 sop
= orig_op1
, uop
= orig_op0
;
8252 STRIP_TYPE_NOPS (sop
);
8253 STRIP_TYPE_NOPS (uop
);
8255 /* Do not warn if the signed quantity is an unsuffixed integer
8256 literal (or some static constant expression involving such
8257 literals or a conditional expression involving such literals)
8258 and it is non-negative. */
8259 if (tree_expr_nonnegative_warnv_p (sop
, &ovf
))
8261 /* Do not warn if the comparison is an equality operation, the
8262 unsigned quantity is an integral constant, and it would fit
8263 in the result if the result were signed. */
8264 else if (TREE_CODE (uop
) == INTEGER_CST
8265 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
8266 && int_fits_type_p (uop
, c_common_signed_type (result_type
)))
8268 /* In C, do not warn if the unsigned quantity is an enumeration
8269 constant and its maximum value would fit in the result if the
8270 result were signed. */
8271 else if (!c_dialect_cxx() && TREE_CODE (uop
) == INTEGER_CST
8272 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
8273 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
8274 c_common_signed_type (result_type
)))
8277 warning (OPT_Wsign_compare
,
8278 "comparison between signed and unsigned integer expressions");
8281 /* Warn if two unsigned values are being compared in a size larger
8282 than their original size, and one (and only one) is the result of
8283 a `~' operator. This comparison will always fail.
8285 Also warn if one operand is a constant, and the constant does not
8286 have all bits set that are set in the ~ operand when it is
8289 op0
= get_narrower (op0
, &unsignedp0
);
8290 op1
= get_narrower (op1
, &unsignedp1
);
8292 if ((TREE_CODE (op0
) == BIT_NOT_EXPR
)
8293 ^ (TREE_CODE (op1
) == BIT_NOT_EXPR
))
8295 if (TREE_CODE (op0
) == BIT_NOT_EXPR
)
8296 op0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
8297 if (TREE_CODE (op1
) == BIT_NOT_EXPR
)
8298 op1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
8300 if (host_integerp (op0
, 0) || host_integerp (op1
, 0))
8303 HOST_WIDE_INT constant
, mask
;
8307 if (host_integerp (op0
, 0))
8310 unsignedp
= unsignedp1
;
8311 constant
= tree_low_cst (op0
, 0);
8316 unsignedp
= unsignedp0
;
8317 constant
= tree_low_cst (op1
, 0);
8320 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
8321 if (bits
< TYPE_PRECISION (result_type
)
8322 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
8324 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
8325 if ((mask
& constant
) != mask
)
8328 warning (OPT_Wsign_compare
,
8329 "promoted ~unsigned is always non-zero");
8331 warning (OPT_Wsign_compare
,
8332 "comparison of promoted ~unsigned with constant");
8336 else if (unsignedp0
&& unsignedp1
8337 && (TYPE_PRECISION (TREE_TYPE (op0
))
8338 < TYPE_PRECISION (result_type
))
8339 && (TYPE_PRECISION (TREE_TYPE (op1
))
8340 < TYPE_PRECISION (result_type
)))
8341 warning (OPT_Wsign_compare
,
8342 "comparison of promoted ~unsigned with unsigned");
8346 #include "gt-c-common.h"