1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
40 #include "langhooks.h"
41 #include "tree-inline.h"
44 #include "diagnostic.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
51 #include "target-def.h"
53 #include "fixed-value.h"
56 cpp_reader
*parse_in
; /* Declared in c-pragma.h. */
58 /* The following symbols are subsumed in the c_global_trees array, and
59 listed here individually for documentation purposes.
61 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
63 tree short_integer_type_node;
64 tree long_integer_type_node;
65 tree long_long_integer_type_node;
67 tree short_unsigned_type_node;
68 tree long_unsigned_type_node;
69 tree long_long_unsigned_type_node;
71 tree truthvalue_type_node;
72 tree truthvalue_false_node;
73 tree truthvalue_true_node;
75 tree ptrdiff_type_node;
77 tree unsigned_char_type_node;
78 tree signed_char_type_node;
81 tree char16_type_node;
82 tree char32_type_node;
85 tree double_type_node;
86 tree long_double_type_node;
88 tree complex_integer_type_node;
89 tree complex_float_type_node;
90 tree complex_double_type_node;
91 tree complex_long_double_type_node;
93 tree dfloat32_type_node;
94 tree dfloat64_type_node;
95 tree_dfloat128_type_node;
100 tree intDI_type_node;
101 tree intTI_type_node;
103 tree unsigned_intQI_type_node;
104 tree unsigned_intHI_type_node;
105 tree unsigned_intSI_type_node;
106 tree unsigned_intDI_type_node;
107 tree unsigned_intTI_type_node;
109 tree widest_integer_literal_type_node;
110 tree widest_unsigned_literal_type_node;
112 Nodes for types `void *' and `const void *'.
114 tree ptr_type_node, const_ptr_type_node;
116 Nodes for types `char *' and `const char *'.
118 tree string_type_node, const_string_type_node;
120 Type `char[SOMENUMBER]'.
121 Used when an array of char is needed and the size is irrelevant.
123 tree char_array_type_node;
125 Type `int[SOMENUMBER]' or something like it.
126 Used when an array of int needed and the size is irrelevant.
128 tree int_array_type_node;
130 Type `wchar_t[SOMENUMBER]' or something like it.
131 Used when a wide string literal is created.
133 tree wchar_array_type_node;
135 Type `char16_t[SOMENUMBER]' or something like it.
136 Used when a UTF-16 string literal is created.
138 tree char16_array_type_node;
140 Type `char32_t[SOMENUMBER]' or something like it.
141 Used when a UTF-32 string literal is created.
143 tree char32_array_type_node;
145 Type `int ()' -- used for implicit declaration of functions.
147 tree default_function_type;
149 A VOID_TYPE node, packaged in a TREE_LIST.
153 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
154 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
155 VAR_DECLS, but C++ does.)
157 tree function_name_decl_node;
158 tree pretty_function_name_decl_node;
159 tree c99_function_name_decl_node;
161 Stack of nested function name VAR_DECLs.
163 tree saved_function_name_decls;
167 tree c_global_trees
[CTI_MAX
];
169 /* Switches common to the C front ends. */
171 /* Nonzero if preprocessing only. */
173 int flag_preprocess_only
;
175 /* Nonzero means don't output line number information. */
177 char flag_no_line_commands
;
179 /* Nonzero causes -E output not to be done, but directives such as
180 #define that have side effects are still obeyed. */
184 /* Nonzero means dump macros in some fashion. */
186 char flag_dump_macros
;
188 /* Nonzero means pass #include lines through to the output. */
190 char flag_dump_includes
;
192 /* Nonzero means process PCH files while preprocessing. */
194 bool flag_pch_preprocess
;
196 /* The file name to which we should write a precompiled header, or
197 NULL if no header will be written in this compile. */
199 const char *pch_file
;
201 /* Nonzero if an ISO standard was selected. It rejects macros in the
205 /* Nonzero if -undef was given. It suppresses target built-in macros
209 /* Nonzero means don't recognize the non-ANSI builtin functions. */
213 /* Nonzero means don't recognize the non-ANSI builtin functions.
216 int flag_no_nonansi_builtin
;
218 /* Nonzero means give `double' the same size as `float'. */
220 int flag_short_double
;
222 /* Nonzero means give `wchar_t' the same size as `short'. */
224 int flag_short_wchar
;
226 /* Nonzero means allow implicit conversions between vectors with
227 differing numbers of subparts and/or differing element types. */
228 int flag_lax_vector_conversions
;
230 /* Nonzero means allow Microsoft extensions without warnings or errors. */
231 int flag_ms_extensions
;
233 /* Nonzero means don't recognize the keyword `asm'. */
237 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
239 int flag_signed_bitfields
= 1;
241 /* Warn about #pragma directives that are not recognized. */
243 int warn_unknown_pragmas
; /* Tri state variable. */
245 /* Warn about format/argument anomalies in calls to formatted I/O functions
246 (*printf, *scanf, strftime, strfmon, etc.). */
250 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
251 with GCC this doesn't matter as __null is guaranteed to have the right
254 int warn_strict_null_sentinel
;
256 /* Zero means that faster, ...NonNil variants of objc_msgSend...
257 calls will be used in ObjC; passing nil receivers to such calls
258 will most likely result in crashes. */
259 int flag_nil_receivers
= 1;
261 /* Nonzero means that code generation will be altered to support
262 "zero-link" execution. This currently affects ObjC only, but may
263 affect other languages in the future. */
264 int flag_zero_link
= 0;
266 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
267 unit. It will inform the ObjC runtime that class definition(s) herein
268 contained are to replace one(s) previously loaded. */
269 int flag_replace_objc_classes
= 0;
271 /* C/ObjC language option variables. */
274 /* Nonzero means allow type mismatches in conditional expressions;
275 just make their values `void'. */
277 int flag_cond_mismatch
;
279 /* Nonzero means enable C89 Amendment 1 features. */
283 /* Nonzero means use the ISO C99 dialect of C. */
287 /* Nonzero means that we have builtin functions, and main is an int. */
292 /* ObjC language option variables. */
295 /* Open and close the file for outputting class declarations, if
298 int flag_gen_declaration
;
300 /* Tells the compiler that this is a special run. Do not perform any
301 compiling, instead we are to test some platform dependent features
302 and output a C header file with appropriate definitions. */
304 int print_struct_values
;
306 /* Tells the compiler what is the constant string class for ObjC. */
308 const char *constant_string_class_name
;
311 /* C++ language option variables. */
314 /* Nonzero means don't recognize any extension keywords. */
316 int flag_no_gnu_keywords
;
318 /* Nonzero means do emit exported implementations of functions even if
319 they can be inlined. */
321 int flag_implement_inlines
= 1;
323 /* Nonzero means that implicit instantiations will be emitted if needed. */
325 int flag_implicit_templates
= 1;
327 /* Nonzero means that implicit instantiations of inline templates will be
328 emitted if needed, even if instantiations of non-inline templates
331 int flag_implicit_inline_templates
= 1;
333 /* Nonzero means generate separate instantiation control files and
334 juggle them at link time. */
336 int flag_use_repository
;
338 /* Nonzero if we want to issue diagnostics that the standard says are not
341 int flag_optional_diags
= 1;
343 /* Nonzero means we should attempt to elide constructors when possible. */
345 int flag_elide_constructors
= 1;
347 /* Nonzero means that member functions defined in class scope are
348 inline by default. */
350 int flag_default_inline
= 1;
352 /* Controls whether compiler generates 'type descriptor' that give
353 run-time type information. */
357 /* Nonzero if we want to conserve space in the .o files. We do this
358 by putting uninitialized data and runtime initialized data into
359 .common instead of .data at the expense of not flagging multiple
362 int flag_conserve_space
;
364 /* Nonzero if we want to obey access control semantics. */
366 int flag_access_control
= 1;
368 /* Nonzero if we want to check the return value of new and avoid calling
369 constructors if it is a null pointer. */
373 /* The C++ dialect being used. C++98 is the default. */
375 enum cxx_dialect cxx_dialect
= cxx98
;
377 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
378 initialization variables.
379 0: Old rules, set by -fno-for-scope.
380 2: New ISO rules, set by -ffor-scope.
381 1: Try to implement new ISO rules, but with backup compatibility
382 (and warnings). This is the default, for now. */
384 int flag_new_for_scope
= 1;
386 /* Nonzero if we want to emit defined symbols with common-like linkage as
387 weak symbols where possible, in order to conform to C++ semantics.
388 Otherwise, emit them as local symbols. */
392 /* 0 means we want the preprocessor to not emit line directives for
393 the current working directory. 1 means we want it to do it. -1
394 means we should decide depending on whether debugging information
395 is being emitted or not. */
397 int flag_working_directory
= -1;
399 /* Nonzero to use __cxa_atexit, rather than atexit, to register
400 destructors for local statics and global objects. '2' means it has been
401 set nonzero as a default, not by a command-line flag. */
403 int flag_use_cxa_atexit
= DEFAULT_USE_CXA_ATEXIT
;
405 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
406 code. '2' means it has not been set explicitly on the command line. */
408 int flag_use_cxa_get_exception_ptr
= 2;
410 /* Nonzero means to implement standard semantics for exception
411 specifications, calling unexpected if an exception is thrown that
412 doesn't match the specification. Zero means to treat them as
413 assertions and optimize accordingly, but not check them. */
415 int flag_enforce_eh_specs
= 1;
417 /* Nonzero means to generate thread-safe code for initializing local
420 int flag_threadsafe_statics
= 1;
422 /* Nonzero if we want to pretty-print template specializations as the
423 template signature followed by the arguments. */
425 int flag_pretty_templates
= 1;
427 /* Nonzero means warn about implicit declarations. */
429 int warn_implicit
= 1;
431 /* Maximum template instantiation depth. This limit exists to limit the
432 time it takes to notice infinite template instantiations; the default
433 value of 1024 is likely to be in the next C++ standard. */
435 int max_tinst_depth
= 1024;
439 /* The elements of `ridpointers' are identifier nodes for the reserved
440 type names and storage classes. It is indexed by a RID_... value. */
443 tree (*make_fname_decl
) (location_t
, tree
, int);
445 /* Nonzero means don't warn about problems that occur when the code is
447 int c_inhibit_evaluation_warnings
;
449 /* Whether lexing has been completed, so subsequent preprocessor
450 errors should use the compiler's input_location. */
451 bool done_lexing
= false;
453 /* Information about how a function name is generated. */
456 tree
*const decl
; /* pointer to the VAR_DECL. */
457 const unsigned rid
; /* RID number for the identifier. */
458 const int pretty
; /* How pretty is it? */
461 /* The three ways of getting then name of the current function. */
463 const struct fname_var_t fname_vars
[] =
465 /* C99 compliant __func__, must be first. */
466 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
467 /* GCC __FUNCTION__ compliant. */
468 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
469 /* GCC __PRETTY_FUNCTION__ compliant. */
470 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
474 static tree
c_fully_fold_internal (tree expr
, bool, bool *, bool *);
475 static tree
check_case_value (tree
);
476 static bool check_case_bounds (tree
, tree
, tree
*, tree
*);
478 static tree
handle_packed_attribute (tree
*, tree
, tree
, int, bool *);
479 static tree
handle_nocommon_attribute (tree
*, tree
, tree
, int, bool *);
480 static tree
handle_common_attribute (tree
*, tree
, tree
, int, bool *);
481 static tree
handle_noreturn_attribute (tree
*, tree
, tree
, int, bool *);
482 static tree
handle_hot_attribute (tree
*, tree
, tree
, int, bool *);
483 static tree
handle_cold_attribute (tree
*, tree
, tree
, int, bool *);
484 static tree
handle_noinline_attribute (tree
*, tree
, tree
, int, bool *);
485 static tree
handle_noclone_attribute (tree
*, tree
, tree
, int, bool *);
486 static tree
handle_always_inline_attribute (tree
*, tree
, tree
, int,
488 static tree
handle_gnu_inline_attribute (tree
*, tree
, tree
, int, bool *);
489 static tree
handle_artificial_attribute (tree
*, tree
, tree
, int, bool *);
490 static tree
handle_flatten_attribute (tree
*, tree
, tree
, int, bool *);
491 static tree
handle_error_attribute (tree
*, tree
, tree
, int, bool *);
492 static tree
handle_used_attribute (tree
*, tree
, tree
, int, bool *);
493 static tree
handle_unused_attribute (tree
*, tree
, tree
, int, bool *);
494 static tree
handle_externally_visible_attribute (tree
*, tree
, tree
, int,
496 static tree
handle_const_attribute (tree
*, tree
, tree
, int, bool *);
497 static tree
handle_transparent_union_attribute (tree
*, tree
, tree
,
499 static tree
handle_constructor_attribute (tree
*, tree
, tree
, int, bool *);
500 static tree
handle_destructor_attribute (tree
*, tree
, tree
, int, bool *);
501 static tree
handle_mode_attribute (tree
*, tree
, tree
, int, bool *);
502 static tree
handle_section_attribute (tree
*, tree
, tree
, int, bool *);
503 static tree
handle_aligned_attribute (tree
*, tree
, tree
, int, bool *);
504 static tree
handle_weak_attribute (tree
*, tree
, tree
, int, bool *) ;
505 static tree
handle_alias_attribute (tree
*, tree
, tree
, int, bool *);
506 static tree
handle_weakref_attribute (tree
*, tree
, tree
, int, bool *) ;
507 static tree
handle_visibility_attribute (tree
*, tree
, tree
, int,
509 static tree
handle_tls_model_attribute (tree
*, tree
, tree
, int,
511 static tree
handle_no_instrument_function_attribute (tree
*, tree
,
513 static tree
handle_malloc_attribute (tree
*, tree
, tree
, int, bool *);
514 static tree
handle_returns_twice_attribute (tree
*, tree
, tree
, int, bool *);
515 static tree
handle_no_limit_stack_attribute (tree
*, tree
, tree
, int,
517 static tree
handle_pure_attribute (tree
*, tree
, tree
, int, bool *);
518 static tree
handle_novops_attribute (tree
*, tree
, tree
, int, bool *);
519 static tree
handle_deprecated_attribute (tree
*, tree
, tree
, int,
521 static tree
handle_vector_size_attribute (tree
*, tree
, tree
, int,
523 static tree
handle_nonnull_attribute (tree
*, tree
, tree
, int, bool *);
524 static tree
handle_nothrow_attribute (tree
*, tree
, tree
, int, bool *);
525 static tree
handle_cleanup_attribute (tree
*, tree
, tree
, int, bool *);
526 static tree
handle_warn_unused_result_attribute (tree
*, tree
, tree
, int,
528 static tree
handle_sentinel_attribute (tree
*, tree
, tree
, int, bool *);
529 static tree
handle_type_generic_attribute (tree
*, tree
, tree
, int, bool *);
530 static tree
handle_alloc_size_attribute (tree
*, tree
, tree
, int, bool *);
531 static tree
handle_target_attribute (tree
*, tree
, tree
, int, bool *);
532 static tree
handle_optimize_attribute (tree
*, tree
, tree
, int, bool *);
534 static void check_function_nonnull (tree
, int, tree
*);
535 static void check_nonnull_arg (void *, tree
, unsigned HOST_WIDE_INT
);
536 static bool nonnull_check_p (tree
, unsigned HOST_WIDE_INT
);
537 static bool get_nonnull_operand (tree
, unsigned HOST_WIDE_INT
*);
538 static int resort_field_decl_cmp (const void *, const void *);
540 /* Reserved words. The third field is a mask: keywords are disabled
541 if they match the mask.
544 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
545 C --std=c99: D_CXXONLY | D_OBJC
546 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
547 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
548 C++ --std=c0x: D_CONLY | D_OBJC
549 ObjC++ is like C++ except that D_OBJC is not set
551 If -fno-asm is used, D_ASM is added to the mask. If
552 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
553 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
554 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
556 const struct c_common_resword c_common_reswords
[] =
558 { "_Bool", RID_BOOL
, D_CONLY
},
559 { "_Complex", RID_COMPLEX
, 0 },
560 { "_Imaginary", RID_IMAGINARY
, D_CONLY
},
561 { "_Decimal32", RID_DFLOAT32
, D_CONLY
| D_EXT
},
562 { "_Decimal64", RID_DFLOAT64
, D_CONLY
| D_EXT
},
563 { "_Decimal128", RID_DFLOAT128
, D_CONLY
| D_EXT
},
564 { "_Fract", RID_FRACT
, D_CONLY
| D_EXT
},
565 { "_Accum", RID_ACCUM
, D_CONLY
| D_EXT
},
566 { "_Sat", RID_SAT
, D_CONLY
| D_EXT
},
567 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
568 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
569 { "__alignof", RID_ALIGNOF
, 0 },
570 { "__alignof__", RID_ALIGNOF
, 0 },
571 { "__asm", RID_ASM
, 0 },
572 { "__asm__", RID_ASM
, 0 },
573 { "__attribute", RID_ATTRIBUTE
, 0 },
574 { "__attribute__", RID_ATTRIBUTE
, 0 },
575 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, D_CONLY
},
576 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
577 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, D_CONLY
},
578 { "__builtin_va_arg", RID_VA_ARG
, 0 },
579 { "__complex", RID_COMPLEX
, 0 },
580 { "__complex__", RID_COMPLEX
, 0 },
581 { "__const", RID_CONST
, 0 },
582 { "__const__", RID_CONST
, 0 },
583 { "__decltype", RID_DECLTYPE
, D_CXXONLY
},
584 { "__extension__", RID_EXTENSION
, 0 },
585 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
586 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN
, D_CXXONLY
},
587 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR
, D_CXXONLY
},
588 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY
, D_CXXONLY
},
589 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN
, D_CXXONLY
},
590 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR
, D_CXXONLY
},
591 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY
, D_CXXONLY
},
592 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR
, D_CXXONLY
},
593 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR
, D_CXXONLY
},
594 { "__is_abstract", RID_IS_ABSTRACT
, D_CXXONLY
},
595 { "__is_base_of", RID_IS_BASE_OF
, D_CXXONLY
},
596 { "__is_class", RID_IS_CLASS
, D_CXXONLY
},
597 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO
, D_CXXONLY
},
598 { "__is_empty", RID_IS_EMPTY
, D_CXXONLY
},
599 { "__is_enum", RID_IS_ENUM
, D_CXXONLY
},
600 { "__is_pod", RID_IS_POD
, D_CXXONLY
},
601 { "__is_polymorphic", RID_IS_POLYMORPHIC
, D_CXXONLY
},
602 { "__is_standard_layout", RID_IS_STD_LAYOUT
, D_CXXONLY
},
603 { "__is_trivial", RID_IS_TRIVIAL
, D_CXXONLY
},
604 { "__is_union", RID_IS_UNION
, D_CXXONLY
},
605 { "__imag", RID_IMAGPART
, 0 },
606 { "__imag__", RID_IMAGPART
, 0 },
607 { "__inline", RID_INLINE
, 0 },
608 { "__inline__", RID_INLINE
, 0 },
609 { "__label__", RID_LABEL
, 0 },
610 { "__null", RID_NULL
, 0 },
611 { "__real", RID_REALPART
, 0 },
612 { "__real__", RID_REALPART
, 0 },
613 { "__restrict", RID_RESTRICT
, 0 },
614 { "__restrict__", RID_RESTRICT
, 0 },
615 { "__signed", RID_SIGNED
, 0 },
616 { "__signed__", RID_SIGNED
, 0 },
617 { "__thread", RID_THREAD
, 0 },
618 { "__typeof", RID_TYPEOF
, 0 },
619 { "__typeof__", RID_TYPEOF
, 0 },
620 { "__volatile", RID_VOLATILE
, 0 },
621 { "__volatile__", RID_VOLATILE
, 0 },
622 { "alignof", RID_ALIGNOF
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
623 { "asm", RID_ASM
, D_ASM
},
624 { "auto", RID_AUTO
, 0 },
625 { "bool", RID_BOOL
, D_CXXONLY
| D_CXXWARN
},
626 { "break", RID_BREAK
, 0 },
627 { "case", RID_CASE
, 0 },
628 { "catch", RID_CATCH
, D_CXX_OBJC
| D_CXXWARN
},
629 { "char", RID_CHAR
, 0 },
630 { "char16_t", RID_CHAR16
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
631 { "char32_t", RID_CHAR32
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
632 { "class", RID_CLASS
, D_CXX_OBJC
| D_CXXWARN
},
633 { "const", RID_CONST
, 0 },
634 { "const_cast", RID_CONSTCAST
, D_CXXONLY
| D_CXXWARN
},
635 { "continue", RID_CONTINUE
, 0 },
636 { "decltype", RID_DECLTYPE
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
637 { "default", RID_DEFAULT
, 0 },
638 { "delete", RID_DELETE
, D_CXXONLY
| D_CXXWARN
},
640 { "double", RID_DOUBLE
, 0 },
641 { "dynamic_cast", RID_DYNCAST
, D_CXXONLY
| D_CXXWARN
},
642 { "else", RID_ELSE
, 0 },
643 { "enum", RID_ENUM
, 0 },
644 { "explicit", RID_EXPLICIT
, D_CXXONLY
| D_CXXWARN
},
645 { "export", RID_EXPORT
, D_CXXONLY
| D_CXXWARN
},
646 { "extern", RID_EXTERN
, 0 },
647 { "false", RID_FALSE
, D_CXXONLY
| D_CXXWARN
},
648 { "float", RID_FLOAT
, 0 },
649 { "for", RID_FOR
, 0 },
650 { "friend", RID_FRIEND
, D_CXXONLY
| D_CXXWARN
},
651 { "goto", RID_GOTO
, 0 },
653 { "inline", RID_INLINE
, D_EXT89
},
654 { "int", RID_INT
, 0 },
655 { "long", RID_LONG
, 0 },
656 { "mutable", RID_MUTABLE
, D_CXXONLY
| D_CXXWARN
},
657 { "namespace", RID_NAMESPACE
, D_CXXONLY
| D_CXXWARN
},
658 { "new", RID_NEW
, D_CXXONLY
| D_CXXWARN
},
659 { "operator", RID_OPERATOR
, D_CXXONLY
| D_CXXWARN
},
660 { "private", RID_PRIVATE
, D_CXX_OBJC
| D_CXXWARN
},
661 { "protected", RID_PROTECTED
, D_CXX_OBJC
| D_CXXWARN
},
662 { "public", RID_PUBLIC
, D_CXX_OBJC
| D_CXXWARN
},
663 { "register", RID_REGISTER
, 0 },
664 { "reinterpret_cast", RID_REINTCAST
, D_CXXONLY
| D_CXXWARN
},
665 { "restrict", RID_RESTRICT
, D_CONLY
| D_C99
},
666 { "return", RID_RETURN
, 0 },
667 { "short", RID_SHORT
, 0 },
668 { "signed", RID_SIGNED
, 0 },
669 { "sizeof", RID_SIZEOF
, 0 },
670 { "static", RID_STATIC
, 0 },
671 { "static_assert", RID_STATIC_ASSERT
, D_CXXONLY
| D_CXX0X
| D_CXXWARN
},
672 { "static_cast", RID_STATCAST
, D_CXXONLY
| D_CXXWARN
},
673 { "struct", RID_STRUCT
, 0 },
674 { "switch", RID_SWITCH
, 0 },
675 { "template", RID_TEMPLATE
, D_CXXONLY
| D_CXXWARN
},
676 { "this", RID_THIS
, D_CXXONLY
| D_CXXWARN
},
677 { "throw", RID_THROW
, D_CXX_OBJC
| D_CXXWARN
},
678 { "true", RID_TRUE
, D_CXXONLY
| D_CXXWARN
},
679 { "try", RID_TRY
, D_CXX_OBJC
| D_CXXWARN
},
680 { "typedef", RID_TYPEDEF
, 0 },
681 { "typename", RID_TYPENAME
, D_CXXONLY
| D_CXXWARN
},
682 { "typeid", RID_TYPEID
, D_CXXONLY
| D_CXXWARN
},
683 { "typeof", RID_TYPEOF
, D_ASM
| D_EXT
},
684 { "union", RID_UNION
, 0 },
685 { "unsigned", RID_UNSIGNED
, 0 },
686 { "using", RID_USING
, D_CXXONLY
| D_CXXWARN
},
687 { "virtual", RID_VIRTUAL
, D_CXXONLY
| D_CXXWARN
},
688 { "void", RID_VOID
, 0 },
689 { "volatile", RID_VOLATILE
, 0 },
690 { "wchar_t", RID_WCHAR
, D_CXXONLY
},
691 { "while", RID_WHILE
, 0 },
692 /* These Objective-C keywords are recognized only immediately after
694 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
695 { "defs", RID_AT_DEFS
, D_OBJC
},
696 { "encode", RID_AT_ENCODE
, D_OBJC
},
697 { "end", RID_AT_END
, D_OBJC
},
698 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
699 { "interface", RID_AT_INTERFACE
, D_OBJC
},
700 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
701 { "selector", RID_AT_SELECTOR
, D_OBJC
},
702 { "finally", RID_AT_FINALLY
, D_OBJC
},
703 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
704 /* These are recognized only in protocol-qualifier context
706 { "bycopy", RID_BYCOPY
, D_OBJC
},
707 { "byref", RID_BYREF
, D_OBJC
},
708 { "in", RID_IN
, D_OBJC
},
709 { "inout", RID_INOUT
, D_OBJC
},
710 { "oneway", RID_ONEWAY
, D_OBJC
},
711 { "out", RID_OUT
, D_OBJC
},
714 const unsigned int num_c_common_reswords
=
715 sizeof c_common_reswords
/ sizeof (struct c_common_resword
);
717 /* Table of machine-independent attributes common to all C-like languages. */
718 const struct attribute_spec c_common_attribute_table
[] =
720 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
721 { "packed", 0, 0, false, false, false,
722 handle_packed_attribute
},
723 { "nocommon", 0, 0, true, false, false,
724 handle_nocommon_attribute
},
725 { "common", 0, 0, true, false, false,
726 handle_common_attribute
},
727 /* FIXME: logically, noreturn attributes should be listed as
728 "false, true, true" and apply to function types. But implementing this
729 would require all the places in the compiler that use TREE_THIS_VOLATILE
730 on a decl to identify non-returning functions to be located and fixed
731 to check the function type instead. */
732 { "noreturn", 0, 0, true, false, false,
733 handle_noreturn_attribute
},
734 { "volatile", 0, 0, true, false, false,
735 handle_noreturn_attribute
},
736 { "noinline", 0, 0, true, false, false,
737 handle_noinline_attribute
},
738 { "noclone", 0, 0, true, false, false,
739 handle_noclone_attribute
},
740 { "always_inline", 0, 0, true, false, false,
741 handle_always_inline_attribute
},
742 { "gnu_inline", 0, 0, true, false, false,
743 handle_gnu_inline_attribute
},
744 { "artificial", 0, 0, true, false, false,
745 handle_artificial_attribute
},
746 { "flatten", 0, 0, true, false, false,
747 handle_flatten_attribute
},
748 { "used", 0, 0, true, false, false,
749 handle_used_attribute
},
750 { "unused", 0, 0, false, false, false,
751 handle_unused_attribute
},
752 { "externally_visible", 0, 0, true, false, false,
753 handle_externally_visible_attribute
},
754 /* The same comments as for noreturn attributes apply to const ones. */
755 { "const", 0, 0, true, false, false,
756 handle_const_attribute
},
757 { "transparent_union", 0, 0, false, false, false,
758 handle_transparent_union_attribute
},
759 { "constructor", 0, 1, true, false, false,
760 handle_constructor_attribute
},
761 { "destructor", 0, 1, true, false, false,
762 handle_destructor_attribute
},
763 { "mode", 1, 1, false, true, false,
764 handle_mode_attribute
},
765 { "section", 1, 1, true, false, false,
766 handle_section_attribute
},
767 { "aligned", 0, 1, false, false, false,
768 handle_aligned_attribute
},
769 { "weak", 0, 0, true, false, false,
770 handle_weak_attribute
},
771 { "alias", 1, 1, true, false, false,
772 handle_alias_attribute
},
773 { "weakref", 0, 1, true, false, false,
774 handle_weakref_attribute
},
775 { "no_instrument_function", 0, 0, true, false, false,
776 handle_no_instrument_function_attribute
},
777 { "malloc", 0, 0, true, false, false,
778 handle_malloc_attribute
},
779 { "returns_twice", 0, 0, true, false, false,
780 handle_returns_twice_attribute
},
781 { "no_stack_limit", 0, 0, true, false, false,
782 handle_no_limit_stack_attribute
},
783 { "pure", 0, 0, true, false, false,
784 handle_pure_attribute
},
785 /* For internal use (marking of builtins) only. The name contains space
786 to prevent its usage in source code. */
787 { "no vops", 0, 0, true, false, false,
788 handle_novops_attribute
},
789 { "deprecated", 0, 1, false, false, false,
790 handle_deprecated_attribute
},
791 { "vector_size", 1, 1, false, true, false,
792 handle_vector_size_attribute
},
793 { "visibility", 1, 1, false, false, false,
794 handle_visibility_attribute
},
795 { "tls_model", 1, 1, true, false, false,
796 handle_tls_model_attribute
},
797 { "nonnull", 0, -1, false, true, true,
798 handle_nonnull_attribute
},
799 { "nothrow", 0, 0, true, false, false,
800 handle_nothrow_attribute
},
801 { "may_alias", 0, 0, false, true, false, NULL
},
802 { "cleanup", 1, 1, true, false, false,
803 handle_cleanup_attribute
},
804 { "warn_unused_result", 0, 0, false, true, true,
805 handle_warn_unused_result_attribute
},
806 { "sentinel", 0, 1, false, true, true,
807 handle_sentinel_attribute
},
808 /* For internal use (marking of builtins) only. The name contains space
809 to prevent its usage in source code. */
810 { "type generic", 0, 0, false, true, true,
811 handle_type_generic_attribute
},
812 { "alloc_size", 1, 2, false, true, true,
813 handle_alloc_size_attribute
},
814 { "cold", 0, 0, true, false, false,
815 handle_cold_attribute
},
816 { "hot", 0, 0, true, false, false,
817 handle_hot_attribute
},
818 { "warning", 1, 1, true, false, false,
819 handle_error_attribute
},
820 { "error", 1, 1, true, false, false,
821 handle_error_attribute
},
822 { "target", 1, -1, true, false, false,
823 handle_target_attribute
},
824 { "optimize", 1, -1, true, false, false,
825 handle_optimize_attribute
},
826 { NULL
, 0, 0, false, false, false, NULL
}
829 /* Give the specifications for the format attributes, used by C and all
832 const struct attribute_spec c_common_format_attribute_table
[] =
834 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
835 { "format", 3, 3, false, true, true,
836 handle_format_attribute
},
837 { "format_arg", 1, 1, false, true, true,
838 handle_format_arg_attribute
},
839 { NULL
, 0, 0, false, false, false, NULL
}
842 /* Push current bindings for the function name VAR_DECLS. */
845 start_fname_decls (void)
848 tree saved
= NULL_TREE
;
850 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
852 tree decl
= *fname_vars
[ix
].decl
;
856 saved
= tree_cons (decl
, build_int_cst (NULL_TREE
, ix
), saved
);
857 *fname_vars
[ix
].decl
= NULL_TREE
;
860 if (saved
|| saved_function_name_decls
)
861 /* Normally they'll have been NULL, so only push if we've got a
862 stack, or they are non-NULL. */
863 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
864 saved_function_name_decls
);
867 /* Finish up the current bindings, adding them into the current function's
868 statement tree. This must be done _before_ finish_stmt_tree is called.
869 If there is no current function, we must be at file scope and no statements
870 are involved. Pop the previous bindings. */
873 finish_fname_decls (void)
876 tree stmts
= NULL_TREE
;
877 tree stack
= saved_function_name_decls
;
879 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
880 append_to_statement_list (TREE_VALUE (stack
), &stmts
);
884 tree
*bodyp
= &DECL_SAVED_TREE (current_function_decl
);
886 if (TREE_CODE (*bodyp
) == BIND_EXPR
)
887 bodyp
= &BIND_EXPR_BODY (*bodyp
);
889 append_to_statement_list_force (*bodyp
, &stmts
);
893 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
894 *fname_vars
[ix
].decl
= NULL_TREE
;
898 /* We had saved values, restore them. */
901 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
903 tree decl
= TREE_PURPOSE (saved
);
904 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
906 *fname_vars
[ix
].decl
= decl
;
908 stack
= TREE_CHAIN (stack
);
910 saved_function_name_decls
= stack
;
913 /* Return the text name of the current function, suitably prettified
914 by PRETTY_P. Return string must be freed by caller. */
917 fname_as_string (int pretty_p
)
919 const char *name
= "top level";
922 cpp_string cstr
= { 0, 0 }, strname
;
930 if (current_function_decl
)
931 name
= lang_hooks
.decl_printable_name (current_function_decl
, vrb
);
933 len
= strlen (name
) + 3; /* Two for '"'s. One for NULL. */
935 namep
= XNEWVEC (char, len
);
936 snprintf (namep
, len
, "\"%s\"", name
);
937 strname
.text
= (unsigned char *) namep
;
938 strname
.len
= len
- 1;
940 if (cpp_interpret_string (parse_in
, &strname
, 1, &cstr
, CPP_STRING
))
943 return (const char *) cstr
.text
;
949 /* Return the VAR_DECL for a const char array naming the current
950 function. If the VAR_DECL has not yet been created, create it
951 now. RID indicates how it should be formatted and IDENTIFIER_NODE
952 ID is its name (unfortunately C and C++ hold the RID values of
953 keywords in different places, so we can't derive RID from ID in
954 this language independent code. LOC is the location of the
958 fname_decl (location_t loc
, unsigned int rid
, tree id
)
961 tree decl
= NULL_TREE
;
963 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
964 if (fname_vars
[ix
].rid
== rid
)
967 decl
= *fname_vars
[ix
].decl
;
970 /* If a tree is built here, it would normally have the lineno of
971 the current statement. Later this tree will be moved to the
972 beginning of the function and this line number will be wrong.
973 To avoid this problem set the lineno to 0 here; that prevents
974 it from appearing in the RTL. */
976 location_t saved_location
= input_location
;
977 input_location
= UNKNOWN_LOCATION
;
979 stmts
= push_stmt_list ();
980 decl
= (*make_fname_decl
) (loc
, id
, fname_vars
[ix
].pretty
);
981 stmts
= pop_stmt_list (stmts
);
982 if (!IS_EMPTY_STMT (stmts
))
983 saved_function_name_decls
984 = tree_cons (decl
, stmts
, saved_function_name_decls
);
985 *fname_vars
[ix
].decl
= decl
;
986 input_location
= saved_location
;
988 if (!ix
&& !current_function_decl
)
989 pedwarn (loc
, 0, "%qD is not defined outside of function scope", decl
);
994 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
997 fix_string_type (tree value
)
999 int length
= TREE_STRING_LENGTH (value
);
1001 tree e_type
, i_type
, a_type
;
1003 /* Compute the number of elements, for the array type. */
1004 if (TREE_TYPE (value
) == char_array_type_node
|| !TREE_TYPE (value
))
1007 e_type
= char_type_node
;
1009 else if (TREE_TYPE (value
) == char16_array_type_node
)
1011 nchars
= length
/ (TYPE_PRECISION (char16_type_node
) / BITS_PER_UNIT
);
1012 e_type
= char16_type_node
;
1014 else if (TREE_TYPE (value
) == char32_array_type_node
)
1016 nchars
= length
/ (TYPE_PRECISION (char32_type_node
) / BITS_PER_UNIT
);
1017 e_type
= char32_type_node
;
1021 nchars
= length
/ (TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
);
1022 e_type
= wchar_type_node
;
1025 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1026 limit in C++98 Annex B is very large (65536) and is not normative,
1027 so we do not diagnose it (warn_overlength_strings is forced off
1028 in c_common_post_options). */
1029 if (warn_overlength_strings
)
1031 const int nchars_max
= flag_isoc99
? 4095 : 509;
1032 const int relevant_std
= flag_isoc99
? 99 : 90;
1033 if (nchars
- 1 > nchars_max
)
1034 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1035 separate the %d from the 'C'. 'ISO' should not be
1036 translated, but it may be moved after 'C%d' in languages
1037 where modifiers follow nouns. */
1038 pedwarn (input_location
, OPT_Woverlength_strings
,
1039 "string length %qd is greater than the length %qd "
1040 "ISO C%d compilers are required to support",
1041 nchars
- 1, nchars_max
, relevant_std
);
1044 /* Create the array type for the string constant. The ISO C++
1045 standard says that a string literal has type `const char[N]' or
1046 `const wchar_t[N]'. We use the same logic when invoked as a C
1047 front-end with -Wwrite-strings.
1048 ??? We should change the type of an expression depending on the
1049 state of a warning flag. We should just be warning -- see how
1050 this is handled in the C++ front-end for the deprecated implicit
1051 conversion from string literals to `char*' or `wchar_t*'.
1053 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1054 array type being the unqualified version of that type.
1055 Therefore, if we are constructing an array of const char, we must
1056 construct the matching unqualified array type first. The C front
1057 end does not require this, but it does no harm, so we do it
1059 i_type
= build_index_type (build_int_cst (NULL_TREE
, nchars
- 1));
1060 a_type
= build_array_type (e_type
, i_type
);
1061 if (c_dialect_cxx() || warn_write_strings
)
1062 a_type
= c_build_qualified_type (a_type
, TYPE_QUAL_CONST
);
1064 TREE_TYPE (value
) = a_type
;
1065 TREE_CONSTANT (value
) = 1;
1066 TREE_READONLY (value
) = 1;
1067 TREE_STATIC (value
) = 1;
1071 /* Fully fold EXPR, an expression that was not folded (beyond integer
1072 constant expressions and null pointer constants) when being built
1073 up. If IN_INIT, this is in a static initializer and certain
1074 changes are made to the folding done. Clear *MAYBE_CONST if
1075 MAYBE_CONST is not NULL and EXPR is definitely not a constant
1076 expression because it contains an evaluated operator (in C99) or an
1077 operator outside of sizeof returning an integer constant (in C90)
1078 not permitted in constant expressions, or because it contains an
1079 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
1080 set to true by callers before calling this function.) Return the
1081 folded expression. Function arguments have already been folded
1082 before calling this function, as have the contents of SAVE_EXPR,
1083 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1084 C_MAYBE_CONST_EXPR. */
1087 c_fully_fold (tree expr
, bool in_init
, bool *maybe_const
)
1090 tree eptype
= NULL_TREE
;
1092 bool maybe_const_itself
= true;
1093 location_t loc
= EXPR_LOCATION (expr
);
1095 /* This function is not relevant to C++ because C++ folds while
1096 parsing, and may need changes to be correct for C++ when C++
1097 stops folding while parsing. */
1098 if (c_dialect_cxx ())
1102 maybe_const
= &dummy
;
1103 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
1105 eptype
= TREE_TYPE (expr
);
1106 expr
= TREE_OPERAND (expr
, 0);
1108 ret
= c_fully_fold_internal (expr
, in_init
, maybe_const
,
1109 &maybe_const_itself
);
1111 ret
= fold_convert_loc (loc
, eptype
, ret
);
1112 *maybe_const
&= maybe_const_itself
;
1116 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1117 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1118 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1119 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1120 both evaluated and unevaluated subexpressions while
1121 *MAYBE_CONST_ITSELF is carried from only evaluated
1125 c_fully_fold_internal (tree expr
, bool in_init
, bool *maybe_const_operands
,
1126 bool *maybe_const_itself
)
1129 enum tree_code code
= TREE_CODE (expr
);
1130 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
1131 location_t loc
= EXPR_LOCATION (expr
);
1132 tree op0
, op1
, op2
, op3
;
1133 tree orig_op0
, orig_op1
, orig_op2
;
1134 bool op0_const
= true, op1_const
= true, op2_const
= true;
1135 bool op0_const_self
= true, op1_const_self
= true, op2_const_self
= true;
1136 bool nowarning
= TREE_NO_WARNING (expr
);
1139 /* This function is not relevant to C++ because C++ folds while
1140 parsing, and may need changes to be correct for C++ when C++
1141 stops folding while parsing. */
1142 if (c_dialect_cxx ())
1145 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1146 anything else not counted as an expression cannot usefully be
1147 folded further at this point. */
1148 if (!IS_EXPR_CODE_CLASS (kind
)
1149 || kind
== tcc_statement
1150 || code
== SAVE_EXPR
)
1153 /* Operands of variable-length expressions (function calls) have
1154 already been folded, as have __builtin_* function calls, and such
1155 expressions cannot occur in constant expressions. */
1156 if (kind
== tcc_vl_exp
)
1158 *maybe_const_operands
= false;
1163 if (code
== C_MAYBE_CONST_EXPR
)
1165 tree pre
= C_MAYBE_CONST_EXPR_PRE (expr
);
1166 tree inner
= C_MAYBE_CONST_EXPR_EXPR (expr
);
1167 if (C_MAYBE_CONST_EXPR_NON_CONST (expr
))
1168 *maybe_const_operands
= false;
1169 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr
))
1170 *maybe_const_itself
= false;
1171 if (pre
&& !in_init
)
1172 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr
), pre
, inner
);
1178 /* Assignment, increment, decrement, function call and comma
1179 operators, and statement expressions, cannot occur in constant
1180 expressions if evaluated / outside of sizeof. (Function calls
1181 were handled above, though VA_ARG_EXPR is treated like a function
1182 call here, and statement expressions are handled through
1183 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1187 case PREDECREMENT_EXPR
:
1188 case PREINCREMENT_EXPR
:
1189 case POSTDECREMENT_EXPR
:
1190 case POSTINCREMENT_EXPR
:
1192 *maybe_const_operands
= false;
1199 *maybe_const_operands
= false;
1207 /* Fold individual tree codes as appropriate. */
1210 case COMPOUND_LITERAL_EXPR
:
1211 /* Any non-constancy will have been marked in a containing
1212 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1216 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1217 op1
= TREE_OPERAND (expr
, 1);
1218 op2
= TREE_OPERAND (expr
, 2);
1219 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1220 maybe_const_itself
);
1221 if (op0
!= orig_op0
)
1222 ret
= build3 (COMPONENT_REF
, TREE_TYPE (expr
), op0
, op1
, op2
);
1225 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1226 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1231 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1232 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1233 op2
= TREE_OPERAND (expr
, 2);
1234 op3
= TREE_OPERAND (expr
, 3);
1235 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1236 maybe_const_itself
);
1237 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1238 maybe_const_itself
);
1239 op1
= decl_constant_value_for_optimization (op1
);
1240 if (op0
!= orig_op0
|| op1
!= orig_op1
)
1241 ret
= build4 (ARRAY_REF
, TREE_TYPE (expr
), op0
, op1
, op2
, op3
);
1244 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1245 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1246 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1253 case PREDECREMENT_EXPR
:
1254 case PREINCREMENT_EXPR
:
1255 case POSTDECREMENT_EXPR
:
1256 case POSTINCREMENT_EXPR
:
1260 case POINTER_PLUS_EXPR
:
1261 case TRUNC_DIV_EXPR
:
1263 case FLOOR_DIV_EXPR
:
1264 case TRUNC_MOD_EXPR
:
1266 case EXACT_DIV_EXPR
:
1279 case TRUTH_AND_EXPR
:
1281 case TRUTH_XOR_EXPR
:
1282 case UNORDERED_EXPR
:
1289 /* Binary operations evaluating both arguments (increment and
1290 decrement are binary internally in GCC). */
1291 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1292 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1293 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1294 maybe_const_itself
);
1295 if (code
!= MODIFY_EXPR
1296 && code
!= PREDECREMENT_EXPR
1297 && code
!= PREINCREMENT_EXPR
1298 && code
!= POSTDECREMENT_EXPR
1299 && code
!= POSTINCREMENT_EXPR
)
1300 op0
= decl_constant_value_for_optimization (op0
);
1301 /* The RHS of a MODIFY_EXPR was fully folded when building that
1302 expression for the sake of conversion warnings. */
1303 if (code
!= MODIFY_EXPR
)
1304 op1
= c_fully_fold_internal (op1
, in_init
, maybe_const_operands
,
1305 maybe_const_itself
);
1306 op1
= decl_constant_value_for_optimization (op1
);
1307 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1309 ? fold_build2_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
)
1310 : fold_build2_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
);
1313 if (TREE_OVERFLOW_P (ret
)
1314 && !TREE_OVERFLOW_P (op0
)
1315 && !TREE_OVERFLOW_P (op1
))
1316 overflow_warning (EXPR_LOCATION (expr
), ret
);
1320 case FIX_TRUNC_EXPR
:
1323 case NON_LVALUE_EXPR
:
1326 case TRUTH_NOT_EXPR
:
1331 /* Unary operations. */
1332 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1333 op0
= c_fully_fold_internal (op0
, in_init
, maybe_const_operands
,
1334 maybe_const_itself
);
1335 if (code
!= ADDR_EXPR
&& code
!= REALPART_EXPR
&& code
!= IMAGPART_EXPR
)
1336 op0
= decl_constant_value_for_optimization (op0
);
1337 if (op0
!= orig_op0
|| in_init
)
1339 ? fold_build1_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
)
1340 : fold_build1_loc (loc
, code
, TREE_TYPE (expr
), op0
);
1343 if (code
== INDIRECT_REF
1345 && TREE_CODE (ret
) == INDIRECT_REF
)
1347 TREE_READONLY (ret
) = TREE_READONLY (expr
);
1348 TREE_SIDE_EFFECTS (ret
) = TREE_SIDE_EFFECTS (expr
);
1349 TREE_THIS_VOLATILE (ret
) = TREE_THIS_VOLATILE (expr
);
1353 case FIX_TRUNC_EXPR
:
1356 /* Don't warn about explicit conversions. We will already
1357 have warned about suspect implicit conversions. */
1361 if (TREE_OVERFLOW_P (ret
) && !TREE_OVERFLOW_P (op0
))
1362 overflow_warning (EXPR_LOCATION (expr
), ret
);
1367 case TRUTH_ANDIF_EXPR
:
1368 case TRUTH_ORIF_EXPR
:
1369 /* Binary operations not necessarily evaluating both
1371 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1372 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1373 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1375 unused_p
= (op0
== (code
== TRUTH_ANDIF_EXPR
1376 ? truthvalue_false_node
1377 : truthvalue_true_node
));
1378 c_inhibit_evaluation_warnings
+= unused_p
;
1379 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1380 c_inhibit_evaluation_warnings
-= unused_p
;
1382 if (op0
!= orig_op0
|| op1
!= orig_op1
|| in_init
)
1384 ? fold_build2_initializer_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
)
1385 : fold_build2_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
);
1388 *maybe_const_operands
&= op0_const
;
1389 *maybe_const_itself
&= op0_const_self
;
1393 && (code
== TRUTH_ANDIF_EXPR
1394 ? op0
== truthvalue_false_node
1395 : op0
== truthvalue_true_node
)))
1396 *maybe_const_operands
&= op1_const
;
1399 && (code
== TRUTH_ANDIF_EXPR
1400 ? op0
== truthvalue_false_node
1401 : op0
== truthvalue_true_node
)))
1402 *maybe_const_itself
&= op1_const_self
;
1406 orig_op0
= op0
= TREE_OPERAND (expr
, 0);
1407 orig_op1
= op1
= TREE_OPERAND (expr
, 1);
1408 orig_op2
= op2
= TREE_OPERAND (expr
, 2);
1409 op0
= c_fully_fold_internal (op0
, in_init
, &op0_const
, &op0_const_self
);
1411 c_inhibit_evaluation_warnings
+= (op0
== truthvalue_false_node
);
1412 op1
= c_fully_fold_internal (op1
, in_init
, &op1_const
, &op1_const_self
);
1413 c_inhibit_evaluation_warnings
-= (op0
== truthvalue_false_node
);
1415 c_inhibit_evaluation_warnings
+= (op0
== truthvalue_true_node
);
1416 op2
= c_fully_fold_internal (op2
, in_init
, &op2_const
, &op2_const_self
);
1417 c_inhibit_evaluation_warnings
-= (op0
== truthvalue_true_node
);
1419 if (op0
!= orig_op0
|| op1
!= orig_op1
|| op2
!= orig_op2
)
1420 ret
= fold_build3_loc (loc
, code
, TREE_TYPE (expr
), op0
, op1
, op2
);
1423 *maybe_const_operands
&= op0_const
;
1424 *maybe_const_itself
&= op0_const_self
;
1428 && op0
== truthvalue_false_node
))
1429 *maybe_const_operands
&= op1_const
;
1432 && op0
== truthvalue_false_node
))
1433 *maybe_const_itself
&= op1_const_self
;
1437 && op0
== truthvalue_true_node
))
1438 *maybe_const_operands
&= op2_const
;
1441 && op0
== truthvalue_true_node
))
1442 *maybe_const_itself
&= op2_const_self
;
1445 case EXCESS_PRECISION_EXPR
:
1446 /* Each case where an operand with excess precision may be
1447 encountered must remove the EXCESS_PRECISION_EXPR around
1448 inner operands and possibly put one around the whole
1449 expression or possibly convert to the semantic type (which
1450 c_fully_fold does); we cannot tell at this stage which is
1451 appropriate in any particular case. */
1455 /* Various codes may appear through folding built-in functions
1456 and their arguments. */
1461 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1462 have been done by this point, so remove them again. */
1463 nowarning
|= TREE_NO_WARNING (ret
);
1464 STRIP_TYPE_NOPS (ret
);
1465 if (nowarning
&& !TREE_NO_WARNING (ret
))
1467 if (!CAN_HAVE_LOCATION_P (ret
))
1468 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
1469 TREE_NO_WARNING (ret
) = 1;
1472 protected_set_expr_location (ret
, loc
);
1476 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1477 return EXP. Otherwise, return either EXP or its known constant
1478 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1479 Is the BLKmode test appropriate? */
1482 decl_constant_value_for_optimization (tree exp
)
1486 /* This function is only used by C, for c_fully_fold and other
1487 optimization, and may not be correct for C++. */
1488 if (c_dialect_cxx ())
1492 || TREE_CODE (exp
) != VAR_DECL
1493 || TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
1494 || DECL_MODE (exp
) == BLKmode
)
1497 ret
= decl_constant_value (exp
);
1498 /* Avoid unwanted tree sharing between the initializer and current
1499 function's body where the tree can be modified e.g. by the
1501 if (ret
!= exp
&& TREE_STATIC (exp
))
1502 ret
= unshare_expr (ret
);
1506 /* Print a warning if a constant expression had overflow in folding.
1507 Invoke this function on every expression that the language
1508 requires to be a constant expression.
1509 Note the ANSI C standard says it is erroneous for a
1510 constant expression to overflow. */
1513 constant_expression_warning (tree value
)
1515 if (warn_overflow
&& pedantic
1516 && (TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1517 || TREE_CODE (value
) == FIXED_CST
1518 || TREE_CODE (value
) == VECTOR_CST
1519 || TREE_CODE (value
) == COMPLEX_CST
)
1520 && TREE_OVERFLOW (value
))
1521 pedwarn (input_location
, OPT_Woverflow
, "overflow in constant expression");
1524 /* The same as above but print an unconditional error. */
1526 constant_expression_error (tree value
)
1528 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1529 || TREE_CODE (value
) == FIXED_CST
1530 || TREE_CODE (value
) == VECTOR_CST
1531 || TREE_CODE (value
) == COMPLEX_CST
)
1532 && TREE_OVERFLOW (value
))
1533 error ("overflow in constant expression");
1536 /* Print a warning if an expression had overflow in folding and its
1539 Invoke this function on every expression that
1540 (1) appears in the source code, and
1541 (2) is a constant expression that overflowed, and
1542 (3) is not already checked by convert_and_check;
1543 however, do not invoke this function on operands of explicit casts
1544 or when the expression is the result of an operator and any operand
1545 already overflowed. */
1548 overflow_warning (location_t loc
, tree value
)
1550 if (c_inhibit_evaluation_warnings
!= 0)
1553 switch (TREE_CODE (value
))
1556 warning_at (loc
, OPT_Woverflow
, "integer overflow in expression");
1560 warning_at (loc
, OPT_Woverflow
,
1561 "floating point overflow in expression");
1565 warning_at (loc
, OPT_Woverflow
, "fixed-point overflow in expression");
1569 warning_at (loc
, OPT_Woverflow
, "vector overflow in expression");
1573 if (TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
)
1574 warning_at (loc
, OPT_Woverflow
,
1575 "complex integer overflow in expression");
1576 else if (TREE_CODE (TREE_REALPART (value
)) == REAL_CST
)
1577 warning_at (loc
, OPT_Woverflow
,
1578 "complex floating point overflow in expression");
1586 /* Warn about uses of logical || / && operator in a context where it
1587 is likely that the bitwise equivalent was intended by the
1588 programmer. We have seen an expression in which CODE is a binary
1589 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1590 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1592 warn_logical_operator (location_t location
, enum tree_code code
, tree type
,
1593 enum tree_code code_left
, tree op_left
,
1594 enum tree_code
ARG_UNUSED (code_right
), tree op_right
)
1596 int or_op
= (code
== TRUTH_ORIF_EXPR
|| code
== TRUTH_OR_EXPR
);
1597 int in0_p
, in1_p
, in_p
;
1598 tree low0
, low1
, low
, high0
, high1
, high
, lhs
, rhs
, tem
;
1599 bool strict_overflow_p
= false;
1601 if (code
!= TRUTH_ANDIF_EXPR
1602 && code
!= TRUTH_AND_EXPR
1603 && code
!= TRUTH_ORIF_EXPR
1604 && code
!= TRUTH_OR_EXPR
)
1607 /* Warn if &&/|| are being used in a context where it is
1608 likely that the bitwise equivalent was intended by the
1609 programmer. That is, an expression such as op && MASK
1610 where op should not be any boolean expression, nor a
1611 constant, and mask seems to be a non-boolean integer constant. */
1612 if (!truth_value_p (code_left
)
1613 && INTEGRAL_TYPE_P (TREE_TYPE (op_left
))
1614 && !CONSTANT_CLASS_P (op_left
)
1615 && !TREE_NO_WARNING (op_left
)
1616 && TREE_CODE (op_right
) == INTEGER_CST
1617 && !integer_zerop (op_right
)
1618 && !integer_onep (op_right
))
1621 warning_at (location
, OPT_Wlogical_op
, "logical %<or%>"
1622 " applied to non-boolean constant");
1624 warning_at (location
, OPT_Wlogical_op
, "logical %<and%>"
1625 " applied to non-boolean constant");
1626 TREE_NO_WARNING (op_left
) = true;
1630 /* We do not warn for constants because they are typical of macro
1631 expansions that test for features. */
1632 if (CONSTANT_CLASS_P (op_left
) || CONSTANT_CLASS_P (op_right
))
1635 /* This warning only makes sense with logical operands. */
1636 if (!(truth_value_p (TREE_CODE (op_left
))
1637 || INTEGRAL_TYPE_P (TREE_TYPE (op_left
)))
1638 || !(truth_value_p (TREE_CODE (op_right
))
1639 || INTEGRAL_TYPE_P (TREE_TYPE (op_right
))))
1642 lhs
= make_range (op_left
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
1643 rhs
= make_range (op_right
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
1645 if (lhs
&& TREE_CODE (lhs
) == C_MAYBE_CONST_EXPR
)
1646 lhs
= C_MAYBE_CONST_EXPR_EXPR (lhs
);
1648 if (rhs
&& TREE_CODE (rhs
) == C_MAYBE_CONST_EXPR
)
1649 rhs
= C_MAYBE_CONST_EXPR_EXPR (rhs
);
1651 /* If this is an OR operation, invert both sides; we will invert
1652 again at the end. */
1654 in0_p
= !in0_p
, in1_p
= !in1_p
;
1656 /* If both expressions are the same, if we can merge the ranges, and we
1657 can build the range test, return it or it inverted. */
1658 if (lhs
&& rhs
&& operand_equal_p (lhs
, rhs
, 0)
1659 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
1661 && 0 != (tem
= build_range_check (UNKNOWN_LOCATION
,
1662 type
, lhs
, in_p
, low
, high
)))
1664 if (TREE_CODE (tem
) != INTEGER_CST
)
1668 warning_at (location
, OPT_Wlogical_op
,
1670 "of collectively exhaustive tests is always true");
1672 warning_at (location
, OPT_Wlogical_op
,
1674 "of mutually exclusive tests is always false");
1679 /* Print a warning about casts that might indicate violation
1680 of strict aliasing rules if -Wstrict-aliasing is used and
1681 strict aliasing mode is in effect. OTYPE is the original
1682 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1685 strict_aliasing_warning (tree otype
, tree type
, tree expr
)
1687 /* Strip pointer conversion chains and get to the correct original type. */
1689 otype
= TREE_TYPE (expr
);
1691 if (!(flag_strict_aliasing
1692 && POINTER_TYPE_P (type
)
1693 && POINTER_TYPE_P (otype
)
1694 && !VOID_TYPE_P (TREE_TYPE (type
)))
1695 /* If the type we are casting to is a ref-all pointer
1696 dereferencing it is always valid. */
1697 || TYPE_REF_CAN_ALIAS_ALL (type
))
1700 if ((warn_strict_aliasing
> 1) && TREE_CODE (expr
) == ADDR_EXPR
1701 && (DECL_P (TREE_OPERAND (expr
, 0))
1702 || handled_component_p (TREE_OPERAND (expr
, 0))))
1704 /* Casting the address of an object to non void pointer. Warn
1705 if the cast breaks type based aliasing. */
1706 if (!COMPLETE_TYPE_P (TREE_TYPE (type
)) && warn_strict_aliasing
== 2)
1708 warning (OPT_Wstrict_aliasing
, "type-punning to incomplete type "
1709 "might break strict-aliasing rules");
1714 /* warn_strict_aliasing >= 3. This includes the default (3).
1715 Only warn if the cast is dereferenced immediately. */
1716 alias_set_type set1
=
1717 get_alias_set (TREE_TYPE (TREE_OPERAND (expr
, 0)));
1718 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1720 if (set1
!= set2
&& set2
!= 0
1721 && (set1
== 0 || !alias_sets_conflict_p (set1
, set2
)))
1723 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1724 "pointer will break strict-aliasing rules");
1727 else if (warn_strict_aliasing
== 2
1728 && !alias_sets_must_conflict_p (set1
, set2
))
1730 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1731 "pointer might break strict-aliasing rules");
1737 if ((warn_strict_aliasing
== 1) && !VOID_TYPE_P (TREE_TYPE (otype
)))
1739 /* At this level, warn for any conversions, even if an address is
1740 not taken in the same statement. This will likely produce many
1741 false positives, but could be useful to pinpoint problems that
1742 are not revealed at higher levels. */
1743 alias_set_type set1
= get_alias_set (TREE_TYPE (otype
));
1744 alias_set_type set2
= get_alias_set (TREE_TYPE (type
));
1745 if (!COMPLETE_TYPE_P (type
)
1746 || !alias_sets_must_conflict_p (set1
, set2
))
1748 warning (OPT_Wstrict_aliasing
, "dereferencing type-punned "
1749 "pointer might break strict-aliasing rules");
1757 /* Warn for unlikely, improbable, or stupid DECL declarations
1761 check_main_parameter_types (tree decl
)
1766 for (args
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); args
;
1767 args
= TREE_CHAIN (args
))
1769 tree type
= args
? TREE_VALUE (args
) : 0;
1771 if (type
== void_type_node
|| type
== error_mark_node
)
1778 if (TYPE_MAIN_VARIANT (type
) != integer_type_node
)
1779 pedwarn (input_location
, OPT_Wmain
, "first argument of %q+D should be %<int%>",
1784 if (TREE_CODE (type
) != POINTER_TYPE
1785 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1786 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1788 pedwarn (input_location
, OPT_Wmain
, "second argument of %q+D should be %<char **%>",
1793 if (TREE_CODE (type
) != POINTER_TYPE
1794 || TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
1795 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type
)))
1797 pedwarn (input_location
, OPT_Wmain
, "third argument of %q+D should probably be "
1798 "%<char **%>", decl
);
1803 /* It is intentional that this message does not mention the third
1804 argument because it's only mentioned in an appendix of the
1806 if (argct
> 0 && (argct
< 2 || argct
> 3))
1807 pedwarn (input_location
, OPT_Wmain
, "%q+D takes only zero or two arguments", decl
);
1810 /* True if pointers to distinct types T1 and T2 can be converted to
1811 each other without an explicit cast. Only returns true for opaque
1814 vector_targets_convertible_p (const_tree t1
, const_tree t2
)
1816 if (TREE_CODE (t1
) == VECTOR_TYPE
&& TREE_CODE (t2
) == VECTOR_TYPE
1817 && (TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
1818 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1824 /* True if vector types T1 and T2 can be converted to each other
1825 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1826 can only be converted with -flax-vector-conversions yet that is not
1827 in effect, emit a note telling the user about that option if such
1828 a note has not previously been emitted. */
1830 vector_types_convertible_p (const_tree t1
, const_tree t2
, bool emit_lax_note
)
1832 static bool emitted_lax_note
= false;
1833 bool convertible_lax
;
1835 if ((TYPE_VECTOR_OPAQUE (t1
) || TYPE_VECTOR_OPAQUE (t2
))
1836 && tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
)))
1840 (tree_int_cst_equal (TYPE_SIZE (t1
), TYPE_SIZE (t2
))
1841 && (TREE_CODE (TREE_TYPE (t1
)) != REAL_TYPE
||
1842 TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
))
1843 && (INTEGRAL_TYPE_P (TREE_TYPE (t1
))
1844 == INTEGRAL_TYPE_P (TREE_TYPE (t2
))));
1846 if (!convertible_lax
|| flag_lax_vector_conversions
)
1847 return convertible_lax
;
1849 if (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
1850 && lang_hooks
.types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
1853 if (emit_lax_note
&& !emitted_lax_note
)
1855 emitted_lax_note
= true;
1856 inform (input_location
, "use -flax-vector-conversions to permit "
1857 "conversions between vectors with differing "
1858 "element types or numbers of subparts");
1864 /* This is a helper function of build_binary_op.
1866 For certain operations if both args were extended from the same
1867 smaller type, do the arithmetic in that type and then extend.
1869 BITWISE indicates a bitwise operation.
1870 For them, this optimization is safe only if
1871 both args are zero-extended or both are sign-extended.
1872 Otherwise, we might change the result.
1873 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1874 but calculated in (unsigned short) it would be (unsigned short)-1.
1876 tree
shorten_binary_op (tree result_type
, tree op0
, tree op1
, bool bitwise
)
1878 int unsigned0
, unsigned1
;
1883 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1884 excessive narrowing when we call get_narrower below. For
1885 example, suppose that OP0 is of unsigned int extended
1886 from signed char and that RESULT_TYPE is long long int.
1887 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1890 (long long int) (unsigned int) signed_char
1892 which get_narrower would narrow down to
1894 (unsigned int) signed char
1896 If we do not cast OP0 first, get_narrower would return
1897 signed_char, which is inconsistent with the case of the
1899 op0
= convert (result_type
, op0
);
1900 op1
= convert (result_type
, op1
);
1902 arg0
= get_narrower (op0
, &unsigned0
);
1903 arg1
= get_narrower (op1
, &unsigned1
);
1905 /* UNS is 1 if the operation to be done is an unsigned one. */
1906 uns
= TYPE_UNSIGNED (result_type
);
1908 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1909 but it *requires* conversion to FINAL_TYPE. */
1911 if ((TYPE_PRECISION (TREE_TYPE (op0
))
1912 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1913 && TREE_TYPE (op0
) != result_type
)
1914 unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
1915 if ((TYPE_PRECISION (TREE_TYPE (op1
))
1916 == TYPE_PRECISION (TREE_TYPE (arg1
)))
1917 && TREE_TYPE (op1
) != result_type
)
1918 unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
1920 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1922 /* For bitwise operations, signedness of nominal type
1923 does not matter. Consider only how operands were extended. */
1927 /* Note that in all three cases below we refrain from optimizing
1928 an unsigned operation on sign-extended args.
1929 That would not be valid. */
1931 /* Both args variable: if both extended in same way
1932 from same width, do it in that width.
1933 Do it unsigned if args were zero-extended. */
1934 if ((TYPE_PRECISION (TREE_TYPE (arg0
))
1935 < TYPE_PRECISION (result_type
))
1936 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1937 == TYPE_PRECISION (TREE_TYPE (arg0
)))
1938 && unsigned0
== unsigned1
1939 && (unsigned0
|| !uns
))
1940 return c_common_signed_or_unsigned_type
1941 (unsigned0
, common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
)));
1943 else if (TREE_CODE (arg0
) == INTEGER_CST
1944 && (unsigned1
|| !uns
)
1945 && (TYPE_PRECISION (TREE_TYPE (arg1
))
1946 < TYPE_PRECISION (result_type
))
1948 = c_common_signed_or_unsigned_type (unsigned1
,
1950 && !POINTER_TYPE_P (type
)
1951 && int_fits_type_p (arg0
, type
))
1954 else if (TREE_CODE (arg1
) == INTEGER_CST
1955 && (unsigned0
|| !uns
)
1956 && (TYPE_PRECISION (TREE_TYPE (arg0
))
1957 < TYPE_PRECISION (result_type
))
1959 = c_common_signed_or_unsigned_type (unsigned0
,
1961 && !POINTER_TYPE_P (type
)
1962 && int_fits_type_p (arg1
, type
))
1968 /* Warns if the conversion of EXPR to TYPE may alter a value.
1969 This is a helper function for warnings_for_convert_and_check. */
1972 conversion_warning (tree type
, tree expr
)
1974 bool give_warning
= false;
1977 const int expr_num_operands
= TREE_OPERAND_LENGTH (expr
);
1978 tree expr_type
= TREE_TYPE (expr
);
1980 if (!warn_conversion
&& !warn_sign_conversion
)
1983 /* If any operand is artificial, then this expression was generated
1984 by the compiler and we do not warn. */
1985 for (i
= 0; i
< expr_num_operands
; i
++)
1987 tree op
= TREE_OPERAND (expr
, i
);
1988 if (op
&& DECL_P (op
) && DECL_ARTIFICIAL (op
))
1992 switch (TREE_CODE (expr
))
2000 case TRUTH_ANDIF_EXPR
:
2001 case TRUTH_ORIF_EXPR
:
2002 case TRUTH_AND_EXPR
:
2004 case TRUTH_XOR_EXPR
:
2005 case TRUTH_NOT_EXPR
:
2006 /* Conversion from boolean to a signed:1 bit-field (which only
2007 can hold the values 0 and -1) doesn't lose information - but
2008 it does change the value. */
2009 if (TYPE_PRECISION (type
) == 1 && !TYPE_UNSIGNED (type
))
2010 warning (OPT_Wconversion
,
2011 "conversion to %qT from boolean expression", type
);
2017 /* Warn for real constant that is not an exact integer converted
2019 if (TREE_CODE (expr_type
) == REAL_TYPE
2020 && TREE_CODE (type
) == INTEGER_TYPE
)
2022 if (!real_isinteger (TREE_REAL_CST_PTR (expr
), TYPE_MODE (expr_type
)))
2023 give_warning
= true;
2025 /* Warn for an integer constant that does not fit into integer type. */
2026 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2027 && TREE_CODE (type
) == INTEGER_TYPE
2028 && !int_fits_type_p (expr
, type
))
2030 if (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)
2031 && tree_int_cst_sgn (expr
) < 0)
2032 warning (OPT_Wsign_conversion
,
2033 "negative integer implicitly converted to unsigned type");
2034 else if (!TYPE_UNSIGNED (type
) && TYPE_UNSIGNED (expr_type
))
2035 warning (OPT_Wsign_conversion
, "conversion of unsigned constant "
2036 "value to negative integer");
2038 give_warning
= true;
2040 else if (TREE_CODE (type
) == REAL_TYPE
)
2042 /* Warn for an integer constant that does not fit into real type. */
2043 if (TREE_CODE (expr_type
) == INTEGER_TYPE
)
2045 REAL_VALUE_TYPE a
= real_value_from_int_cst (0, expr
);
2046 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
2047 give_warning
= true;
2049 /* Warn for a real constant that does not fit into a smaller
2051 else if (TREE_CODE (expr_type
) == REAL_TYPE
2052 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2054 REAL_VALUE_TYPE a
= TREE_REAL_CST (expr
);
2055 if (!exact_real_truncate (TYPE_MODE (type
), &a
))
2056 give_warning
= true;
2061 warning (OPT_Wconversion
,
2062 "conversion to %qT alters %qT constant value",
2069 /* In case of COND_EXPR, if both operands are constants or
2070 COND_EXPR, then we do not care about the type of COND_EXPR,
2071 only about the conversion of each operand. */
2072 tree op1
= TREE_OPERAND (expr
, 1);
2073 tree op2
= TREE_OPERAND (expr
, 2);
2075 if ((TREE_CODE (op1
) == REAL_CST
|| TREE_CODE (op1
) == INTEGER_CST
2076 || TREE_CODE (op1
) == COND_EXPR
)
2077 && (TREE_CODE (op2
) == REAL_CST
|| TREE_CODE (op2
) == INTEGER_CST
2078 || TREE_CODE (op2
) == COND_EXPR
))
2080 conversion_warning (type
, op1
);
2081 conversion_warning (type
, op2
);
2087 default: /* 'expr' is not a constant. */
2089 /* Warn for real types converted to integer types. */
2090 if (TREE_CODE (expr_type
) == REAL_TYPE
2091 && TREE_CODE (type
) == INTEGER_TYPE
)
2092 give_warning
= true;
2094 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2095 && TREE_CODE (type
) == INTEGER_TYPE
)
2097 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2098 expr
= get_unwidened (expr
, 0);
2099 expr_type
= TREE_TYPE (expr
);
2101 /* Don't warn for short y; short x = ((int)y & 0xff); */
2102 if (TREE_CODE (expr
) == BIT_AND_EXPR
2103 || TREE_CODE (expr
) == BIT_IOR_EXPR
2104 || TREE_CODE (expr
) == BIT_XOR_EXPR
)
2106 /* If both args were extended from a shortest type,
2107 use that type if that is safe. */
2108 expr_type
= shorten_binary_op (expr_type
,
2109 TREE_OPERAND (expr
, 0),
2110 TREE_OPERAND (expr
, 1),
2113 if (TREE_CODE (expr
) == BIT_AND_EXPR
)
2115 tree op0
= TREE_OPERAND (expr
, 0);
2116 tree op1
= TREE_OPERAND (expr
, 1);
2117 bool unsigned0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
2118 bool unsigned1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
2120 /* If one of the operands is a non-negative constant
2121 that fits in the target type, then the type of the
2122 other operand does not matter. */
2123 if ((TREE_CODE (op0
) == INTEGER_CST
2124 && int_fits_type_p (op0
, c_common_signed_type (type
))
2125 && int_fits_type_p (op0
, c_common_unsigned_type (type
)))
2126 || (TREE_CODE (op1
) == INTEGER_CST
2127 && int_fits_type_p (op1
, c_common_signed_type (type
))
2128 && int_fits_type_p (op1
,
2129 c_common_unsigned_type (type
))))
2131 /* If constant is unsigned and fits in the target
2132 type, then the result will also fit. */
2133 else if ((TREE_CODE (op0
) == INTEGER_CST
2135 && int_fits_type_p (op0
, type
))
2136 || (TREE_CODE (op1
) == INTEGER_CST
2138 && int_fits_type_p (op1
, type
)))
2142 /* Warn for integer types converted to smaller integer types. */
2143 if (TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2144 give_warning
= true;
2146 /* When they are the same width but different signedness,
2147 then the value may change. */
2148 else if ((TYPE_PRECISION (type
) == TYPE_PRECISION (expr_type
)
2149 && TYPE_UNSIGNED (expr_type
) != TYPE_UNSIGNED (type
))
2150 /* Even when converted to a bigger type, if the type is
2151 unsigned but expr is signed, then negative values
2153 || (TYPE_UNSIGNED (type
) && !TYPE_UNSIGNED (expr_type
)))
2154 warning (OPT_Wsign_conversion
, "conversion to %qT from %qT "
2155 "may change the sign of the result",
2159 /* Warn for integer types converted to real types if and only if
2160 all the range of values of the integer type cannot be
2161 represented by the real type. */
2162 else if (TREE_CODE (expr_type
) == INTEGER_TYPE
2163 && TREE_CODE (type
) == REAL_TYPE
)
2165 tree type_low_bound
= TYPE_MIN_VALUE (expr_type
);
2166 tree type_high_bound
= TYPE_MAX_VALUE (expr_type
);
2167 REAL_VALUE_TYPE real_low_bound
2168 = real_value_from_int_cst (0, type_low_bound
);
2169 REAL_VALUE_TYPE real_high_bound
2170 = real_value_from_int_cst (0, type_high_bound
);
2172 if (!exact_real_truncate (TYPE_MODE (type
), &real_low_bound
)
2173 || !exact_real_truncate (TYPE_MODE (type
), &real_high_bound
))
2174 give_warning
= true;
2177 /* Warn for real types converted to smaller real types. */
2178 else if (TREE_CODE (expr_type
) == REAL_TYPE
2179 && TREE_CODE (type
) == REAL_TYPE
2180 && TYPE_PRECISION (type
) < TYPE_PRECISION (expr_type
))
2181 give_warning
= true;
2185 warning (OPT_Wconversion
,
2186 "conversion to %qT from %qT may alter its value",
2191 /* Produce warnings after a conversion. RESULT is the result of
2192 converting EXPR to TYPE. This is a helper function for
2193 convert_and_check and cp_convert_and_check. */
2196 warnings_for_convert_and_check (tree type
, tree expr
, tree result
)
2198 if (TREE_CODE (expr
) == INTEGER_CST
2199 && (TREE_CODE (type
) == INTEGER_TYPE
2200 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2201 && !int_fits_type_p (expr
, type
))
2203 /* Do not diagnose overflow in a constant expression merely
2204 because a conversion overflowed. */
2205 if (TREE_OVERFLOW (result
))
2206 TREE_OVERFLOW (result
) = TREE_OVERFLOW (expr
);
2208 if (TYPE_UNSIGNED (type
))
2210 /* This detects cases like converting -129 or 256 to
2212 if (!int_fits_type_p (expr
, c_common_signed_type (type
)))
2213 warning (OPT_Woverflow
,
2214 "large integer implicitly truncated to unsigned type");
2216 conversion_warning (type
, expr
);
2218 else if (!int_fits_type_p (expr
, c_common_unsigned_type (type
)))
2219 warning (OPT_Woverflow
,
2220 "overflow in implicit constant conversion");
2221 /* No warning for converting 0x80000000 to int. */
2223 && (TREE_CODE (TREE_TYPE (expr
)) != INTEGER_TYPE
2224 || TYPE_PRECISION (TREE_TYPE (expr
))
2225 != TYPE_PRECISION (type
)))
2226 warning (OPT_Woverflow
,
2227 "overflow in implicit constant conversion");
2230 conversion_warning (type
, expr
);
2232 else if ((TREE_CODE (result
) == INTEGER_CST
2233 || TREE_CODE (result
) == FIXED_CST
) && TREE_OVERFLOW (result
))
2234 warning (OPT_Woverflow
,
2235 "overflow in implicit constant conversion");
2237 conversion_warning (type
, expr
);
2241 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2242 Invoke this function on every expression that is converted implicitly,
2243 i.e. because of language rules and not because of an explicit cast. */
2246 convert_and_check (tree type
, tree expr
)
2249 tree expr_for_warning
;
2251 /* Convert from a value with possible excess precision rather than
2252 via the semantic type, but do not warn about values not fitting
2253 exactly in the semantic type. */
2254 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
2256 tree orig_type
= TREE_TYPE (expr
);
2257 expr
= TREE_OPERAND (expr
, 0);
2258 expr_for_warning
= convert (orig_type
, expr
);
2259 if (orig_type
== type
)
2260 return expr_for_warning
;
2263 expr_for_warning
= expr
;
2265 if (TREE_TYPE (expr
) == type
)
2268 result
= convert (type
, expr
);
2270 if (c_inhibit_evaluation_warnings
== 0
2271 && !TREE_OVERFLOW_P (expr
)
2272 && result
!= error_mark_node
)
2273 warnings_for_convert_and_check (type
, expr_for_warning
, result
);
2278 /* A node in a list that describes references to variables (EXPR), which are
2279 either read accesses if WRITER is zero, or write accesses, in which case
2280 WRITER is the parent of EXPR. */
2287 /* Used to implement a cache the results of a call to verify_tree. We only
2288 use this for SAVE_EXPRs. */
2291 struct tlist_cache
*next
;
2292 struct tlist
*cache_before_sp
;
2293 struct tlist
*cache_after_sp
;
2297 /* Obstack to use when allocating tlist structures, and corresponding
2299 static struct obstack tlist_obstack
;
2300 static char *tlist_firstobj
= 0;
2302 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2304 static struct tlist
*warned_ids
;
2305 /* SAVE_EXPRs need special treatment. We process them only once and then
2306 cache the results. */
2307 static struct tlist_cache
*save_expr_cache
;
2309 static void add_tlist (struct tlist
**, struct tlist
*, tree
, int);
2310 static void merge_tlist (struct tlist
**, struct tlist
*, int);
2311 static void verify_tree (tree
, struct tlist
**, struct tlist
**, tree
);
2312 static int warning_candidate_p (tree
);
2313 static bool candidate_equal_p (const_tree
, const_tree
);
2314 static void warn_for_collisions (struct tlist
*);
2315 static void warn_for_collisions_1 (tree
, tree
, struct tlist
*, int);
2316 static struct tlist
*new_tlist (struct tlist
*, tree
, tree
);
2318 /* Create a new struct tlist and fill in its fields. */
2319 static struct tlist
*
2320 new_tlist (struct tlist
*next
, tree t
, tree writer
)
2323 l
= XOBNEW (&tlist_obstack
, struct tlist
);
2330 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2331 is nonnull, we ignore any node we find which has a writer equal to it. */
2334 add_tlist (struct tlist
**to
, struct tlist
*add
, tree exclude_writer
, int copy
)
2338 struct tlist
*next
= add
->next
;
2341 if (!exclude_writer
|| !candidate_equal_p (add
->writer
, exclude_writer
))
2342 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
2347 /* Merge the nodes of ADD into TO. This merging process is done so that for
2348 each variable that already exists in TO, no new node is added; however if
2349 there is a write access recorded in ADD, and an occurrence on TO is only
2350 a read access, then the occurrence in TO will be modified to record the
2354 merge_tlist (struct tlist
**to
, struct tlist
*add
, int copy
)
2356 struct tlist
**end
= to
;
2359 end
= &(*end
)->next
;
2365 struct tlist
*next
= add
->next
;
2367 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
2368 if (candidate_equal_p (tmp2
->expr
, add
->expr
))
2372 tmp2
->writer
= add
->writer
;
2376 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
2377 end
= &(*end
)->next
;
2384 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2385 references in list LIST conflict with it, excluding reads if ONLY writers
2389 warn_for_collisions_1 (tree written
, tree writer
, struct tlist
*list
,
2394 /* Avoid duplicate warnings. */
2395 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
2396 if (candidate_equal_p (tmp
->expr
, written
))
2401 if (candidate_equal_p (list
->expr
, written
)
2402 && !candidate_equal_p (list
->writer
, writer
)
2403 && (!only_writes
|| list
->writer
))
2405 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
2406 warning_at (EXPR_HAS_LOCATION (writer
)
2407 ? EXPR_LOCATION (writer
) : input_location
,
2408 OPT_Wsequence_point
, "operation on %qE may be undefined",
2415 /* Given a list LIST of references to variables, find whether any of these
2416 can cause conflicts due to missing sequence points. */
2419 warn_for_collisions (struct tlist
*list
)
2423 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
2426 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
2430 /* Return nonzero if X is a tree that can be verified by the sequence point
2433 warning_candidate_p (tree x
)
2435 /* !VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2436 (lvalue_p) crash on TRY/CATCH. */
2437 return !(DECL_P (x
) && DECL_ARTIFICIAL (x
))
2438 && TREE_TYPE (x
) && !VOID_TYPE_P (TREE_TYPE (x
)) && lvalue_p (x
);
2441 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2443 candidate_equal_p (const_tree x
, const_tree y
)
2445 return (x
== y
) || (x
&& y
&& operand_equal_p (x
, y
, 0));
2448 /* Walk the tree X, and record accesses to variables. If X is written by the
2449 parent tree, WRITER is the parent.
2450 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2451 expression or its only operand forces a sequence point, then everything up
2452 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2454 Once we return, we will have emitted warnings if any subexpression before
2455 such a sequence point could be undefined. On a higher level, however, the
2456 sequence point may not be relevant, and we'll merge the two lists.
2458 Example: (b++, a) + b;
2459 The call that processes the COMPOUND_EXPR will store the increment of B
2460 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2461 processes the PLUS_EXPR will need to merge the two lists so that
2462 eventually, all accesses end up on the same list (and we'll warn about the
2463 unordered subexpressions b++ and b.
2465 A note on merging. If we modify the former example so that our expression
2468 care must be taken not simply to add all three expressions into the final
2469 PNO_SP list. The function merge_tlist takes care of that by merging the
2470 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2471 way, so that no more than one access to B is recorded. */
2474 verify_tree (tree x
, struct tlist
**pbefore_sp
, struct tlist
**pno_sp
,
2477 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
2478 enum tree_code code
;
2479 enum tree_code_class cl
;
2481 /* X may be NULL if it is the operand of an empty statement expression
2487 code
= TREE_CODE (x
);
2488 cl
= TREE_CODE_CLASS (code
);
2490 if (warning_candidate_p (x
))
2491 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
2499 case TRUTH_ANDIF_EXPR
:
2500 case TRUTH_ORIF_EXPR
:
2501 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2502 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2503 warn_for_collisions (tmp_nosp
);
2504 merge_tlist (pbefore_sp
, tmp_before
, 0);
2505 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
2506 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
2507 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2511 tmp_before
= tmp_list2
= 0;
2512 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
2513 warn_for_collisions (tmp_list2
);
2514 merge_tlist (pbefore_sp
, tmp_before
, 0);
2515 merge_tlist (pbefore_sp
, tmp_list2
, 1);
2517 tmp_list3
= tmp_nosp
= 0;
2518 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
2519 warn_for_collisions (tmp_nosp
);
2520 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2522 tmp_list3
= tmp_list2
= 0;
2523 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
2524 warn_for_collisions (tmp_list2
);
2525 merge_tlist (pbefore_sp
, tmp_list3
, 0);
2526 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2527 two first, to avoid warning for (a ? b++ : b++). */
2528 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
2529 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2532 case PREDECREMENT_EXPR
:
2533 case PREINCREMENT_EXPR
:
2534 case POSTDECREMENT_EXPR
:
2535 case POSTINCREMENT_EXPR
:
2536 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
2540 tmp_before
= tmp_nosp
= tmp_list3
= 0;
2541 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2542 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
2543 /* Expressions inside the LHS are not ordered wrt. the sequence points
2544 in the RHS. Example:
2546 Despite the fact that the modification of "a" is in the before_sp
2547 list (tmp_before), it conflicts with the use of "a" in the LHS.
2548 We can handle this by adding the contents of tmp_list3
2549 to those of tmp_before, and redoing the collision warnings for that
2551 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
2552 warn_for_collisions (tmp_before
);
2553 /* Exclude the LHS itself here; we first have to merge it into the
2554 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2555 didn't exclude the LHS, we'd get it twice, once as a read and once
2557 add_tlist (pno_sp
, tmp_list3
, x
, 0);
2558 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
2560 merge_tlist (pbefore_sp
, tmp_before
, 0);
2561 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
2562 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
2563 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
2567 /* We need to warn about conflicts among arguments and conflicts between
2568 args and the function address. Side effects of the function address,
2569 however, are not ordered by the sequence point of the call. */
2571 call_expr_arg_iterator iter
;
2573 tmp_before
= tmp_nosp
= 0;
2574 verify_tree (CALL_EXPR_FN (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2575 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, x
)
2577 tmp_list2
= tmp_list3
= 0;
2578 verify_tree (arg
, &tmp_list2
, &tmp_list3
, NULL_TREE
);
2579 merge_tlist (&tmp_list3
, tmp_list2
, 0);
2580 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
2582 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
2583 warn_for_collisions (tmp_before
);
2584 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
2589 /* Scan all the list, e.g. indices of multi dimensional array. */
2592 tmp_before
= tmp_nosp
= 0;
2593 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2594 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2595 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2602 struct tlist_cache
*t
;
2603 for (t
= save_expr_cache
; t
; t
= t
->next
)
2604 if (candidate_equal_p (t
->expr
, x
))
2609 t
= XOBNEW (&tlist_obstack
, struct tlist_cache
);
2610 t
->next
= save_expr_cache
;
2612 save_expr_cache
= t
;
2614 tmp_before
= tmp_nosp
= 0;
2615 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
2616 warn_for_collisions (tmp_nosp
);
2621 struct tlist
*t
= tmp_nosp
;
2623 merge_tlist (&tmp_list3
, t
, 0);
2625 t
->cache_before_sp
= tmp_before
;
2626 t
->cache_after_sp
= tmp_list3
;
2628 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
2629 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
2634 x
= TREE_OPERAND (x
, 0);
2641 /* For other expressions, simply recurse on their operands.
2642 Manual tail recursion for unary expressions.
2643 Other non-expressions need not be processed. */
2644 if (cl
== tcc_unary
)
2646 x
= TREE_OPERAND (x
, 0);
2650 else if (IS_EXPR_CODE_CLASS (cl
))
2653 int max
= TREE_OPERAND_LENGTH (x
);
2654 for (lp
= 0; lp
< max
; lp
++)
2656 tmp_before
= tmp_nosp
= 0;
2657 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, 0);
2658 merge_tlist (&tmp_nosp
, tmp_before
, 0);
2659 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
2666 /* Try to warn for undefined behavior in EXPR due to missing sequence
2670 verify_sequence_points (tree expr
)
2672 struct tlist
*before_sp
= 0, *after_sp
= 0;
2675 save_expr_cache
= 0;
2676 if (tlist_firstobj
== 0)
2678 gcc_obstack_init (&tlist_obstack
);
2679 tlist_firstobj
= (char *) obstack_alloc (&tlist_obstack
, 0);
2682 verify_tree (expr
, &before_sp
, &after_sp
, 0);
2683 warn_for_collisions (after_sp
);
2684 obstack_free (&tlist_obstack
, tlist_firstobj
);
2687 /* Validate the expression after `case' and apply default promotions. */
2690 check_case_value (tree value
)
2692 if (value
== NULL_TREE
)
2695 /* ??? Can we ever get nops here for a valid case value? We
2697 STRIP_TYPE_NOPS (value
);
2698 /* In C++, the following is allowed:
2701 switch (...) { case i: ... }
2703 So, we try to reduce the VALUE to a constant that way. */
2704 if (c_dialect_cxx ())
2706 value
= decl_constant_value (value
);
2707 STRIP_TYPE_NOPS (value
);
2708 value
= fold (value
);
2711 if (TREE_CODE (value
) == INTEGER_CST
)
2712 /* Promote char or short to int. */
2713 value
= perform_integral_promotions (value
);
2714 else if (value
!= error_mark_node
)
2716 error ("case label does not reduce to an integer constant");
2717 value
= error_mark_node
;
2720 constant_expression_warning (value
);
2725 /* See if the case values LOW and HIGH are in the range of the original
2726 type (i.e. before the default conversion to int) of the switch testing
2728 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2729 the type before promoting it. CASE_LOW_P is a pointer to the lower
2730 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2731 if the case is not a case range.
2732 The caller has to make sure that we are not called with NULL for
2733 CASE_LOW_P (i.e. the default case).
2734 Returns true if the case label is in range of ORIG_TYPE (saturated or
2735 untouched) or false if the label is out of range. */
2738 check_case_bounds (tree type
, tree orig_type
,
2739 tree
*case_low_p
, tree
*case_high_p
)
2741 tree min_value
, max_value
;
2742 tree case_low
= *case_low_p
;
2743 tree case_high
= case_high_p
? *case_high_p
: case_low
;
2745 /* If there was a problem with the original type, do nothing. */
2746 if (orig_type
== error_mark_node
)
2749 min_value
= TYPE_MIN_VALUE (orig_type
);
2750 max_value
= TYPE_MAX_VALUE (orig_type
);
2752 /* Case label is less than minimum for type. */
2753 if (tree_int_cst_compare (case_low
, min_value
) < 0
2754 && tree_int_cst_compare (case_high
, min_value
) < 0)
2756 warning (0, "case label value is less than minimum value for type");
2760 /* Case value is greater than maximum for type. */
2761 if (tree_int_cst_compare (case_low
, max_value
) > 0
2762 && tree_int_cst_compare (case_high
, max_value
) > 0)
2764 warning (0, "case label value exceeds maximum value for type");
2768 /* Saturate lower case label value to minimum. */
2769 if (tree_int_cst_compare (case_high
, min_value
) >= 0
2770 && tree_int_cst_compare (case_low
, min_value
) < 0)
2772 warning (0, "lower value in case label range"
2773 " less than minimum value for type");
2774 case_low
= min_value
;
2777 /* Saturate upper case label value to maximum. */
2778 if (tree_int_cst_compare (case_low
, max_value
) <= 0
2779 && tree_int_cst_compare (case_high
, max_value
) > 0)
2781 warning (0, "upper value in case label range"
2782 " exceeds maximum value for type");
2783 case_high
= max_value
;
2786 if (*case_low_p
!= case_low
)
2787 *case_low_p
= convert (type
, case_low
);
2788 if (case_high_p
&& *case_high_p
!= case_high
)
2789 *case_high_p
= convert (type
, case_high
);
2794 /* Return an integer type with BITS bits of precision,
2795 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2798 c_common_type_for_size (unsigned int bits
, int unsignedp
)
2800 if (bits
== TYPE_PRECISION (integer_type_node
))
2801 return unsignedp
? unsigned_type_node
: integer_type_node
;
2803 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2804 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2806 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2807 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2809 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2810 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2812 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2813 return (unsignedp
? long_long_unsigned_type_node
2814 : long_long_integer_type_node
);
2816 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2817 return (unsignedp
? widest_unsigned_literal_type_node
2818 : widest_integer_literal_type_node
);
2820 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2821 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2823 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2824 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2826 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2827 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2829 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2830 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2835 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2836 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2837 and saturating if SATP is nonzero, otherwise not saturating. */
2840 c_common_fixed_point_type_for_size (unsigned int ibit
, unsigned int fbit
,
2841 int unsignedp
, int satp
)
2843 enum machine_mode mode
;
2845 mode
= unsignedp
? UQQmode
: QQmode
;
2847 mode
= unsignedp
? UHAmode
: HAmode
;
2849 for (; mode
!= VOIDmode
; mode
= GET_MODE_WIDER_MODE (mode
))
2850 if (GET_MODE_IBIT (mode
) >= ibit
&& GET_MODE_FBIT (mode
) >= fbit
)
2853 if (mode
== VOIDmode
|| !targetm
.scalar_mode_supported_p (mode
))
2855 sorry ("GCC cannot support operators with integer types and "
2856 "fixed-point types that have too many integral and "
2857 "fractional bits together");
2861 return c_common_type_for_mode (mode
, satp
);
2864 /* Used for communication between c_common_type_for_mode and
2865 c_register_builtin_type. */
2866 static GTY(()) tree registered_builtin_types
;
2868 /* Return a data type that has machine mode MODE.
2869 If the mode is an integer,
2870 then UNSIGNEDP selects between signed and unsigned types.
2871 If the mode is a fixed-point mode,
2872 then UNSIGNEDP selects between saturating and nonsaturating types. */
2875 c_common_type_for_mode (enum machine_mode mode
, int unsignedp
)
2879 if (mode
== TYPE_MODE (integer_type_node
))
2880 return unsignedp
? unsigned_type_node
: integer_type_node
;
2882 if (mode
== TYPE_MODE (signed_char_type_node
))
2883 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2885 if (mode
== TYPE_MODE (short_integer_type_node
))
2886 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2888 if (mode
== TYPE_MODE (long_integer_type_node
))
2889 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2891 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2892 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
2894 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
2895 return unsignedp
? widest_unsigned_literal_type_node
2896 : widest_integer_literal_type_node
;
2899 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2902 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2905 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2908 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2910 #if HOST_BITS_PER_WIDE_INT >= 64
2911 if (mode
== TYPE_MODE (intTI_type_node
))
2912 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
2915 if (mode
== TYPE_MODE (float_type_node
))
2916 return float_type_node
;
2918 if (mode
== TYPE_MODE (double_type_node
))
2919 return double_type_node
;
2921 if (mode
== TYPE_MODE (long_double_type_node
))
2922 return long_double_type_node
;
2924 if (mode
== TYPE_MODE (void_type_node
))
2925 return void_type_node
;
2927 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
2929 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2930 : make_signed_type (GET_MODE_PRECISION (mode
)));
2932 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
2934 ? make_unsigned_type (GET_MODE_PRECISION (mode
))
2935 : make_signed_type (GET_MODE_PRECISION (mode
)));
2937 if (COMPLEX_MODE_P (mode
))
2939 enum machine_mode inner_mode
;
2942 if (mode
== TYPE_MODE (complex_float_type_node
))
2943 return complex_float_type_node
;
2944 if (mode
== TYPE_MODE (complex_double_type_node
))
2945 return complex_double_type_node
;
2946 if (mode
== TYPE_MODE (complex_long_double_type_node
))
2947 return complex_long_double_type_node
;
2949 if (mode
== TYPE_MODE (complex_integer_type_node
) && !unsignedp
)
2950 return complex_integer_type_node
;
2952 inner_mode
= GET_MODE_INNER (mode
);
2953 inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2954 if (inner_type
!= NULL_TREE
)
2955 return build_complex_type (inner_type
);
2957 else if (VECTOR_MODE_P (mode
))
2959 enum machine_mode inner_mode
= GET_MODE_INNER (mode
);
2960 tree inner_type
= c_common_type_for_mode (inner_mode
, unsignedp
);
2961 if (inner_type
!= NULL_TREE
)
2962 return build_vector_type_for_mode (inner_type
, mode
);
2965 if (mode
== TYPE_MODE (dfloat32_type_node
))
2966 return dfloat32_type_node
;
2967 if (mode
== TYPE_MODE (dfloat64_type_node
))
2968 return dfloat64_type_node
;
2969 if (mode
== TYPE_MODE (dfloat128_type_node
))
2970 return dfloat128_type_node
;
2972 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode
))
2974 if (mode
== TYPE_MODE (short_fract_type_node
))
2975 return unsignedp
? sat_short_fract_type_node
: short_fract_type_node
;
2976 if (mode
== TYPE_MODE (fract_type_node
))
2977 return unsignedp
? sat_fract_type_node
: fract_type_node
;
2978 if (mode
== TYPE_MODE (long_fract_type_node
))
2979 return unsignedp
? sat_long_fract_type_node
: long_fract_type_node
;
2980 if (mode
== TYPE_MODE (long_long_fract_type_node
))
2981 return unsignedp
? sat_long_long_fract_type_node
2982 : long_long_fract_type_node
;
2984 if (mode
== TYPE_MODE (unsigned_short_fract_type_node
))
2985 return unsignedp
? sat_unsigned_short_fract_type_node
2986 : unsigned_short_fract_type_node
;
2987 if (mode
== TYPE_MODE (unsigned_fract_type_node
))
2988 return unsignedp
? sat_unsigned_fract_type_node
2989 : unsigned_fract_type_node
;
2990 if (mode
== TYPE_MODE (unsigned_long_fract_type_node
))
2991 return unsignedp
? sat_unsigned_long_fract_type_node
2992 : unsigned_long_fract_type_node
;
2993 if (mode
== TYPE_MODE (unsigned_long_long_fract_type_node
))
2994 return unsignedp
? sat_unsigned_long_long_fract_type_node
2995 : unsigned_long_long_fract_type_node
;
2997 if (mode
== TYPE_MODE (short_accum_type_node
))
2998 return unsignedp
? sat_short_accum_type_node
: short_accum_type_node
;
2999 if (mode
== TYPE_MODE (accum_type_node
))
3000 return unsignedp
? sat_accum_type_node
: accum_type_node
;
3001 if (mode
== TYPE_MODE (long_accum_type_node
))
3002 return unsignedp
? sat_long_accum_type_node
: long_accum_type_node
;
3003 if (mode
== TYPE_MODE (long_long_accum_type_node
))
3004 return unsignedp
? sat_long_long_accum_type_node
3005 : long_long_accum_type_node
;
3007 if (mode
== TYPE_MODE (unsigned_short_accum_type_node
))
3008 return unsignedp
? sat_unsigned_short_accum_type_node
3009 : unsigned_short_accum_type_node
;
3010 if (mode
== TYPE_MODE (unsigned_accum_type_node
))
3011 return unsignedp
? sat_unsigned_accum_type_node
3012 : unsigned_accum_type_node
;
3013 if (mode
== TYPE_MODE (unsigned_long_accum_type_node
))
3014 return unsignedp
? sat_unsigned_long_accum_type_node
3015 : unsigned_long_accum_type_node
;
3016 if (mode
== TYPE_MODE (unsigned_long_long_accum_type_node
))
3017 return unsignedp
? sat_unsigned_long_long_accum_type_node
3018 : unsigned_long_long_accum_type_node
;
3021 return unsignedp
? sat_qq_type_node
: qq_type_node
;
3023 return unsignedp
? sat_hq_type_node
: hq_type_node
;
3025 return unsignedp
? sat_sq_type_node
: sq_type_node
;
3027 return unsignedp
? sat_dq_type_node
: dq_type_node
;
3029 return unsignedp
? sat_tq_type_node
: tq_type_node
;
3031 if (mode
== UQQmode
)
3032 return unsignedp
? sat_uqq_type_node
: uqq_type_node
;
3033 if (mode
== UHQmode
)
3034 return unsignedp
? sat_uhq_type_node
: uhq_type_node
;
3035 if (mode
== USQmode
)
3036 return unsignedp
? sat_usq_type_node
: usq_type_node
;
3037 if (mode
== UDQmode
)
3038 return unsignedp
? sat_udq_type_node
: udq_type_node
;
3039 if (mode
== UTQmode
)
3040 return unsignedp
? sat_utq_type_node
: utq_type_node
;
3043 return unsignedp
? sat_ha_type_node
: ha_type_node
;
3045 return unsignedp
? sat_sa_type_node
: sa_type_node
;
3047 return unsignedp
? sat_da_type_node
: da_type_node
;
3049 return unsignedp
? sat_ta_type_node
: ta_type_node
;
3051 if (mode
== UHAmode
)
3052 return unsignedp
? sat_uha_type_node
: uha_type_node
;
3053 if (mode
== USAmode
)
3054 return unsignedp
? sat_usa_type_node
: usa_type_node
;
3055 if (mode
== UDAmode
)
3056 return unsignedp
? sat_uda_type_node
: uda_type_node
;
3057 if (mode
== UTAmode
)
3058 return unsignedp
? sat_uta_type_node
: uta_type_node
;
3061 for (t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
3062 if (TYPE_MODE (TREE_VALUE (t
)) == mode
)
3063 return TREE_VALUE (t
);
3069 c_common_unsigned_type (tree type
)
3071 return c_common_signed_or_unsigned_type (1, type
);
3074 /* Return a signed type the same as TYPE in other respects. */
3077 c_common_signed_type (tree type
)
3079 return c_common_signed_or_unsigned_type (0, type
);
3082 /* Return a type the same as TYPE except unsigned or
3083 signed according to UNSIGNEDP. */
3086 c_common_signed_or_unsigned_type (int unsignedp
, tree type
)
3090 /* This block of code emulates the behavior of the old
3091 c_common_unsigned_type. In particular, it returns
3092 long_unsigned_type_node if passed a long, even when a int would
3093 have the same size. This is necessary for warnings to work
3094 correctly in archs where sizeof(int) == sizeof(long) */
3096 type1
= TYPE_MAIN_VARIANT (type
);
3097 if (type1
== signed_char_type_node
|| type1
== char_type_node
|| type1
== unsigned_char_type_node
)
3098 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3099 if (type1
== integer_type_node
|| type1
== unsigned_type_node
)
3100 return unsignedp
? unsigned_type_node
: integer_type_node
;
3101 if (type1
== short_integer_type_node
|| type1
== short_unsigned_type_node
)
3102 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3103 if (type1
== long_integer_type_node
|| type1
== long_unsigned_type_node
)
3104 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3105 if (type1
== long_long_integer_type_node
|| type1
== long_long_unsigned_type_node
)
3106 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
3107 if (type1
== widest_integer_literal_type_node
|| type1
== widest_unsigned_literal_type_node
)
3108 return unsignedp
? widest_unsigned_literal_type_node
: widest_integer_literal_type_node
;
3109 #if HOST_BITS_PER_WIDE_INT >= 64
3110 if (type1
== intTI_type_node
|| type1
== unsigned_intTI_type_node
)
3111 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3113 if (type1
== intDI_type_node
|| type1
== unsigned_intDI_type_node
)
3114 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3115 if (type1
== intSI_type_node
|| type1
== unsigned_intSI_type_node
)
3116 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3117 if (type1
== intHI_type_node
|| type1
== unsigned_intHI_type_node
)
3118 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3119 if (type1
== intQI_type_node
|| type1
== unsigned_intQI_type_node
)
3120 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3122 #define C_COMMON_FIXED_TYPES(NAME) \
3123 if (type1 == short_ ## NAME ## _type_node \
3124 || type1 == unsigned_short_ ## NAME ## _type_node) \
3125 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3126 : short_ ## NAME ## _type_node; \
3127 if (type1 == NAME ## _type_node \
3128 || type1 == unsigned_ ## NAME ## _type_node) \
3129 return unsignedp ? unsigned_ ## NAME ## _type_node \
3130 : NAME ## _type_node; \
3131 if (type1 == long_ ## NAME ## _type_node \
3132 || type1 == unsigned_long_ ## NAME ## _type_node) \
3133 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3134 : long_ ## NAME ## _type_node; \
3135 if (type1 == long_long_ ## NAME ## _type_node \
3136 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3137 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3138 : long_long_ ## NAME ## _type_node;
3140 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3141 if (type1 == NAME ## _type_node \
3142 || type1 == u ## NAME ## _type_node) \
3143 return unsignedp ? u ## NAME ## _type_node \
3144 : NAME ## _type_node;
3146 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3147 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3148 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3149 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3150 : sat_ ## short_ ## NAME ## _type_node; \
3151 if (type1 == sat_ ## NAME ## _type_node \
3152 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3153 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3154 : sat_ ## NAME ## _type_node; \
3155 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3156 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3157 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3158 : sat_ ## long_ ## NAME ## _type_node; \
3159 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3160 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3161 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3162 : sat_ ## long_long_ ## NAME ## _type_node;
3164 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3165 if (type1 == sat_ ## NAME ## _type_node \
3166 || type1 == sat_ ## u ## NAME ## _type_node) \
3167 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3168 : sat_ ## NAME ## _type_node;
3170 C_COMMON_FIXED_TYPES (fract
);
3171 C_COMMON_FIXED_TYPES_SAT (fract
);
3172 C_COMMON_FIXED_TYPES (accum
);
3173 C_COMMON_FIXED_TYPES_SAT (accum
);
3175 C_COMMON_FIXED_MODE_TYPES (qq
);
3176 C_COMMON_FIXED_MODE_TYPES (hq
);
3177 C_COMMON_FIXED_MODE_TYPES (sq
);
3178 C_COMMON_FIXED_MODE_TYPES (dq
);
3179 C_COMMON_FIXED_MODE_TYPES (tq
);
3180 C_COMMON_FIXED_MODE_TYPES_SAT (qq
);
3181 C_COMMON_FIXED_MODE_TYPES_SAT (hq
);
3182 C_COMMON_FIXED_MODE_TYPES_SAT (sq
);
3183 C_COMMON_FIXED_MODE_TYPES_SAT (dq
);
3184 C_COMMON_FIXED_MODE_TYPES_SAT (tq
);
3185 C_COMMON_FIXED_MODE_TYPES (ha
);
3186 C_COMMON_FIXED_MODE_TYPES (sa
);
3187 C_COMMON_FIXED_MODE_TYPES (da
);
3188 C_COMMON_FIXED_MODE_TYPES (ta
);
3189 C_COMMON_FIXED_MODE_TYPES_SAT (ha
);
3190 C_COMMON_FIXED_MODE_TYPES_SAT (sa
);
3191 C_COMMON_FIXED_MODE_TYPES_SAT (da
);
3192 C_COMMON_FIXED_MODE_TYPES_SAT (ta
);
3194 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3195 the precision; they have precision set to match their range, but
3196 may use a wider mode to match an ABI. If we change modes, we may
3197 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3198 the precision as well, so as to yield correct results for
3199 bit-field types. C++ does not have these separate bit-field
3200 types, and producing a signed or unsigned variant of an
3201 ENUMERAL_TYPE may cause other problems as well. */
3203 if (!INTEGRAL_TYPE_P (type
)
3204 || TYPE_UNSIGNED (type
) == unsignedp
)
3207 #define TYPE_OK(node) \
3208 (TYPE_MODE (type) == TYPE_MODE (node) \
3209 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3210 if (TYPE_OK (signed_char_type_node
))
3211 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3212 if (TYPE_OK (integer_type_node
))
3213 return unsignedp
? unsigned_type_node
: integer_type_node
;
3214 if (TYPE_OK (short_integer_type_node
))
3215 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3216 if (TYPE_OK (long_integer_type_node
))
3217 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3218 if (TYPE_OK (long_long_integer_type_node
))
3219 return (unsignedp
? long_long_unsigned_type_node
3220 : long_long_integer_type_node
);
3221 if (TYPE_OK (widest_integer_literal_type_node
))
3222 return (unsignedp
? widest_unsigned_literal_type_node
3223 : widest_integer_literal_type_node
);
3225 #if HOST_BITS_PER_WIDE_INT >= 64
3226 if (TYPE_OK (intTI_type_node
))
3227 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3229 if (TYPE_OK (intDI_type_node
))
3230 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3231 if (TYPE_OK (intSI_type_node
))
3232 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3233 if (TYPE_OK (intHI_type_node
))
3234 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3235 if (TYPE_OK (intQI_type_node
))
3236 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3239 return build_nonstandard_integer_type (TYPE_PRECISION (type
), unsignedp
);
3242 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3245 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width
, int unsignedp
)
3247 /* Extended integer types of the same width as a standard type have
3248 lesser rank, so those of the same width as int promote to int or
3249 unsigned int and are valid for printf formats expecting int or
3250 unsigned int. To avoid such special cases, avoid creating
3251 extended integer types for bit-fields if a standard integer type
3253 if (width
== TYPE_PRECISION (integer_type_node
))
3254 return unsignedp
? unsigned_type_node
: integer_type_node
;
3255 if (width
== TYPE_PRECISION (signed_char_type_node
))
3256 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3257 if (width
== TYPE_PRECISION (short_integer_type_node
))
3258 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3259 if (width
== TYPE_PRECISION (long_integer_type_node
))
3260 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3261 if (width
== TYPE_PRECISION (long_long_integer_type_node
))
3262 return (unsignedp
? long_long_unsigned_type_node
3263 : long_long_integer_type_node
);
3264 return build_nonstandard_integer_type (width
, unsignedp
);
3267 /* The C version of the register_builtin_type langhook. */
3270 c_register_builtin_type (tree type
, const char* name
)
3274 decl
= build_decl (UNKNOWN_LOCATION
,
3275 TYPE_DECL
, get_identifier (name
), type
);
3276 DECL_ARTIFICIAL (decl
) = 1;
3277 if (!TYPE_NAME (type
))
3278 TYPE_NAME (type
) = decl
;
3281 registered_builtin_types
= tree_cons (0, type
, registered_builtin_types
);
3284 /* Print an error message for invalid operands to arith operation
3285 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3286 LOCATION is the location of the message. */
3289 binary_op_error (location_t location
, enum tree_code code
,
3290 tree type0
, tree type1
)
3297 opname
= "+"; break;
3299 opname
= "-"; break;
3301 opname
= "*"; break;
3303 opname
= "max"; break;
3305 opname
= "min"; break;
3307 opname
= "=="; break;
3309 opname
= "!="; break;
3311 opname
= "<="; break;
3313 opname
= ">="; break;
3315 opname
= "<"; break;
3317 opname
= ">"; break;
3319 opname
= "<<"; break;
3321 opname
= ">>"; break;
3322 case TRUNC_MOD_EXPR
:
3323 case FLOOR_MOD_EXPR
:
3324 opname
= "%"; break;
3325 case TRUNC_DIV_EXPR
:
3326 case FLOOR_DIV_EXPR
:
3327 opname
= "/"; break;
3329 opname
= "&"; break;
3331 opname
= "|"; break;
3332 case TRUTH_ANDIF_EXPR
:
3333 opname
= "&&"; break;
3334 case TRUTH_ORIF_EXPR
:
3335 opname
= "||"; break;
3337 opname
= "^"; break;
3342 "invalid operands to binary %s (have %qT and %qT)", opname
,
3346 /* Subroutine of build_binary_op, used for comparison operations.
3347 See if the operands have both been converted from subword integer types
3348 and, if so, perhaps change them both back to their original type.
3349 This function is also responsible for converting the two operands
3350 to the proper common type for comparison.
3352 The arguments of this function are all pointers to local variables
3353 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3354 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3356 If this function returns nonzero, it means that the comparison has
3357 a constant value. What this function returns is an expression for
3361 shorten_compare (tree
*op0_ptr
, tree
*op1_ptr
, tree
*restype_ptr
,
3362 enum tree_code
*rescode_ptr
)
3365 tree op0
= *op0_ptr
;
3366 tree op1
= *op1_ptr
;
3367 int unsignedp0
, unsignedp1
;
3369 tree primop0
, primop1
;
3370 enum tree_code code
= *rescode_ptr
;
3372 /* Throw away any conversions to wider types
3373 already present in the operands. */
3375 primop0
= get_narrower (op0
, &unsignedp0
);
3376 primop1
= get_narrower (op1
, &unsignedp1
);
3378 /* Handle the case that OP0 does not *contain* a conversion
3379 but it *requires* conversion to FINAL_TYPE. */
3381 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
3382 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (op0
));
3383 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
3384 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (op1
));
3386 /* If one of the operands must be floated, we cannot optimize. */
3387 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
3388 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
3390 /* If first arg is constant, swap the args (changing operation
3391 so value is preserved), for canonicalization. Don't do this if
3392 the second arg is 0. */
3394 if (TREE_CONSTANT (primop0
)
3395 && !integer_zerop (primop1
) && !real_zerop (primop1
)
3396 && !fixed_zerop (primop1
))
3399 int temi
= unsignedp0
;
3407 unsignedp0
= unsignedp1
;
3430 *rescode_ptr
= code
;
3433 /* If comparing an integer against a constant more bits wide,
3434 maybe we can deduce a value of 1 or 0 independent of the data.
3435 Or else truncate the constant now
3436 rather than extend the variable at run time.
3438 This is only interesting if the constant is the wider arg.
3439 Also, it is not safe if the constant is unsigned and the
3440 variable arg is signed, since in this case the variable
3441 would be sign-extended and then regarded as unsigned.
3442 Our technique fails in this case because the lowest/highest
3443 possible unsigned results don't follow naturally from the
3444 lowest/highest possible values of the variable operand.
3445 For just EQ_EXPR and NE_EXPR there is another technique that
3446 could be used: see if the constant can be faithfully represented
3447 in the other operand's type, by truncating it and reextending it
3448 and see if that preserves the constant's value. */
3450 if (!real1
&& !real2
3451 && TREE_CODE (TREE_TYPE (primop0
)) != FIXED_POINT_TYPE
3452 && TREE_CODE (primop1
) == INTEGER_CST
3453 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
3455 int min_gt
, max_gt
, min_lt
, max_lt
;
3456 tree maxval
, minval
;
3457 /* 1 if comparison is nominally unsigned. */
3458 int unsignedp
= TYPE_UNSIGNED (*restype_ptr
);
3461 type
= c_common_signed_or_unsigned_type (unsignedp0
,
3462 TREE_TYPE (primop0
));
3464 maxval
= TYPE_MAX_VALUE (type
);
3465 minval
= TYPE_MIN_VALUE (type
);
3467 if (unsignedp
&& !unsignedp0
)
3468 *restype_ptr
= c_common_signed_type (*restype_ptr
);
3470 if (TREE_TYPE (primop1
) != *restype_ptr
)
3472 /* Convert primop1 to target type, but do not introduce
3473 additional overflow. We know primop1 is an int_cst. */
3474 primop1
= force_fit_type_double (*restype_ptr
,
3475 TREE_INT_CST_LOW (primop1
),
3476 TREE_INT_CST_HIGH (primop1
), 0,
3477 TREE_OVERFLOW (primop1
));
3479 if (type
!= *restype_ptr
)
3481 minval
= convert (*restype_ptr
, minval
);
3482 maxval
= convert (*restype_ptr
, maxval
);
3485 if (unsignedp
&& unsignedp0
)
3487 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
3488 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
3489 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
3490 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
3494 min_gt
= INT_CST_LT (primop1
, minval
);
3495 max_gt
= INT_CST_LT (primop1
, maxval
);
3496 min_lt
= INT_CST_LT (minval
, primop1
);
3497 max_lt
= INT_CST_LT (maxval
, primop1
);
3501 /* This used to be a switch, but Genix compiler can't handle that. */
3502 if (code
== NE_EXPR
)
3504 if (max_lt
|| min_gt
)
3505 val
= truthvalue_true_node
;
3507 else if (code
== EQ_EXPR
)
3509 if (max_lt
|| min_gt
)
3510 val
= truthvalue_false_node
;
3512 else if (code
== LT_EXPR
)
3515 val
= truthvalue_true_node
;
3517 val
= truthvalue_false_node
;
3519 else if (code
== GT_EXPR
)
3522 val
= truthvalue_true_node
;
3524 val
= truthvalue_false_node
;
3526 else if (code
== LE_EXPR
)
3529 val
= truthvalue_true_node
;
3531 val
= truthvalue_false_node
;
3533 else if (code
== GE_EXPR
)
3536 val
= truthvalue_true_node
;
3538 val
= truthvalue_false_node
;
3541 /* If primop0 was sign-extended and unsigned comparison specd,
3542 we did a signed comparison above using the signed type bounds.
3543 But the comparison we output must be unsigned.
3545 Also, for inequalities, VAL is no good; but if the signed
3546 comparison had *any* fixed result, it follows that the
3547 unsigned comparison just tests the sign in reverse
3548 (positive values are LE, negative ones GE).
3549 So we can generate an unsigned comparison
3550 against an extreme value of the signed type. */
3552 if (unsignedp
&& !unsignedp0
)
3559 primop1
= TYPE_MIN_VALUE (type
);
3565 primop1
= TYPE_MAX_VALUE (type
);
3572 type
= c_common_unsigned_type (type
);
3575 if (TREE_CODE (primop0
) != INTEGER_CST
)
3577 if (val
== truthvalue_false_node
)
3578 warning (OPT_Wtype_limits
, "comparison is always false due to limited range of data type");
3579 if (val
== truthvalue_true_node
)
3580 warning (OPT_Wtype_limits
, "comparison is always true due to limited range of data type");
3585 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3586 if (TREE_SIDE_EFFECTS (primop0
))
3587 return build2 (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
3591 /* Value is not predetermined, but do the comparison
3592 in the type of the operand that is not constant.
3593 TYPE is already properly set. */
3596 /* If either arg is decimal float and the other is float, find the
3597 proper common type to use for comparison. */
3598 else if (real1
&& real2
3599 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0
)))
3600 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1
)))))
3601 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3603 else if (real1
&& real2
3604 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3605 == TYPE_PRECISION (TREE_TYPE (primop1
))))
3606 type
= TREE_TYPE (primop0
);
3608 /* If args' natural types are both narrower than nominal type
3609 and both extend in the same manner, compare them
3610 in the type of the wider arg.
3611 Otherwise must actually extend both to the nominal
3612 common type lest different ways of extending
3614 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3616 else if (unsignedp0
== unsignedp1
&& real1
== real2
3617 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
3618 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
3620 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3621 type
= c_common_signed_or_unsigned_type (unsignedp0
3622 || TYPE_UNSIGNED (*restype_ptr
),
3624 /* Make sure shorter operand is extended the right way
3625 to match the longer operand. */
3627 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
3628 TREE_TYPE (primop0
)),
3631 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
3632 TREE_TYPE (primop1
)),
3637 /* Here we must do the comparison on the nominal type
3638 using the args exactly as we received them. */
3639 type
= *restype_ptr
;
3643 if (!real1
&& !real2
&& integer_zerop (primop1
)
3644 && TYPE_UNSIGNED (*restype_ptr
))
3650 /* All unsigned values are >= 0, so we warn. However,
3651 if OP0 is a constant that is >= 0, the signedness of
3652 the comparison isn't an issue, so suppress the
3654 if (warn_type_limits
&& !in_system_header
3655 && !(TREE_CODE (primop0
) == INTEGER_CST
3656 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3658 warning (OPT_Wtype_limits
,
3659 "comparison of unsigned expression >= 0 is always true");
3660 value
= truthvalue_true_node
;
3664 if (warn_type_limits
&& !in_system_header
3665 && !(TREE_CODE (primop0
) == INTEGER_CST
3666 && !TREE_OVERFLOW (convert (c_common_signed_type (type
),
3668 warning (OPT_Wtype_limits
,
3669 "comparison of unsigned expression < 0 is always false");
3670 value
= truthvalue_false_node
;
3679 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3680 if (TREE_SIDE_EFFECTS (primop0
))
3681 return build2 (COMPOUND_EXPR
, TREE_TYPE (value
),
3688 *op0_ptr
= convert (type
, primop0
);
3689 *op1_ptr
= convert (type
, primop1
);
3691 *restype_ptr
= truthvalue_type_node
;
3696 /* Return a tree for the sum or difference (RESULTCODE says which)
3697 of pointer PTROP and integer INTOP. */
3700 pointer_int_sum (location_t loc
, enum tree_code resultcode
,
3701 tree ptrop
, tree intop
)
3705 /* The result is a pointer of the same type that is being added. */
3706 tree result_type
= TREE_TYPE (ptrop
);
3708 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
3710 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3711 "pointer of type %<void *%> used in arithmetic");
3712 size_exp
= integer_one_node
;
3714 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
3716 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3717 "pointer to a function used in arithmetic");
3718 size_exp
= integer_one_node
;
3720 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
3722 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
3723 "pointer to member function used in arithmetic");
3724 size_exp
= integer_one_node
;
3727 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
3729 /* We are manipulating pointer values, so we don't need to warn
3730 about relying on undefined signed overflow. We disable the
3731 warning here because we use integer types so fold won't know that
3732 they are really pointers. */
3733 fold_defer_overflow_warnings ();
3735 /* If what we are about to multiply by the size of the elements
3736 contains a constant term, apply distributive law
3737 and multiply that constant term separately.
3738 This helps produce common subexpressions. */
3739 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
3740 && !TREE_CONSTANT (intop
)
3741 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
3742 && TREE_CONSTANT (size_exp
)
3743 /* If the constant comes from pointer subtraction,
3744 skip this optimization--it would cause an error. */
3745 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
3746 /* If the constant is unsigned, and smaller than the pointer size,
3747 then we must skip this optimization. This is because it could cause
3748 an overflow error if the constant is negative but INTOP is not. */
3749 && (!TYPE_UNSIGNED (TREE_TYPE (intop
))
3750 || (TYPE_PRECISION (TREE_TYPE (intop
))
3751 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
3753 enum tree_code subcode
= resultcode
;
3754 tree int_type
= TREE_TYPE (intop
);
3755 if (TREE_CODE (intop
) == MINUS_EXPR
)
3756 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
3757 /* Convert both subexpression types to the type of intop,
3758 because weird cases involving pointer arithmetic
3759 can result in a sum or difference with different type args. */
3760 ptrop
= build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop
, 1)),
3762 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
3763 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
3766 /* Convert the integer argument to a type the same size as sizetype
3767 so the multiply won't overflow spuriously. */
3768 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
3769 || TYPE_UNSIGNED (TREE_TYPE (intop
)) != TYPE_UNSIGNED (sizetype
))
3770 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
3771 TYPE_UNSIGNED (sizetype
)), intop
);
3773 /* Replace the integer argument with a suitable product by the object size.
3774 Do this multiplication as signed, then convert to the appropriate
3775 type for the pointer operation. */
3776 intop
= convert (sizetype
,
3777 build_binary_op (loc
,
3779 convert (TREE_TYPE (intop
), size_exp
), 1));
3781 /* Create the sum or difference. */
3782 if (resultcode
== MINUS_EXPR
)
3783 intop
= fold_build1_loc (loc
, NEGATE_EXPR
, sizetype
, intop
);
3785 ret
= fold_build2_loc (loc
, POINTER_PLUS_EXPR
, result_type
, ptrop
, intop
);
3787 fold_undefer_and_ignore_overflow_warnings ();
3792 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3793 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3794 around the SAVE_EXPR if needed so that c_fully_fold does not need
3795 to look inside SAVE_EXPRs. */
3798 c_save_expr (tree expr
)
3800 bool maybe_const
= true;
3801 if (c_dialect_cxx ())
3802 return save_expr (expr
);
3803 expr
= c_fully_fold (expr
, false, &maybe_const
);
3804 expr
= save_expr (expr
);
3807 expr
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL
, expr
);
3808 C_MAYBE_CONST_EXPR_NON_CONST (expr
) = 1;
3813 /* Return whether EXPR is a declaration whose address can never be
3817 decl_with_nonnull_addr_p (const_tree expr
)
3819 return (DECL_P (expr
)
3820 && (TREE_CODE (expr
) == PARM_DECL
3821 || TREE_CODE (expr
) == LABEL_DECL
3822 || !DECL_WEAK (expr
)));
3825 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3826 or for an `if' or `while' statement or ?..: exp. It should already
3827 have been validated to be of suitable type; otherwise, a bad
3828 diagnostic may result.
3830 The EXPR is located at LOCATION.
3832 This preparation consists of taking the ordinary
3833 representation of an expression expr and producing a valid tree
3834 boolean expression describing whether expr is nonzero. We could
3835 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3836 but we optimize comparisons, &&, ||, and !.
3838 The resulting type should always be `truthvalue_type_node'. */
3841 c_common_truthvalue_conversion (location_t location
, tree expr
)
3843 switch (TREE_CODE (expr
))
3845 case EQ_EXPR
: case NE_EXPR
: case UNEQ_EXPR
: case LTGT_EXPR
:
3846 case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3847 case UNLE_EXPR
: case UNGE_EXPR
: case UNLT_EXPR
: case UNGT_EXPR
:
3848 case ORDERED_EXPR
: case UNORDERED_EXPR
:
3849 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3851 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3852 TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
3855 case TRUTH_ANDIF_EXPR
:
3856 case TRUTH_ORIF_EXPR
:
3857 case TRUTH_AND_EXPR
:
3859 case TRUTH_XOR_EXPR
:
3860 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3862 expr
= build2 (TREE_CODE (expr
), truthvalue_type_node
,
3863 c_common_truthvalue_conversion (location
,
3864 TREE_OPERAND (expr
, 0)),
3865 c_common_truthvalue_conversion (location
,
3866 TREE_OPERAND (expr
, 1)));
3869 case TRUTH_NOT_EXPR
:
3870 if (TREE_TYPE (expr
) == truthvalue_type_node
)
3872 expr
= build1 (TREE_CODE (expr
), truthvalue_type_node
,
3873 c_common_truthvalue_conversion (location
,
3874 TREE_OPERAND (expr
, 0)));
3881 return integer_zerop (expr
) ? truthvalue_false_node
3882 : truthvalue_true_node
;
3885 return real_compare (NE_EXPR
, &TREE_REAL_CST (expr
), &dconst0
)
3886 ? truthvalue_true_node
3887 : truthvalue_false_node
;
3890 return fixed_compare (NE_EXPR
, &TREE_FIXED_CST (expr
),
3891 &FCONST0 (TYPE_MODE (TREE_TYPE (expr
))))
3892 ? truthvalue_true_node
3893 : truthvalue_false_node
;
3896 expr
= build_unary_op (location
, ADDR_EXPR
, expr
, 0);
3901 tree inner
= TREE_OPERAND (expr
, 0);
3902 if (decl_with_nonnull_addr_p (inner
))
3904 /* Common Ada/Pascal programmer's mistake. */
3905 warning_at (location
,
3907 "the address of %qD will always evaluate as %<true%>",
3909 return truthvalue_true_node
;
3912 /* If we still have a decl, it is possible for its address to
3913 be NULL, so we cannot optimize. */
3916 gcc_assert (DECL_WEAK (inner
));
3920 if (TREE_SIDE_EFFECTS (inner
))
3922 expr
= build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3923 inner
, truthvalue_true_node
);
3927 return truthvalue_true_node
;
3931 expr
= build_binary_op (EXPR_LOCATION (expr
),
3932 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3933 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3934 c_common_truthvalue_conversion (location
,
3935 TREE_OPERAND (expr
, 0)),
3936 c_common_truthvalue_conversion (location
,
3937 TREE_OPERAND (expr
, 1)),
3944 case EXCESS_PRECISION_EXPR
:
3945 /* These don't change whether an object is nonzero or zero. */
3946 return c_common_truthvalue_conversion (location
, TREE_OPERAND (expr
, 0));
3950 /* These don't change whether an object is zero or nonzero, but
3951 we can't ignore them if their second arg has side-effects. */
3952 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3954 expr
= build2 (COMPOUND_EXPR
, truthvalue_type_node
,
3955 TREE_OPERAND (expr
, 1),
3956 c_common_truthvalue_conversion
3957 (location
, TREE_OPERAND (expr
, 0)));
3961 return c_common_truthvalue_conversion (location
,
3962 TREE_OPERAND (expr
, 0));
3965 /* Distribute the conversion into the arms of a COND_EXPR. */
3966 if (c_dialect_cxx ())
3968 expr
= fold_build3_loc (location
, COND_EXPR
, truthvalue_type_node
,
3969 TREE_OPERAND (expr
, 0),
3970 c_common_truthvalue_conversion (location
,
3973 c_common_truthvalue_conversion (location
,
3980 /* Folding will happen later for C. */
3981 expr
= build3 (COND_EXPR
, truthvalue_type_node
,
3982 TREE_OPERAND (expr
, 0),
3983 c_common_truthvalue_conversion (location
,
3984 TREE_OPERAND (expr
, 1)),
3985 c_common_truthvalue_conversion (location
,
3986 TREE_OPERAND (expr
, 2)));
3991 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3992 since that affects how `default_conversion' will behave. */
3993 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
3994 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
3996 /* If this is widening the argument, we can ignore it. */
3997 if (TYPE_PRECISION (TREE_TYPE (expr
))
3998 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
3999 return c_common_truthvalue_conversion (location
,
4000 TREE_OPERAND (expr
, 0));
4004 if (!TREE_NO_WARNING (expr
)
4005 && warn_parentheses
)
4007 warning (OPT_Wparentheses
,
4008 "suggest parentheses around assignment used as truth value");
4009 TREE_NO_WARNING (expr
) = 1;
4017 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
4019 tree t
= c_save_expr (expr
);
4020 expr
= (build_binary_op
4021 (EXPR_LOCATION (expr
),
4022 (TREE_SIDE_EFFECTS (expr
)
4023 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
4024 c_common_truthvalue_conversion
4026 build_unary_op (location
, REALPART_EXPR
, t
, 0)),
4027 c_common_truthvalue_conversion
4029 build_unary_op (location
, IMAGPART_EXPR
, t
, 0)),
4034 if (TREE_CODE (TREE_TYPE (expr
)) == FIXED_POINT_TYPE
)
4036 tree fixed_zero_node
= build_fixed (TREE_TYPE (expr
),
4038 (TREE_TYPE (expr
))));
4039 return build_binary_op (location
, NE_EXPR
, expr
, fixed_zero_node
, 1);
4042 return build_binary_op (location
, NE_EXPR
, expr
, integer_zero_node
, 1);
4045 protected_set_expr_location (expr
, location
);
4049 static void def_builtin_1 (enum built_in_function fncode
,
4051 enum built_in_class fnclass
,
4052 tree fntype
, tree libtype
,
4053 bool both_p
, bool fallback_p
, bool nonansi_p
,
4054 tree fnattrs
, bool implicit_p
);
4057 /* Apply the TYPE_QUALS to the new DECL. */
4060 c_apply_type_quals_to_decl (int type_quals
, tree decl
)
4062 tree type
= TREE_TYPE (decl
);
4064 if (type
== error_mark_node
)
4067 if (((type_quals
& TYPE_QUAL_CONST
)
4068 || (type
&& TREE_CODE (type
) == REFERENCE_TYPE
))
4069 /* An object declared 'const' is only readonly after it is
4070 initialized. We don't have any way of expressing this currently,
4071 so we need to be conservative and unset TREE_READONLY for types
4072 with constructors. Otherwise aliasing code will ignore stores in
4073 an inline constructor. */
4074 && !(type
&& TYPE_NEEDS_CONSTRUCTING (type
)))
4075 TREE_READONLY (decl
) = 1;
4076 if (type_quals
& TYPE_QUAL_VOLATILE
)
4078 TREE_SIDE_EFFECTS (decl
) = 1;
4079 TREE_THIS_VOLATILE (decl
) = 1;
4081 if (type_quals
& TYPE_QUAL_RESTRICT
)
4083 while (type
&& TREE_CODE (type
) == ARRAY_TYPE
)
4084 /* Allow 'restrict' on arrays of pointers.
4085 FIXME currently we just ignore it. */
4086 type
= TREE_TYPE (type
);
4088 || !POINTER_TYPE_P (type
)
4089 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
)))
4090 error ("invalid use of %<restrict%>");
4094 /* Hash function for the problem of multiple type definitions in
4095 different files. This must hash all types that will compare
4096 equal via comptypes to the same value. In practice it hashes
4097 on some of the simple stuff and leaves the details to comptypes. */
4100 c_type_hash (const void *p
)
4104 const_tree
const t
= (const_tree
) p
;
4106 switch (TREE_CODE (t
))
4108 /* For pointers, hash on pointee type plus some swizzling. */
4110 return c_type_hash (TREE_TYPE (t
)) ^ 0x3003003;
4111 /* Hash on number of elements and total size. */
4114 t2
= TYPE_VALUES (t
);
4118 t2
= TYPE_FIELDS (t
);
4120 case QUAL_UNION_TYPE
:
4122 t2
= TYPE_FIELDS (t
);
4126 t2
= TYPE_FIELDS (t
);
4131 for (; t2
; t2
= TREE_CHAIN (t2
))
4133 /* We might have a VLA here. */
4134 if (TREE_CODE (TYPE_SIZE (t
)) != INTEGER_CST
)
4137 size
= TREE_INT_CST_LOW (TYPE_SIZE (t
));
4138 return ((size
<< 24) | (i
<< shift
));
4141 static GTY((param_is (union tree_node
))) htab_t type_hash_table
;
4143 /* Return the typed-based alias set for T, which may be an expression
4144 or a type. Return -1 if we don't do anything special. */
4147 c_common_get_alias_set (tree t
)
4152 /* Permit type-punning when accessing a union, provided the access
4153 is directly through the union. For example, this code does not
4154 permit taking the address of a union member and then storing
4155 through it. Even the type-punning allowed here is a GCC
4156 extension, albeit a common and useful one; the C standard says
4157 that such accesses have implementation-defined behavior. */
4159 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
4160 u
= TREE_OPERAND (u
, 0))
4161 if (TREE_CODE (u
) == COMPONENT_REF
4162 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
4165 /* That's all the expressions we handle specially. */
4169 /* The C standard guarantees that any object may be accessed via an
4170 lvalue that has character type. */
4171 if (t
== char_type_node
4172 || t
== signed_char_type_node
4173 || t
== unsigned_char_type_node
)
4176 /* The C standard specifically allows aliasing between signed and
4177 unsigned variants of the same type. We treat the signed
4178 variant as canonical. */
4179 if (TREE_CODE (t
) == INTEGER_TYPE
&& TYPE_UNSIGNED (t
))
4181 tree t1
= c_common_signed_type (t
);
4183 /* t1 == t can happen for boolean nodes which are always unsigned. */
4185 return get_alias_set (t1
);
4187 else if (POINTER_TYPE_P (t
))
4191 /* Unfortunately, there is no canonical form of a pointer type.
4192 In particular, if we have `typedef int I', then `int *', and
4193 `I *' are different types. So, we have to pick a canonical
4194 representative. We do this below.
4196 Technically, this approach is actually more conservative that
4197 it needs to be. In particular, `const int *' and `int *'
4198 should be in different alias sets, according to the C and C++
4199 standard, since their types are not the same, and so,
4200 technically, an `int **' and `const int **' cannot point at
4203 But, the standard is wrong. In particular, this code is
4208 const int* const* cipp = ipp;
4210 And, it doesn't make sense for that to be legal unless you
4211 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4212 the pointed-to types. This issue has been reported to the
4214 t1
= build_type_no_quals (t
);
4216 return get_alias_set (t1
);
4219 /* Handle the case of multiple type nodes referring to "the same" type,
4220 which occurs with IMA. These share an alias set. FIXME: Currently only
4221 C90 is handled. (In C99 type compatibility is not transitive, which
4222 complicates things mightily. The alias set splay trees can theoretically
4223 represent this, but insertion is tricky when you consider all the
4224 different orders things might arrive in.) */
4226 if (c_language
!= clk_c
|| flag_isoc99
)
4229 /* Save time if there's only one input file. */
4230 if (num_in_fnames
== 1)
4233 /* Pointers need special handling if they point to any type that
4234 needs special handling (below). */
4235 if (TREE_CODE (t
) == POINTER_TYPE
)
4238 /* Find bottom type under any nested POINTERs. */
4239 for (t2
= TREE_TYPE (t
);
4240 TREE_CODE (t2
) == POINTER_TYPE
;
4241 t2
= TREE_TYPE (t2
))
4243 if (TREE_CODE (t2
) != RECORD_TYPE
4244 && TREE_CODE (t2
) != ENUMERAL_TYPE
4245 && TREE_CODE (t2
) != QUAL_UNION_TYPE
4246 && TREE_CODE (t2
) != UNION_TYPE
)
4248 if (TYPE_SIZE (t2
) == 0)
4251 /* These are the only cases that need special handling. */
4252 if (TREE_CODE (t
) != RECORD_TYPE
4253 && TREE_CODE (t
) != ENUMERAL_TYPE
4254 && TREE_CODE (t
) != QUAL_UNION_TYPE
4255 && TREE_CODE (t
) != UNION_TYPE
4256 && TREE_CODE (t
) != POINTER_TYPE
)
4259 if (TYPE_SIZE (t
) == 0)
4262 /* Look up t in hash table. Only one of the compatible types within each
4263 alias set is recorded in the table. */
4264 if (!type_hash_table
)
4265 type_hash_table
= htab_create_ggc (1021, c_type_hash
,
4266 (htab_eq
) lang_hooks
.types_compatible_p
,
4268 slot
= htab_find_slot (type_hash_table
, t
, INSERT
);
4271 TYPE_ALIAS_SET (t
) = TYPE_ALIAS_SET ((tree
)*slot
);
4272 return TYPE_ALIAS_SET ((tree
)*slot
);
4275 /* Our caller will assign and record (in t) a new alias set; all we need
4276 to do is remember t in the hash table. */
4282 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4283 the second parameter indicates which OPERATOR is being applied.
4284 The COMPLAIN flag controls whether we should diagnose possibly
4285 ill-formed constructs or not. LOC is the location of the SIZEOF or
4289 c_sizeof_or_alignof_type (location_t loc
,
4290 tree type
, bool is_sizeof
, int complain
)
4292 const char *op_name
;
4294 enum tree_code type_code
= TREE_CODE (type
);
4296 op_name
= is_sizeof
? "sizeof" : "__alignof__";
4298 if (type_code
== FUNCTION_TYPE
)
4302 if (complain
&& (pedantic
|| warn_pointer_arith
))
4303 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4304 "invalid application of %<sizeof%> to a function type");
4306 return error_mark_node
;
4307 value
= size_one_node
;
4310 value
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
4312 else if (type_code
== VOID_TYPE
|| type_code
== ERROR_MARK
)
4314 if (type_code
== VOID_TYPE
4315 && complain
&& (pedantic
|| warn_pointer_arith
))
4316 pedwarn (loc
, pedantic
? OPT_pedantic
: OPT_Wpointer_arith
,
4317 "invalid application of %qs to a void type", op_name
);
4319 return error_mark_node
;
4320 value
= size_one_node
;
4322 else if (!COMPLETE_TYPE_P (type
))
4325 error_at (loc
, "invalid application of %qs to incomplete type %qT ",
4327 value
= size_zero_node
;
4332 /* Convert in case a char is more than one unit. */
4333 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
4334 size_int (TYPE_PRECISION (char_type_node
)
4337 value
= size_int (TYPE_ALIGN_UNIT (type
));
4340 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4341 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4342 never happen. However, this node should really have type
4343 `size_t', which is just a typedef for an ordinary integer type. */
4344 value
= fold_convert_loc (loc
, size_type_node
, value
);
4345 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value
)));
4350 /* Implement the __alignof keyword: Return the minimum required
4351 alignment of EXPR, measured in bytes. For VAR_DECLs,
4352 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4353 from an "aligned" __attribute__ specification). LOC is the
4354 location of the ALIGNOF operator. */
4357 c_alignof_expr (location_t loc
, tree expr
)
4361 if (VAR_OR_FUNCTION_DECL_P (expr
))
4362 t
= size_int (DECL_ALIGN_UNIT (expr
));
4364 else if (TREE_CODE (expr
) == COMPONENT_REF
4365 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
4367 error_at (loc
, "%<__alignof%> applied to a bit-field");
4370 else if (TREE_CODE (expr
) == COMPONENT_REF
4371 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
4372 t
= size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr
, 1)));
4374 else if (TREE_CODE (expr
) == INDIRECT_REF
)
4376 tree t
= TREE_OPERAND (expr
, 0);
4378 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4380 while (CONVERT_EXPR_P (t
)
4381 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
4385 t
= TREE_OPERAND (t
, 0);
4386 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
4387 if (thisalign
> bestalign
)
4388 best
= t
, bestalign
= thisalign
;
4390 return c_alignof (loc
, TREE_TYPE (TREE_TYPE (best
)));
4393 return c_alignof (loc
, TREE_TYPE (expr
));
4395 return fold_convert_loc (loc
, size_type_node
, t
);
4398 /* Handle C and C++ default attributes. */
4400 enum built_in_attribute
4402 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4403 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4404 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4405 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4406 #include "builtin-attrs.def"
4407 #undef DEF_ATTR_NULL_TREE
4409 #undef DEF_ATTR_IDENT
4410 #undef DEF_ATTR_TREE_LIST
4414 static GTY(()) tree built_in_attributes
[(int) ATTR_LAST
];
4416 static void c_init_attributes (void);
4420 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4421 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4422 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4423 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4424 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4425 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4426 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4427 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4428 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4429 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4430 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4431 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4432 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4433 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4434 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4436 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4437 #include "builtin-types.def"
4438 #undef DEF_PRIMITIVE_TYPE
4439 #undef DEF_FUNCTION_TYPE_0
4440 #undef DEF_FUNCTION_TYPE_1
4441 #undef DEF_FUNCTION_TYPE_2
4442 #undef DEF_FUNCTION_TYPE_3
4443 #undef DEF_FUNCTION_TYPE_4
4444 #undef DEF_FUNCTION_TYPE_5
4445 #undef DEF_FUNCTION_TYPE_6
4446 #undef DEF_FUNCTION_TYPE_7
4447 #undef DEF_FUNCTION_TYPE_VAR_0
4448 #undef DEF_FUNCTION_TYPE_VAR_1
4449 #undef DEF_FUNCTION_TYPE_VAR_2
4450 #undef DEF_FUNCTION_TYPE_VAR_3
4451 #undef DEF_FUNCTION_TYPE_VAR_4
4452 #undef DEF_FUNCTION_TYPE_VAR_5
4453 #undef DEF_POINTER_TYPE
4457 typedef enum c_builtin_type builtin_type
;
4459 /* A temporary array for c_common_nodes_and_builtins. Used in
4460 communication with def_fn_type. */
4461 static tree builtin_types
[(int) BT_LAST
+ 1];
4463 /* A helper function for c_common_nodes_and_builtins. Build function type
4464 for DEF with return type RET and N arguments. If VAR is true, then the
4465 function should be variadic after those N arguments.
4467 Takes special care not to ICE if any of the types involved are
4468 error_mark_node, which indicates that said type is not in fact available
4469 (see builtin_type_for_size). In which case the function type as a whole
4470 should be error_mark_node. */
4473 def_fn_type (builtin_type def
, builtin_type ret
, bool var
, int n
, ...)
4475 tree args
= NULL
, t
;
4480 for (i
= 0; i
< n
; ++i
)
4482 builtin_type a
= (builtin_type
) va_arg (list
, int);
4483 t
= builtin_types
[a
];
4484 if (t
== error_mark_node
)
4486 args
= tree_cons (NULL_TREE
, t
, args
);
4490 args
= nreverse (args
);
4492 args
= chainon (args
, void_list_node
);
4494 t
= builtin_types
[ret
];
4495 if (t
== error_mark_node
)
4497 t
= build_function_type (t
, args
);
4500 builtin_types
[def
] = t
;
4503 /* Build builtin functions common to both C and C++ language
4507 c_define_builtins (tree va_list_ref_type_node
, tree va_list_arg_type_node
)
4509 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4510 builtin_types[ENUM] = VALUE;
4511 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4512 def_fn_type (ENUM, RETURN, 0, 0);
4513 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4514 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4515 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4516 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4517 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4518 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4519 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4520 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4521 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4522 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4523 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4525 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4526 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4528 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4529 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4530 def_fn_type (ENUM, RETURN, 1, 0);
4531 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4532 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4533 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4534 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4535 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4536 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4537 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4538 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4539 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4540 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4541 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4542 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4544 #include "builtin-types.def"
4546 #undef DEF_PRIMITIVE_TYPE
4547 #undef DEF_FUNCTION_TYPE_1
4548 #undef DEF_FUNCTION_TYPE_2
4549 #undef DEF_FUNCTION_TYPE_3
4550 #undef DEF_FUNCTION_TYPE_4
4551 #undef DEF_FUNCTION_TYPE_5
4552 #undef DEF_FUNCTION_TYPE_6
4553 #undef DEF_FUNCTION_TYPE_VAR_0
4554 #undef DEF_FUNCTION_TYPE_VAR_1
4555 #undef DEF_FUNCTION_TYPE_VAR_2
4556 #undef DEF_FUNCTION_TYPE_VAR_3
4557 #undef DEF_FUNCTION_TYPE_VAR_4
4558 #undef DEF_FUNCTION_TYPE_VAR_5
4559 #undef DEF_POINTER_TYPE
4560 builtin_types
[(int) BT_LAST
] = NULL_TREE
;
4562 c_init_attributes ();
4564 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4565 NONANSI_P, ATTRS, IMPLICIT, COND) \
4567 def_builtin_1 (ENUM, NAME, CLASS, \
4568 builtin_types[(int) TYPE], \
4569 builtin_types[(int) LIBTYPE], \
4570 BOTH_P, FALLBACK_P, NONANSI_P, \
4571 built_in_attributes[(int) ATTRS], IMPLICIT);
4572 #include "builtins.def"
4575 targetm
.init_builtins ();
4577 build_common_builtin_nodes ();
4583 /* Like get_identifier, but avoid warnings about null arguments when
4584 the argument may be NULL for targets where GCC lacks stdint.h type
4588 c_get_ident (const char *id
)
4590 return get_identifier (id
);
4593 /* Build tree nodes and builtin functions common to both C and C++ language
4597 c_common_nodes_and_builtins (void)
4599 int char16_type_size
;
4600 int char32_type_size
;
4601 int wchar_type_size
;
4602 tree array_domain_type
;
4603 tree va_list_ref_type_node
;
4604 tree va_list_arg_type_node
;
4606 /* Define `int' and `char' first so that dbx will output them first. */
4607 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
4608 record_builtin_type (RID_CHAR
, "char", char_type_node
);
4610 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4611 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4612 but not C. Are the conditionals here needed? */
4613 if (c_dialect_cxx ())
4614 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
4615 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
4616 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
4617 record_builtin_type (RID_MAX
, "long unsigned int",
4618 long_unsigned_type_node
);
4619 if (c_dialect_cxx ())
4620 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
4621 record_builtin_type (RID_MAX
, "long long int",
4622 long_long_integer_type_node
);
4623 record_builtin_type (RID_MAX
, "long long unsigned int",
4624 long_long_unsigned_type_node
);
4625 if (c_dialect_cxx ())
4626 record_builtin_type (RID_MAX
, "long long unsigned",
4627 long_long_unsigned_type_node
);
4628 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
4629 record_builtin_type (RID_MAX
, "short unsigned int",
4630 short_unsigned_type_node
);
4631 if (c_dialect_cxx ())
4632 record_builtin_type (RID_MAX
, "unsigned short",
4633 short_unsigned_type_node
);
4635 /* Define both `signed char' and `unsigned char'. */
4636 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
4637 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
4639 /* These are types that c_common_type_for_size and
4640 c_common_type_for_mode use. */
4641 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4642 TYPE_DECL
, NULL_TREE
,
4644 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4645 TYPE_DECL
, NULL_TREE
,
4647 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4648 TYPE_DECL
, NULL_TREE
,
4650 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4651 TYPE_DECL
, NULL_TREE
,
4653 #if HOST_BITS_PER_WIDE_INT >= 64
4654 if (targetm
.scalar_mode_supported_p (TImode
))
4655 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4657 get_identifier ("__int128_t"),
4660 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4661 TYPE_DECL
, NULL_TREE
,
4662 unsigned_intQI_type_node
));
4663 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4664 TYPE_DECL
, NULL_TREE
,
4665 unsigned_intHI_type_node
));
4666 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4667 TYPE_DECL
, NULL_TREE
,
4668 unsigned_intSI_type_node
));
4669 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4670 TYPE_DECL
, NULL_TREE
,
4671 unsigned_intDI_type_node
));
4672 #if HOST_BITS_PER_WIDE_INT >= 64
4673 if (targetm
.scalar_mode_supported_p (TImode
))
4674 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4676 get_identifier ("__uint128_t"),
4677 unsigned_intTI_type_node
));
4680 /* Create the widest literal types. */
4681 widest_integer_literal_type_node
4682 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
4683 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4684 TYPE_DECL
, NULL_TREE
,
4685 widest_integer_literal_type_node
));
4687 widest_unsigned_literal_type_node
4688 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
4689 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4690 TYPE_DECL
, NULL_TREE
,
4691 widest_unsigned_literal_type_node
));
4693 /* `unsigned long' is the standard type for sizeof.
4694 Note that stddef.h uses `unsigned long',
4695 and this must agree, even if long and int are the same size. */
4697 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
4698 signed_size_type_node
= c_common_signed_type (size_type_node
);
4699 set_sizetype (size_type_node
);
4702 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE
)));
4704 build_common_tree_nodes_2 (flag_short_double
);
4706 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
4707 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
4708 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
4710 /* Only supported decimal floating point extension if the target
4711 actually supports underlying modes. */
4712 if (targetm
.scalar_mode_supported_p (SDmode
)
4713 && targetm
.scalar_mode_supported_p (DDmode
)
4714 && targetm
.scalar_mode_supported_p (TDmode
))
4716 record_builtin_type (RID_DFLOAT32
, NULL
, dfloat32_type_node
);
4717 record_builtin_type (RID_DFLOAT64
, NULL
, dfloat64_type_node
);
4718 record_builtin_type (RID_DFLOAT128
, NULL
, dfloat128_type_node
);
4721 if (targetm
.fixed_point_supported_p ())
4723 record_builtin_type (RID_MAX
, "short _Fract", short_fract_type_node
);
4724 record_builtin_type (RID_FRACT
, NULL
, fract_type_node
);
4725 record_builtin_type (RID_MAX
, "long _Fract", long_fract_type_node
);
4726 record_builtin_type (RID_MAX
, "long long _Fract",
4727 long_long_fract_type_node
);
4728 record_builtin_type (RID_MAX
, "unsigned short _Fract",
4729 unsigned_short_fract_type_node
);
4730 record_builtin_type (RID_MAX
, "unsigned _Fract",
4731 unsigned_fract_type_node
);
4732 record_builtin_type (RID_MAX
, "unsigned long _Fract",
4733 unsigned_long_fract_type_node
);
4734 record_builtin_type (RID_MAX
, "unsigned long long _Fract",
4735 unsigned_long_long_fract_type_node
);
4736 record_builtin_type (RID_MAX
, "_Sat short _Fract",
4737 sat_short_fract_type_node
);
4738 record_builtin_type (RID_MAX
, "_Sat _Fract", sat_fract_type_node
);
4739 record_builtin_type (RID_MAX
, "_Sat long _Fract",
4740 sat_long_fract_type_node
);
4741 record_builtin_type (RID_MAX
, "_Sat long long _Fract",
4742 sat_long_long_fract_type_node
);
4743 record_builtin_type (RID_MAX
, "_Sat unsigned short _Fract",
4744 sat_unsigned_short_fract_type_node
);
4745 record_builtin_type (RID_MAX
, "_Sat unsigned _Fract",
4746 sat_unsigned_fract_type_node
);
4747 record_builtin_type (RID_MAX
, "_Sat unsigned long _Fract",
4748 sat_unsigned_long_fract_type_node
);
4749 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Fract",
4750 sat_unsigned_long_long_fract_type_node
);
4751 record_builtin_type (RID_MAX
, "short _Accum", short_accum_type_node
);
4752 record_builtin_type (RID_ACCUM
, NULL
, accum_type_node
);
4753 record_builtin_type (RID_MAX
, "long _Accum", long_accum_type_node
);
4754 record_builtin_type (RID_MAX
, "long long _Accum",
4755 long_long_accum_type_node
);
4756 record_builtin_type (RID_MAX
, "unsigned short _Accum",
4757 unsigned_short_accum_type_node
);
4758 record_builtin_type (RID_MAX
, "unsigned _Accum",
4759 unsigned_accum_type_node
);
4760 record_builtin_type (RID_MAX
, "unsigned long _Accum",
4761 unsigned_long_accum_type_node
);
4762 record_builtin_type (RID_MAX
, "unsigned long long _Accum",
4763 unsigned_long_long_accum_type_node
);
4764 record_builtin_type (RID_MAX
, "_Sat short _Accum",
4765 sat_short_accum_type_node
);
4766 record_builtin_type (RID_MAX
, "_Sat _Accum", sat_accum_type_node
);
4767 record_builtin_type (RID_MAX
, "_Sat long _Accum",
4768 sat_long_accum_type_node
);
4769 record_builtin_type (RID_MAX
, "_Sat long long _Accum",
4770 sat_long_long_accum_type_node
);
4771 record_builtin_type (RID_MAX
, "_Sat unsigned short _Accum",
4772 sat_unsigned_short_accum_type_node
);
4773 record_builtin_type (RID_MAX
, "_Sat unsigned _Accum",
4774 sat_unsigned_accum_type_node
);
4775 record_builtin_type (RID_MAX
, "_Sat unsigned long _Accum",
4776 sat_unsigned_long_accum_type_node
);
4777 record_builtin_type (RID_MAX
, "_Sat unsigned long long _Accum",
4778 sat_unsigned_long_long_accum_type_node
);
4782 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4784 get_identifier ("complex int"),
4785 complex_integer_type_node
));
4786 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4788 get_identifier ("complex float"),
4789 complex_float_type_node
));
4790 lang_hooks
.decls
.pushdecl (build_decl (UNKNOWN_LOCATION
,
4792 get_identifier ("complex double"),
4793 complex_double_type_node
));
4794 lang_hooks
.decls
.pushdecl
4795 (build_decl (UNKNOWN_LOCATION
,
4796 TYPE_DECL
, get_identifier ("complex long double"),
4797 complex_long_double_type_node
));
4799 if (c_dialect_cxx ())
4800 /* For C++, make fileptr_type_node a distinct void * type until
4801 FILE type is defined. */
4802 fileptr_type_node
= build_variant_type_copy (ptr_type_node
);
4804 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
4806 /* Set the TYPE_NAME for any variants that were built before
4807 record_builtin_type gave names to the built-in types. */
4809 tree void_name
= TYPE_NAME (void_type_node
);
4810 TYPE_NAME (void_type_node
) = NULL_TREE
;
4811 TYPE_NAME (build_qualified_type (void_type_node
, TYPE_QUAL_CONST
))
4813 TYPE_NAME (void_type_node
) = void_name
;
4816 /* This node must not be shared. */
4817 void_zero_node
= make_node (INTEGER_CST
);
4818 TREE_TYPE (void_zero_node
) = void_type_node
;
4820 void_list_node
= build_void_list_node ();
4822 /* Make a type to be the domain of a few array types
4823 whose domains don't really matter.
4824 200 is small enough that it always fits in size_t
4825 and large enough that it can hold most function names for the
4826 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4827 array_domain_type
= build_index_type (size_int (200));
4829 /* Make a type for arrays of characters.
4830 With luck nothing will ever really depend on the length of this
4832 char_array_type_node
4833 = build_array_type (char_type_node
, array_domain_type
);
4835 /* Likewise for arrays of ints. */
4837 = build_array_type (integer_type_node
, array_domain_type
);
4839 string_type_node
= build_pointer_type (char_type_node
);
4840 const_string_type_node
4841 = build_pointer_type (build_qualified_type
4842 (char_type_node
, TYPE_QUAL_CONST
));
4844 /* This is special for C++ so functions can be overloaded. */
4845 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
4846 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
4847 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
4848 underlying_wchar_type_node
= wchar_type_node
;
4849 if (c_dialect_cxx ())
4851 if (TYPE_UNSIGNED (wchar_type_node
))
4852 wchar_type_node
= make_unsigned_type (wchar_type_size
);
4854 wchar_type_node
= make_signed_type (wchar_type_size
);
4855 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
4858 /* This is for wide string constants. */
4859 wchar_array_type_node
4860 = build_array_type (wchar_type_node
, array_domain_type
);
4862 /* Define 'char16_t'. */
4863 char16_type_node
= get_identifier (CHAR16_TYPE
);
4864 char16_type_node
= TREE_TYPE (identifier_global_value (char16_type_node
));
4865 char16_type_size
= TYPE_PRECISION (char16_type_node
);
4866 if (c_dialect_cxx ())
4868 char16_type_node
= make_unsigned_type (char16_type_size
);
4870 if (cxx_dialect
== cxx0x
)
4871 record_builtin_type (RID_CHAR16
, "char16_t", char16_type_node
);
4874 /* This is for UTF-16 string constants. */
4875 char16_array_type_node
4876 = build_array_type (char16_type_node
, array_domain_type
);
4878 /* Define 'char32_t'. */
4879 char32_type_node
= get_identifier (CHAR32_TYPE
);
4880 char32_type_node
= TREE_TYPE (identifier_global_value (char32_type_node
));
4881 char32_type_size
= TYPE_PRECISION (char32_type_node
);
4882 if (c_dialect_cxx ())
4884 char32_type_node
= make_unsigned_type (char32_type_size
);
4886 if (cxx_dialect
== cxx0x
)
4887 record_builtin_type (RID_CHAR32
, "char32_t", char32_type_node
);
4890 /* This is for UTF-32 string constants. */
4891 char32_array_type_node
4892 = build_array_type (char32_type_node
, array_domain_type
);
4895 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
4898 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
4900 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
4902 if (SIG_ATOMIC_TYPE
)
4903 sig_atomic_type_node
=
4904 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE
)));
4907 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE
)));
4910 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE
)));
4913 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE
)));
4916 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE
)));
4919 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE
)));
4922 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE
)));
4924 c_uint32_type_node
=
4925 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE
)));
4927 c_uint64_type_node
=
4928 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE
)));
4929 if (INT_LEAST8_TYPE
)
4930 int_least8_type_node
=
4931 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE
)));
4932 if (INT_LEAST16_TYPE
)
4933 int_least16_type_node
=
4934 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE
)));
4935 if (INT_LEAST32_TYPE
)
4936 int_least32_type_node
=
4937 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE
)));
4938 if (INT_LEAST64_TYPE
)
4939 int_least64_type_node
=
4940 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE
)));
4941 if (UINT_LEAST8_TYPE
)
4942 uint_least8_type_node
=
4943 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE
)));
4944 if (UINT_LEAST16_TYPE
)
4945 uint_least16_type_node
=
4946 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE
)));
4947 if (UINT_LEAST32_TYPE
)
4948 uint_least32_type_node
=
4949 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE
)));
4950 if (UINT_LEAST64_TYPE
)
4951 uint_least64_type_node
=
4952 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE
)));
4954 int_fast8_type_node
=
4955 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE
)));
4956 if (INT_FAST16_TYPE
)
4957 int_fast16_type_node
=
4958 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE
)));
4959 if (INT_FAST32_TYPE
)
4960 int_fast32_type_node
=
4961 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE
)));
4962 if (INT_FAST64_TYPE
)
4963 int_fast64_type_node
=
4964 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE
)));
4965 if (UINT_FAST8_TYPE
)
4966 uint_fast8_type_node
=
4967 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE
)));
4968 if (UINT_FAST16_TYPE
)
4969 uint_fast16_type_node
=
4970 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE
)));
4971 if (UINT_FAST32_TYPE
)
4972 uint_fast32_type_node
=
4973 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE
)));
4974 if (UINT_FAST64_TYPE
)
4975 uint_fast64_type_node
=
4976 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE
)));
4979 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE
)));
4982 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE
)));
4984 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
4986 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
4987 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
4989 lang_hooks
.decls
.pushdecl
4990 (build_decl (UNKNOWN_LOCATION
,
4991 TYPE_DECL
, get_identifier ("__builtin_va_list"),
4992 va_list_type_node
));
4993 #ifdef TARGET_ENUM_VA_LIST
4998 for (l
= 0; TARGET_ENUM_VA_LIST (l
, &pname
, &ptype
); ++l
)
5000 lang_hooks
.decls
.pushdecl
5001 (build_decl (UNKNOWN_LOCATION
,
5002 TYPE_DECL
, get_identifier (pname
),
5009 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
5011 va_list_arg_type_node
= va_list_ref_type_node
=
5012 build_pointer_type (TREE_TYPE (va_list_type_node
));
5016 va_list_arg_type_node
= va_list_type_node
;
5017 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
5020 if (!flag_preprocess_only
)
5021 c_define_builtins (va_list_ref_type_node
, va_list_arg_type_node
);
5023 main_identifier_node
= get_identifier ("main");
5025 /* Create the built-in __null node. It is important that this is
5027 null_node
= make_node (INTEGER_CST
);
5028 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
5030 /* Since builtin_types isn't gc'ed, don't export these nodes. */
5031 memset (builtin_types
, 0, sizeof (builtin_types
));
5034 /* Look up the function in built_in_decls that corresponds to DECL
5035 and set ASMSPEC as its user assembler name. DECL must be a
5036 function decl that declares a builtin. */
5039 set_builtin_user_assembler_name (tree decl
, const char *asmspec
)
5042 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
5043 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
5046 builtin
= built_in_decls
[DECL_FUNCTION_CODE (decl
)];
5047 set_user_assembler_name (builtin
, asmspec
);
5048 switch (DECL_FUNCTION_CODE (decl
))
5050 case BUILT_IN_MEMCPY
:
5051 init_block_move_fn (asmspec
);
5052 memcpy_libfunc
= set_user_assembler_libfunc ("memcpy", asmspec
);
5054 case BUILT_IN_MEMSET
:
5055 init_block_clear_fn (asmspec
);
5056 memset_libfunc
= set_user_assembler_libfunc ("memset", asmspec
);
5058 case BUILT_IN_MEMMOVE
:
5059 memmove_libfunc
= set_user_assembler_libfunc ("memmove", asmspec
);
5061 case BUILT_IN_MEMCMP
:
5062 memcmp_libfunc
= set_user_assembler_libfunc ("memcmp", asmspec
);
5064 case BUILT_IN_ABORT
:
5065 abort_libfunc
= set_user_assembler_libfunc ("abort", asmspec
);
5072 /* The number of named compound-literals generated thus far. */
5073 static GTY(()) int compound_literal_number
;
5075 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
5078 set_compound_literal_name (tree decl
)
5081 ASM_FORMAT_PRIVATE_NAME (name
, "__compound_literal",
5082 compound_literal_number
);
5083 compound_literal_number
++;
5084 DECL_NAME (decl
) = get_identifier (name
);
5088 build_va_arg (location_t loc
, tree expr
, tree type
)
5090 expr
= build1 (VA_ARG_EXPR
, type
, expr
);
5091 SET_EXPR_LOCATION (expr
, loc
);
5096 /* Linked list of disabled built-in functions. */
5098 typedef struct disabled_builtin
5101 struct disabled_builtin
*next
;
5103 static disabled_builtin
*disabled_builtins
= NULL
;
5105 static bool builtin_function_disabled_p (const char *);
5107 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5108 begins with "__builtin_", give an error. */
5111 disable_builtin_function (const char *name
)
5113 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
5114 error ("cannot disable built-in function %qs", name
);
5117 disabled_builtin
*new_disabled_builtin
= XNEW (disabled_builtin
);
5118 new_disabled_builtin
->name
= name
;
5119 new_disabled_builtin
->next
= disabled_builtins
;
5120 disabled_builtins
= new_disabled_builtin
;
5125 /* Return true if the built-in function NAME has been disabled, false
5129 builtin_function_disabled_p (const char *name
)
5131 disabled_builtin
*p
;
5132 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
5134 if (strcmp (name
, p
->name
) == 0)
5141 /* Worker for DEF_BUILTIN.
5142 Possibly define a builtin function with one or two names.
5143 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5144 nonansi_p and flag_no_nonansi_builtin. */
5147 def_builtin_1 (enum built_in_function fncode
,
5149 enum built_in_class fnclass
,
5150 tree fntype
, tree libtype
,
5151 bool both_p
, bool fallback_p
, bool nonansi_p
,
5152 tree fnattrs
, bool implicit_p
)
5155 const char *libname
;
5157 if (fntype
== error_mark_node
)
5160 gcc_assert ((!both_p
&& !fallback_p
)
5161 || !strncmp (name
, "__builtin_",
5162 strlen ("__builtin_")));
5164 libname
= name
+ strlen ("__builtin_");
5165 decl
= add_builtin_function (name
, fntype
, fncode
, fnclass
,
5166 (fallback_p
? libname
: NULL
),
5169 && !flag_no_builtin
&& !builtin_function_disabled_p (libname
)
5170 && !(nonansi_p
&& flag_no_nonansi_builtin
))
5171 add_builtin_function (libname
, libtype
, fncode
, fnclass
,
5174 built_in_decls
[(int) fncode
] = decl
;
5176 implicit_built_in_decls
[(int) fncode
] = decl
;
5179 /* Nonzero if the type T promotes to int. This is (nearly) the
5180 integral promotions defined in ISO C99 6.3.1.1/2. */
5183 c_promoting_integer_type_p (const_tree t
)
5185 switch (TREE_CODE (t
))
5188 return (TYPE_MAIN_VARIANT (t
) == char_type_node
5189 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
5190 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
5191 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
5192 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
5193 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
5196 /* ??? Technically all enumerations not larger than an int
5197 promote to an int. But this is used along code paths
5198 that only want to notice a size change. */
5199 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
5209 /* Return 1 if PARMS specifies a fixed number of parameters
5210 and none of their types is affected by default promotions. */
5213 self_promoting_args_p (const_tree parms
)
5216 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
5218 tree type
= TREE_VALUE (t
);
5220 if (type
== error_mark_node
)
5223 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
5229 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
5232 if (c_promoting_integer_type_p (type
))
5238 /* Recursively remove any '*' or '&' operator from TYPE. */
5240 strip_pointer_operator (tree t
)
5242 while (POINTER_TYPE_P (t
))
5247 /* Recursively remove pointer or array type from TYPE. */
5249 strip_pointer_or_array_types (tree t
)
5251 while (TREE_CODE (t
) == ARRAY_TYPE
|| POINTER_TYPE_P (t
))
5256 /* Used to compare case labels. K1 and K2 are actually tree nodes
5257 representing case labels, or NULL_TREE for a `default' label.
5258 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5259 K2, and 0 if K1 and K2 are equal. */
5262 case_compare (splay_tree_key k1
, splay_tree_key k2
)
5264 /* Consider a NULL key (such as arises with a `default' label) to be
5265 smaller than anything else. */
5271 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
5274 /* Process a case label, located at LOC, for the range LOW_VALUE
5275 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5276 then this case label is actually a `default' label. If only
5277 HIGH_VALUE is NULL_TREE, then case label was declared using the
5278 usual C/C++ syntax, rather than the GNU case range extension.
5279 CASES is a tree containing all the case ranges processed so far;
5280 COND is the condition for the switch-statement itself. Returns the
5281 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5285 c_add_case_label (location_t loc
, splay_tree cases
, tree cond
, tree orig_type
,
5286 tree low_value
, tree high_value
)
5291 splay_tree_node node
;
5293 /* Create the LABEL_DECL itself. */
5294 label
= create_artificial_label (loc
);
5296 /* If there was an error processing the switch condition, bail now
5297 before we get more confused. */
5298 if (!cond
|| cond
== error_mark_node
)
5301 if ((low_value
&& TREE_TYPE (low_value
)
5302 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
5303 || (high_value
&& TREE_TYPE (high_value
)
5304 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
5306 error_at (loc
, "pointers are not permitted as case values");
5310 /* Case ranges are a GNU extension. */
5312 pedwarn (loc
, OPT_pedantic
,
5313 "range expressions in switch statements are non-standard");
5315 type
= TREE_TYPE (cond
);
5318 low_value
= check_case_value (low_value
);
5319 low_value
= convert_and_check (type
, low_value
);
5320 if (low_value
== error_mark_node
)
5325 high_value
= check_case_value (high_value
);
5326 high_value
= convert_and_check (type
, high_value
);
5327 if (high_value
== error_mark_node
)
5331 if (low_value
&& high_value
)
5333 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5334 really a case range, even though it was written that way.
5335 Remove the HIGH_VALUE to simplify later processing. */
5336 if (tree_int_cst_equal (low_value
, high_value
))
5337 high_value
= NULL_TREE
;
5338 else if (!tree_int_cst_lt (low_value
, high_value
))
5339 warning_at (loc
, 0, "empty range specified");
5342 /* See if the case is in range of the type of the original testing
5343 expression. If both low_value and high_value are out of range,
5344 don't insert the case label and return NULL_TREE. */
5346 && !check_case_bounds (type
, orig_type
,
5347 &low_value
, high_value
? &high_value
: NULL
))
5350 /* Look up the LOW_VALUE in the table of case labels we already
5352 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
5353 /* If there was not an exact match, check for overlapping ranges.
5354 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5355 that's a `default' label and the only overlap is an exact match. */
5356 if (!node
&& (low_value
|| high_value
))
5358 splay_tree_node low_bound
;
5359 splay_tree_node high_bound
;
5361 /* Even though there wasn't an exact match, there might be an
5362 overlap between this case range and another case range.
5363 Since we've (inductively) not allowed any overlapping case
5364 ranges, we simply need to find the greatest low case label
5365 that is smaller that LOW_VALUE, and the smallest low case
5366 label that is greater than LOW_VALUE. If there is an overlap
5367 it will occur in one of these two ranges. */
5368 low_bound
= splay_tree_predecessor (cases
,
5369 (splay_tree_key
) low_value
);
5370 high_bound
= splay_tree_successor (cases
,
5371 (splay_tree_key
) low_value
);
5373 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5374 the LOW_VALUE, so there is no need to check unless the
5375 LOW_BOUND is in fact itself a case range. */
5377 && CASE_HIGH ((tree
) low_bound
->value
)
5378 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
5381 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5382 range is bigger than the low end of the current range, so we
5383 are only interested if the current range is a real range, and
5384 not an ordinary case label. */
5387 && (tree_int_cst_compare ((tree
) high_bound
->key
,
5392 /* If there was an overlap, issue an error. */
5395 tree duplicate
= CASE_LABEL ((tree
) node
->value
);
5399 error_at (loc
, "duplicate (or overlapping) case value");
5400 error_at (DECL_SOURCE_LOCATION (duplicate
),
5401 "this is the first entry overlapping that value");
5405 error_at (loc
, "duplicate case value") ;
5406 error_at (DECL_SOURCE_LOCATION (duplicate
), "previously used here");
5410 error_at (loc
, "multiple default labels in one switch");
5411 error_at (DECL_SOURCE_LOCATION (duplicate
),
5412 "this is the first default label");
5417 /* Add a CASE_LABEL to the statement-tree. */
5418 case_label
= add_stmt (build_case_label (loc
, low_value
, high_value
, label
));
5419 /* Register this case label in the splay tree. */
5420 splay_tree_insert (cases
,
5421 (splay_tree_key
) low_value
,
5422 (splay_tree_value
) case_label
);
5427 /* Add a label so that the back-end doesn't think that the beginning of
5428 the switch is unreachable. Note that we do not add a case label, as
5429 that just leads to duplicates and thence to failure later on. */
5432 tree t
= create_artificial_label (loc
);
5433 add_stmt (build_stmt (loc
, LABEL_EXPR
, t
));
5435 return error_mark_node
;
5438 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5439 Used to verify that case values match up with enumerator values. */
5442 match_case_to_enum_1 (tree key
, tree type
, tree label
)
5444 char buf
[2 + 2*HOST_BITS_PER_WIDE_INT
/4 + 1];
5446 /* ??? Not working too hard to print the double-word value.
5447 Should perhaps be done with %lwd in the diagnostic routines? */
5448 if (TREE_INT_CST_HIGH (key
) == 0)
5449 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_UNSIGNED
,
5450 TREE_INT_CST_LOW (key
));
5451 else if (!TYPE_UNSIGNED (type
)
5452 && TREE_INT_CST_HIGH (key
) == -1
5453 && TREE_INT_CST_LOW (key
) != 0)
5454 snprintf (buf
, sizeof (buf
), "-" HOST_WIDE_INT_PRINT_UNSIGNED
,
5455 -TREE_INT_CST_LOW (key
));
5457 snprintf (buf
, sizeof (buf
), HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
5458 (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (key
),
5459 (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (key
));
5461 if (TYPE_NAME (type
) == 0)
5462 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
5463 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5464 "case value %qs not in enumerated type",
5467 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label
)),
5468 warn_switch
? OPT_Wswitch
: OPT_Wswitch_enum
,
5469 "case value %qs not in enumerated type %qT",
5473 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5474 Used to verify that case values match up with enumerator values. */
5477 match_case_to_enum (splay_tree_node node
, void *data
)
5479 tree label
= (tree
) node
->value
;
5480 tree type
= (tree
) data
;
5482 /* Skip default case. */
5483 if (!CASE_LOW (label
))
5486 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5487 when we did our enum->case scan. Reset our scratch bit after. */
5488 if (!CASE_LOW_SEEN (label
))
5489 match_case_to_enum_1 (CASE_LOW (label
), type
, label
);
5491 CASE_LOW_SEEN (label
) = 0;
5493 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5494 not set, that means that CASE_HIGH did not appear when we did our
5495 enum->case scan. Reset our scratch bit after. */
5496 if (CASE_HIGH (label
))
5498 if (!CASE_HIGH_SEEN (label
))
5499 match_case_to_enum_1 (CASE_HIGH (label
), type
, label
);
5501 CASE_HIGH_SEEN (label
) = 0;
5507 /* Handle -Wswitch*. Called from the front end after parsing the
5508 switch construct. */
5509 /* ??? Should probably be somewhere generic, since other languages
5510 besides C and C++ would want this. At the moment, however, C/C++
5511 are the only tree-ssa languages that support enumerations at all,
5512 so the point is moot. */
5515 c_do_switch_warnings (splay_tree cases
, location_t switch_location
,
5516 tree type
, tree cond
)
5518 splay_tree_node default_node
;
5519 splay_tree_node node
;
5522 if (!warn_switch
&& !warn_switch_enum
&& !warn_switch_default
)
5525 default_node
= splay_tree_lookup (cases
, (splay_tree_key
) NULL
);
5527 warning_at (switch_location
, OPT_Wswitch_default
,
5528 "switch missing default case");
5530 /* From here on, we only care about about enumerated types. */
5531 if (!type
|| TREE_CODE (type
) != ENUMERAL_TYPE
)
5534 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
5535 if (!warn_switch_enum
&& !warn_switch
)
5538 /* Check the cases. Warn about case values which are not members of
5539 the enumerated type. For -Wswitch-enum, or for -Wswitch when
5540 there is no default case, check that exactly all enumeration
5541 literals are covered by the cases. */
5543 /* Clearing COND if it is not an integer constant simplifies
5544 the tests inside the loop below. */
5545 if (TREE_CODE (cond
) != INTEGER_CST
)
5548 /* The time complexity here is O(N*lg(N)) worst case, but for the
5549 common case of monotonically increasing enumerators, it is
5550 O(N), since the nature of the splay tree will keep the next
5551 element adjacent to the root at all times. */
5553 for (chain
= TYPE_VALUES (type
); chain
; chain
= TREE_CHAIN (chain
))
5555 tree value
= TREE_VALUE (chain
);
5556 if (TREE_CODE (value
) == CONST_DECL
)
5557 value
= DECL_INITIAL (value
);
5558 node
= splay_tree_lookup (cases
, (splay_tree_key
) value
);
5561 /* Mark the CASE_LOW part of the case entry as seen. */
5562 tree label
= (tree
) node
->value
;
5563 CASE_LOW_SEEN (label
) = 1;
5567 /* Even though there wasn't an exact match, there might be a
5568 case range which includes the enumerator's value. */
5569 node
= splay_tree_predecessor (cases
, (splay_tree_key
) value
);
5570 if (node
&& CASE_HIGH ((tree
) node
->value
))
5572 tree label
= (tree
) node
->value
;
5573 int cmp
= tree_int_cst_compare (CASE_HIGH (label
), value
);
5576 /* If we match the upper bound exactly, mark the CASE_HIGH
5577 part of the case entry as seen. */
5579 CASE_HIGH_SEEN (label
) = 1;
5584 /* We've now determined that this enumerated literal isn't
5585 handled by the case labels of the switch statement. */
5587 /* If the switch expression is a constant, we only really care
5588 about whether that constant is handled by the switch. */
5589 if (cond
&& tree_int_cst_compare (cond
, value
))
5592 /* If there is a default_node, the only relevant option is
5593 Wswitch-enum. Otherwise, if both are enabled then we prefer
5594 to warn using -Wswitch because -Wswitch is enabled by -Wall
5595 while -Wswitch-enum is explicit. */
5596 warning_at (switch_location
,
5597 (default_node
|| !warn_switch
5600 "enumeration value %qE not handled in switch",
5601 TREE_PURPOSE (chain
));
5604 /* Warn if there are case expressions that don't correspond to
5605 enumerators. This can occur since C and C++ don't enforce
5606 type-checking of assignments to enumeration variables.
5608 The time complexity here is now always O(N) worst case, since
5609 we should have marked both the lower bound and upper bound of
5610 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5611 above. This scan also resets those fields. */
5613 splay_tree_foreach (cases
, match_case_to_enum
, type
);
5616 /* Finish an expression taking the address of LABEL (an
5617 IDENTIFIER_NODE). Returns an expression for the address.
5619 LOC is the location for the expression returned. */
5622 finish_label_address_expr (tree label
, location_t loc
)
5626 pedwarn (input_location
, OPT_pedantic
, "taking the address of a label is non-standard");
5628 if (label
== error_mark_node
)
5629 return error_mark_node
;
5631 label
= lookup_label (label
);
5632 if (label
== NULL_TREE
)
5633 result
= null_pointer_node
;
5636 TREE_USED (label
) = 1;
5637 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
5638 /* The current function in not necessarily uninlinable.
5639 Computed gotos are incompatible with inlining, but the value
5640 here could be used only in a diagnostic, for example. */
5641 protected_set_expr_location (result
, loc
);
5648 /* Given a boolean expression ARG, return a tree representing an increment
5649 or decrement (as indicated by CODE) of ARG. The front end must check for
5650 invalid cases (e.g., decrement in C++). */
5652 boolean_increment (enum tree_code code
, tree arg
)
5655 tree true_res
= build_int_cst (TREE_TYPE (arg
), 1);
5657 arg
= stabilize_reference (arg
);
5660 case PREINCREMENT_EXPR
:
5661 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5663 case POSTINCREMENT_EXPR
:
5664 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
5665 arg
= save_expr (arg
);
5666 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5667 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5669 case PREDECREMENT_EXPR
:
5670 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5671 invert_truthvalue_loc (input_location
, arg
));
5673 case POSTDECREMENT_EXPR
:
5674 val
= build2 (MODIFY_EXPR
, TREE_TYPE (arg
), arg
,
5675 invert_truthvalue_loc (input_location
, arg
));
5676 arg
= save_expr (arg
);
5677 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
5678 val
= build2 (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
5683 TREE_SIDE_EFFECTS (val
) = 1;
5687 /* Built-in macros for stddef.h and stdint.h, that require macros
5688 defined in this file. */
5690 c_stddef_cpp_builtins(void)
5692 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
5693 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
5694 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
5695 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
5696 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE
, 0);
5697 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE
, 0);
5698 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE
, 0);
5699 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE
, 0);
5700 if (SIG_ATOMIC_TYPE
)
5701 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE
, 0);
5703 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE
, 0);
5705 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE
, 0);
5707 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE
, 0);
5709 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE
, 0);
5711 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE
, 0);
5713 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE
, 0);
5715 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE
, 0);
5717 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE
, 0);
5718 if (INT_LEAST8_TYPE
)
5719 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE
, 0);
5720 if (INT_LEAST16_TYPE
)
5721 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE
, 0);
5722 if (INT_LEAST32_TYPE
)
5723 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE
, 0);
5724 if (INT_LEAST64_TYPE
)
5725 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE
, 0);
5726 if (UINT_LEAST8_TYPE
)
5727 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE
, 0);
5728 if (UINT_LEAST16_TYPE
)
5729 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE
, 0);
5730 if (UINT_LEAST32_TYPE
)
5731 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE
, 0);
5732 if (UINT_LEAST64_TYPE
)
5733 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE
, 0);
5735 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE
, 0);
5736 if (INT_FAST16_TYPE
)
5737 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE
, 0);
5738 if (INT_FAST32_TYPE
)
5739 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE
, 0);
5740 if (INT_FAST64_TYPE
)
5741 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE
, 0);
5742 if (UINT_FAST8_TYPE
)
5743 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE
, 0);
5744 if (UINT_FAST16_TYPE
)
5745 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE
, 0);
5746 if (UINT_FAST32_TYPE
)
5747 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE
, 0);
5748 if (UINT_FAST64_TYPE
)
5749 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE
, 0);
5751 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE
, 0);
5753 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE
, 0);
5757 c_init_attributes (void)
5759 /* Fill in the built_in_attributes array. */
5760 #define DEF_ATTR_NULL_TREE(ENUM) \
5761 built_in_attributes[(int) ENUM] = NULL_TREE;
5762 #define DEF_ATTR_INT(ENUM, VALUE) \
5763 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5764 #define DEF_ATTR_IDENT(ENUM, STRING) \
5765 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5766 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5767 built_in_attributes[(int) ENUM] \
5768 = tree_cons (built_in_attributes[(int) PURPOSE], \
5769 built_in_attributes[(int) VALUE], \
5770 built_in_attributes[(int) CHAIN]);
5771 #include "builtin-attrs.def"
5772 #undef DEF_ATTR_NULL_TREE
5774 #undef DEF_ATTR_IDENT
5775 #undef DEF_ATTR_TREE_LIST
5778 /* Attribute handlers common to C front ends. */
5780 /* Handle a "packed" attribute; arguments as in
5781 struct attribute_spec.handler. */
5784 handle_packed_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5785 int flags
, bool *no_add_attrs
)
5789 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5790 *node
= build_variant_type_copy (*node
);
5791 TYPE_PACKED (*node
) = 1;
5793 else if (TREE_CODE (*node
) == FIELD_DECL
)
5795 if (TYPE_ALIGN (TREE_TYPE (*node
)) <= BITS_PER_UNIT
5796 /* Still pack bitfields. */
5797 && ! DECL_INITIAL (*node
))
5798 warning (OPT_Wattributes
,
5799 "%qE attribute ignored for field of type %qT",
5800 name
, TREE_TYPE (*node
));
5802 DECL_PACKED (*node
) = 1;
5804 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5805 used for DECL_REGISTER. It wouldn't mean anything anyway.
5806 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5807 that changes what the typedef is typing. */
5810 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5811 *no_add_attrs
= true;
5817 /* Handle a "nocommon" attribute; arguments as in
5818 struct attribute_spec.handler. */
5821 handle_nocommon_attribute (tree
*node
, tree name
,
5822 tree
ARG_UNUSED (args
),
5823 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5825 if (TREE_CODE (*node
) == VAR_DECL
)
5826 DECL_COMMON (*node
) = 0;
5829 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5830 *no_add_attrs
= true;
5836 /* Handle a "common" attribute; arguments as in
5837 struct attribute_spec.handler. */
5840 handle_common_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5841 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5843 if (TREE_CODE (*node
) == VAR_DECL
)
5844 DECL_COMMON (*node
) = 1;
5847 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5848 *no_add_attrs
= true;
5854 /* Handle a "noreturn" attribute; arguments as in
5855 struct attribute_spec.handler. */
5858 handle_noreturn_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5859 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5861 tree type
= TREE_TYPE (*node
);
5863 /* See FIXME comment in c_common_attribute_table. */
5864 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5865 TREE_THIS_VOLATILE (*node
) = 1;
5866 else if (TREE_CODE (type
) == POINTER_TYPE
5867 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
5869 = build_pointer_type
5870 (build_type_variant (TREE_TYPE (type
),
5871 TYPE_READONLY (TREE_TYPE (type
)), 1));
5874 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5875 *no_add_attrs
= true;
5881 /* Handle a "hot" and attribute; arguments as in
5882 struct attribute_spec.handler. */
5885 handle_hot_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5886 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5888 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5890 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node
)) != NULL
)
5892 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5894 *no_add_attrs
= true;
5896 /* Most of the rest of the hot processing is done later with
5897 lookup_attribute. */
5901 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5902 *no_add_attrs
= true;
5907 /* Handle a "cold" and attribute; arguments as in
5908 struct attribute_spec.handler. */
5911 handle_cold_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
5912 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5914 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5916 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node
)) != NULL
)
5918 warning (OPT_Wattributes
, "%qE attribute conflicts with attribute %s",
5920 *no_add_attrs
= true;
5922 /* Most of the rest of the cold processing is done later with
5923 lookup_attribute. */
5927 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5928 *no_add_attrs
= true;
5934 /* Handle a "noinline" attribute; arguments as in
5935 struct attribute_spec.handler. */
5938 handle_noinline_attribute (tree
*node
, tree name
,
5939 tree
ARG_UNUSED (args
),
5940 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5942 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5943 DECL_UNINLINABLE (*node
) = 1;
5946 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5947 *no_add_attrs
= true;
5953 /* Handle a "noclone" attribute; arguments as in
5954 struct attribute_spec.handler. */
5957 handle_noclone_attribute (tree
*node
, tree name
,
5958 tree
ARG_UNUSED (args
),
5959 int ARG_UNUSED (flags
), bool *no_add_attrs
)
5961 if (TREE_CODE (*node
) != FUNCTION_DECL
)
5963 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5964 *no_add_attrs
= true;
5970 /* Handle a "always_inline" attribute; arguments as in
5971 struct attribute_spec.handler. */
5974 handle_always_inline_attribute (tree
*node
, tree name
,
5975 tree
ARG_UNUSED (args
),
5976 int ARG_UNUSED (flags
),
5979 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5981 /* Set the attribute and mark it for disregarding inline
5983 DECL_DISREGARD_INLINE_LIMITS (*node
) = 1;
5987 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
5988 *no_add_attrs
= true;
5994 /* Handle a "gnu_inline" attribute; arguments as in
5995 struct attribute_spec.handler. */
5998 handle_gnu_inline_attribute (tree
*node
, tree name
,
5999 tree
ARG_UNUSED (args
),
6000 int ARG_UNUSED (flags
),
6003 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
6005 /* Do nothing else, just set the attribute. We'll get at
6006 it later with lookup_attribute. */
6010 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6011 *no_add_attrs
= true;
6017 /* Handle an "artificial" attribute; arguments as in
6018 struct attribute_spec.handler. */
6021 handle_artificial_attribute (tree
*node
, tree name
,
6022 tree
ARG_UNUSED (args
),
6023 int ARG_UNUSED (flags
),
6026 if (TREE_CODE (*node
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (*node
))
6028 /* Do nothing else, just set the attribute. We'll get at
6029 it later with lookup_attribute. */
6033 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6034 *no_add_attrs
= true;
6040 /* Handle a "flatten" attribute; arguments as in
6041 struct attribute_spec.handler. */
6044 handle_flatten_attribute (tree
*node
, tree name
,
6045 tree args ATTRIBUTE_UNUSED
,
6046 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
6048 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6049 /* Do nothing else, just set the attribute. We'll get at
6050 it later with lookup_attribute. */
6054 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6055 *no_add_attrs
= true;
6061 /* Handle a "warning" or "error" attribute; arguments as in
6062 struct attribute_spec.handler. */
6065 handle_error_attribute (tree
*node
, tree name
, tree args
,
6066 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6068 if (TREE_CODE (*node
) == FUNCTION_DECL
6069 || TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
6070 /* Do nothing else, just set the attribute. We'll get at
6071 it later with lookup_attribute. */
6075 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6076 *no_add_attrs
= true;
6082 /* Handle a "used" attribute; arguments as in
6083 struct attribute_spec.handler. */
6086 handle_used_attribute (tree
*pnode
, tree name
, tree
ARG_UNUSED (args
),
6087 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6091 if (TREE_CODE (node
) == FUNCTION_DECL
6092 || (TREE_CODE (node
) == VAR_DECL
&& TREE_STATIC (node
)))
6094 TREE_USED (node
) = 1;
6095 DECL_PRESERVE_P (node
) = 1;
6099 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6100 *no_add_attrs
= true;
6106 /* Handle a "unused" attribute; arguments as in
6107 struct attribute_spec.handler. */
6110 handle_unused_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6111 int flags
, bool *no_add_attrs
)
6117 if (TREE_CODE (decl
) == PARM_DECL
6118 || TREE_CODE (decl
) == VAR_DECL
6119 || TREE_CODE (decl
) == FUNCTION_DECL
6120 || TREE_CODE (decl
) == LABEL_DECL
6121 || TREE_CODE (decl
) == TYPE_DECL
)
6122 TREE_USED (decl
) = 1;
6125 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6126 *no_add_attrs
= true;
6131 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6132 *node
= build_variant_type_copy (*node
);
6133 TREE_USED (*node
) = 1;
6139 /* Handle a "externally_visible" attribute; arguments as in
6140 struct attribute_spec.handler. */
6143 handle_externally_visible_attribute (tree
*pnode
, tree name
,
6144 tree
ARG_UNUSED (args
),
6145 int ARG_UNUSED (flags
),
6150 if (TREE_CODE (node
) == FUNCTION_DECL
|| TREE_CODE (node
) == VAR_DECL
)
6152 if ((!TREE_STATIC (node
) && TREE_CODE (node
) != FUNCTION_DECL
6153 && !DECL_EXTERNAL (node
)) || !TREE_PUBLIC (node
))
6155 warning (OPT_Wattributes
,
6156 "%qE attribute have effect only on public objects", name
);
6157 *no_add_attrs
= true;
6162 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6163 *no_add_attrs
= true;
6169 /* Handle a "const" attribute; arguments as in
6170 struct attribute_spec.handler. */
6173 handle_const_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
6174 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6176 tree type
= TREE_TYPE (*node
);
6178 /* See FIXME comment on noreturn in c_common_attribute_table. */
6179 if (TREE_CODE (*node
) == FUNCTION_DECL
)
6180 TREE_READONLY (*node
) = 1;
6181 else if (TREE_CODE (type
) == POINTER_TYPE
6182 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
6184 = build_pointer_type
6185 (build_type_variant (TREE_TYPE (type
), 1,
6186 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
6189 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6190 *no_add_attrs
= true;
6196 /* Handle a "transparent_union" attribute; arguments as in
6197 struct attribute_spec.handler. */
6200 handle_transparent_union_attribute (tree
*node
, tree name
,
6201 tree
ARG_UNUSED (args
), int flags
,
6206 *no_add_attrs
= true;
6208 if (TREE_CODE (*node
) == TYPE_DECL
)
6209 node
= &TREE_TYPE (*node
);
6212 if (TREE_CODE (type
) == UNION_TYPE
)
6214 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6215 the code in finish_struct. */
6216 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6218 if (TYPE_FIELDS (type
) == NULL_TREE
6219 || TYPE_MODE (type
) != DECL_MODE (TYPE_FIELDS (type
)))
6222 /* A type variant isn't good enough, since we don't a cast
6223 to such a type removed as a no-op. */
6224 *node
= type
= build_duplicate_type (type
);
6227 TYPE_TRANSPARENT_UNION (type
) = 1;
6232 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6236 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6237 get the requested priority for a constructor or destructor,
6238 possibly issuing diagnostics for invalid or reserved
6241 static priority_type
6242 get_priority (tree args
, bool is_destructor
)
6248 return DEFAULT_INIT_PRIORITY
;
6250 if (!SUPPORTS_INIT_PRIORITY
)
6253 error ("destructor priorities are not supported");
6255 error ("constructor priorities are not supported");
6256 return DEFAULT_INIT_PRIORITY
;
6259 arg
= TREE_VALUE (args
);
6260 if (!host_integerp (arg
, /*pos=*/0)
6261 || !INTEGRAL_TYPE_P (TREE_TYPE (arg
)))
6264 pri
= tree_low_cst (TREE_VALUE (args
), /*pos=*/0);
6265 if (pri
< 0 || pri
> MAX_INIT_PRIORITY
)
6268 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
6272 "destructor priorities from 0 to %d are reserved "
6273 "for the implementation",
6274 MAX_RESERVED_INIT_PRIORITY
);
6277 "constructor priorities from 0 to %d are reserved "
6278 "for the implementation",
6279 MAX_RESERVED_INIT_PRIORITY
);
6285 error ("destructor priorities must be integers from 0 to %d inclusive",
6288 error ("constructor priorities must be integers from 0 to %d inclusive",
6290 return DEFAULT_INIT_PRIORITY
;
6293 /* Handle a "constructor" attribute; arguments as in
6294 struct attribute_spec.handler. */
6297 handle_constructor_attribute (tree
*node
, tree name
, tree args
,
6298 int ARG_UNUSED (flags
),
6302 tree type
= TREE_TYPE (decl
);
6304 if (TREE_CODE (decl
) == FUNCTION_DECL
6305 && TREE_CODE (type
) == FUNCTION_TYPE
6306 && decl_function_context (decl
) == 0)
6308 priority_type priority
;
6309 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
6310 priority
= get_priority (args
, /*is_destructor=*/false);
6311 SET_DECL_INIT_PRIORITY (decl
, priority
);
6312 TREE_USED (decl
) = 1;
6316 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6317 *no_add_attrs
= true;
6323 /* Handle a "destructor" attribute; arguments as in
6324 struct attribute_spec.handler. */
6327 handle_destructor_attribute (tree
*node
, tree name
, tree args
,
6328 int ARG_UNUSED (flags
),
6332 tree type
= TREE_TYPE (decl
);
6334 if (TREE_CODE (decl
) == FUNCTION_DECL
6335 && TREE_CODE (type
) == FUNCTION_TYPE
6336 && decl_function_context (decl
) == 0)
6338 priority_type priority
;
6339 DECL_STATIC_DESTRUCTOR (decl
) = 1;
6340 priority
= get_priority (args
, /*is_destructor=*/true);
6341 SET_DECL_FINI_PRIORITY (decl
, priority
);
6342 TREE_USED (decl
) = 1;
6346 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6347 *no_add_attrs
= true;
6353 /* Handle a "mode" attribute; arguments as in
6354 struct attribute_spec.handler. */
6357 handle_mode_attribute (tree
*node
, tree name
, tree args
,
6358 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6361 tree ident
= TREE_VALUE (args
);
6363 *no_add_attrs
= true;
6365 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
6366 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6370 const char *p
= IDENTIFIER_POINTER (ident
);
6371 int len
= strlen (p
);
6372 enum machine_mode mode
= VOIDmode
;
6376 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
6377 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
6379 char *newp
= (char *) alloca (len
- 1);
6381 strcpy (newp
, &p
[2]);
6382 newp
[len
- 4] = '\0';
6386 /* Change this type to have a type with the specified mode.
6387 First check for the special modes. */
6388 if (!strcmp (p
, "byte"))
6390 else if (!strcmp (p
, "word"))
6392 else if (!strcmp (p
, "pointer"))
6394 else if (!strcmp (p
, "libgcc_cmp_return"))
6395 mode
= targetm
.libgcc_cmp_return_mode ();
6396 else if (!strcmp (p
, "libgcc_shift_count"))
6397 mode
= targetm
.libgcc_shift_count_mode ();
6398 else if (!strcmp (p
, "unwind_word"))
6399 mode
= targetm
.unwind_word_mode ();
6401 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
6402 if (!strcmp (p
, GET_MODE_NAME (j
)))
6404 mode
= (enum machine_mode
) j
;
6408 if (mode
== VOIDmode
)
6410 error ("unknown machine mode %qE", ident
);
6415 switch (GET_MODE_CLASS (mode
))
6418 case MODE_PARTIAL_INT
:
6420 case MODE_DECIMAL_FLOAT
:
6425 valid_mode
= targetm
.scalar_mode_supported_p (mode
);
6428 case MODE_COMPLEX_INT
:
6429 case MODE_COMPLEX_FLOAT
:
6430 valid_mode
= targetm
.scalar_mode_supported_p (GET_MODE_INNER (mode
));
6433 case MODE_VECTOR_INT
:
6434 case MODE_VECTOR_FLOAT
:
6435 case MODE_VECTOR_FRACT
:
6436 case MODE_VECTOR_UFRACT
:
6437 case MODE_VECTOR_ACCUM
:
6438 case MODE_VECTOR_UACCUM
:
6439 warning (OPT_Wattributes
, "specifying vector types with "
6440 "__attribute__ ((mode)) is deprecated");
6441 warning (OPT_Wattributes
,
6442 "use __attribute__ ((vector_size)) instead");
6443 valid_mode
= vector_mode_valid_p (mode
);
6451 error ("unable to emulate %qs", p
);
6455 if (POINTER_TYPE_P (type
))
6457 tree (*fn
)(tree
, enum machine_mode
, bool);
6459 if (!targetm
.valid_pointer_mode (mode
))
6461 error ("invalid pointer mode %qs", p
);
6465 if (TREE_CODE (type
) == POINTER_TYPE
)
6466 fn
= build_pointer_type_for_mode
;
6468 fn
= build_reference_type_for_mode
;
6469 typefm
= fn (TREE_TYPE (type
), mode
, false);
6473 /* For fixed-point modes, we need to test if the signness of type
6474 and the machine mode are consistent. */
6475 if (ALL_FIXED_POINT_MODE_P (mode
)
6476 && TYPE_UNSIGNED (type
) != UNSIGNED_FIXED_POINT_MODE_P (mode
))
6478 error ("signness of type and machine mode %qs don't match", p
);
6481 /* For fixed-point modes, we need to pass saturating info. */
6482 typefm
= lang_hooks
.types
.type_for_mode (mode
,
6483 ALL_FIXED_POINT_MODE_P (mode
) ? TYPE_SATURATING (type
)
6484 : TYPE_UNSIGNED (type
));
6487 if (typefm
== NULL_TREE
)
6489 error ("no data type for mode %qs", p
);
6492 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
6494 /* For enumeral types, copy the precision from the integer
6495 type returned above. If not an INTEGER_TYPE, we can't use
6496 this mode for this type. */
6497 if (TREE_CODE (typefm
) != INTEGER_TYPE
)
6499 error ("cannot use mode %qs for enumeral types", p
);
6503 if (flags
& ATTR_FLAG_TYPE_IN_PLACE
)
6505 TYPE_PRECISION (type
) = TYPE_PRECISION (typefm
);
6510 /* We cannot build a type variant, as there's code that assumes
6511 that TYPE_MAIN_VARIANT has the same mode. This includes the
6512 debug generators. Instead, create a subrange type. This
6513 results in all of the enumeral values being emitted only once
6514 in the original, and the subtype gets them by reference. */
6515 if (TYPE_UNSIGNED (type
))
6516 typefm
= make_unsigned_type (TYPE_PRECISION (typefm
));
6518 typefm
= make_signed_type (TYPE_PRECISION (typefm
));
6519 TREE_TYPE (typefm
) = type
;
6522 else if (VECTOR_MODE_P (mode
)
6523 ? TREE_CODE (type
) != TREE_CODE (TREE_TYPE (typefm
))
6524 : TREE_CODE (type
) != TREE_CODE (typefm
))
6526 error ("mode %qs applied to inappropriate type", p
);
6536 /* Handle a "section" attribute; arguments as in
6537 struct attribute_spec.handler. */
6540 handle_section_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6541 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6545 if (targetm
.have_named_sections
)
6547 user_defined_section_attribute
= true;
6549 if ((TREE_CODE (decl
) == FUNCTION_DECL
6550 || TREE_CODE (decl
) == VAR_DECL
)
6551 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
6553 if (TREE_CODE (decl
) == VAR_DECL
6554 && current_function_decl
!= NULL_TREE
6555 && !TREE_STATIC (decl
))
6557 error_at (DECL_SOURCE_LOCATION (decl
),
6558 "section attribute cannot be specified for "
6560 *no_add_attrs
= true;
6563 /* The decl may have already been given a section attribute
6564 from a previous declaration. Ensure they match. */
6565 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
6566 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
6567 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
6569 error ("section of %q+D conflicts with previous declaration",
6571 *no_add_attrs
= true;
6573 else if (TREE_CODE (decl
) == VAR_DECL
6574 && !targetm
.have_tls
&& targetm
.emutls
.tmpl_section
6575 && DECL_THREAD_LOCAL_P (decl
))
6577 error ("section of %q+D cannot be overridden", *node
);
6578 *no_add_attrs
= true;
6581 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
6585 error ("section attribute not allowed for %q+D", *node
);
6586 *no_add_attrs
= true;
6591 error_at (DECL_SOURCE_LOCATION (*node
),
6592 "section attributes are not supported for this target");
6593 *no_add_attrs
= true;
6599 /* Handle a "aligned" attribute; arguments as in
6600 struct attribute_spec.handler. */
6603 handle_aligned_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6604 int flags
, bool *no_add_attrs
)
6606 tree decl
= NULL_TREE
;
6609 tree align_expr
= (args
? TREE_VALUE (args
)
6610 : size_int (ATTRIBUTE_ALIGNED_VALUE
/ BITS_PER_UNIT
));
6616 type
= &TREE_TYPE (decl
);
6617 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
6619 else if (TYPE_P (*node
))
6620 type
= node
, is_type
= 1;
6622 if (TREE_CODE (align_expr
) != INTEGER_CST
)
6624 error ("requested alignment is not a constant");
6625 *no_add_attrs
= true;
6627 else if ((i
= tree_log2 (align_expr
)) == -1)
6629 error ("requested alignment is not a power of 2");
6630 *no_add_attrs
= true;
6632 else if (i
>= HOST_BITS_PER_INT
- BITS_PER_UNIT_LOG
)
6634 error ("requested alignment is too large");
6635 *no_add_attrs
= true;
6639 /* If we have a TYPE_DECL, then copy the type, so that we
6640 don't accidentally modify a builtin type. See pushdecl. */
6641 if (decl
&& TREE_TYPE (decl
) != error_mark_node
6642 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
6644 tree tt
= TREE_TYPE (decl
);
6645 *type
= build_variant_type_copy (*type
);
6646 DECL_ORIGINAL_TYPE (decl
) = tt
;
6647 TYPE_NAME (*type
) = decl
;
6648 TREE_USED (*type
) = TREE_USED (decl
);
6649 TREE_TYPE (decl
) = *type
;
6651 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
6652 *type
= build_variant_type_copy (*type
);
6654 TYPE_ALIGN (*type
) = (1U << i
) * BITS_PER_UNIT
;
6655 TYPE_USER_ALIGN (*type
) = 1;
6657 else if (! VAR_OR_FUNCTION_DECL_P (decl
)
6658 && TREE_CODE (decl
) != FIELD_DECL
)
6660 error ("alignment may not be specified for %q+D", decl
);
6661 *no_add_attrs
= true;
6663 else if (TREE_CODE (decl
) == FUNCTION_DECL
6664 && DECL_ALIGN (decl
) > (1U << i
) * BITS_PER_UNIT
)
6666 if (DECL_USER_ALIGN (decl
))
6667 error ("alignment for %q+D was previously specified as %d "
6668 "and may not be decreased", decl
,
6669 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6671 error ("alignment for %q+D must be at least %d", decl
,
6672 DECL_ALIGN (decl
) / BITS_PER_UNIT
);
6673 *no_add_attrs
= true;
6677 DECL_ALIGN (decl
) = (1U << i
) * BITS_PER_UNIT
;
6678 DECL_USER_ALIGN (decl
) = 1;
6684 /* Handle a "weak" attribute; arguments as in
6685 struct attribute_spec.handler. */
6688 handle_weak_attribute (tree
*node
, tree name
,
6689 tree
ARG_UNUSED (args
),
6690 int ARG_UNUSED (flags
),
6691 bool * ARG_UNUSED (no_add_attrs
))
6693 if (TREE_CODE (*node
) == FUNCTION_DECL
6694 && DECL_DECLARED_INLINE_P (*node
))
6696 error ("inline function %q+D cannot be declared weak", *node
);
6697 *no_add_attrs
= true;
6699 else if (TREE_CODE (*node
) == FUNCTION_DECL
6700 || TREE_CODE (*node
) == VAR_DECL
)
6701 declare_weak (*node
);
6703 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6708 /* Handle an "alias" attribute; arguments as in
6709 struct attribute_spec.handler. */
6712 handle_alias_attribute (tree
*node
, tree name
, tree args
,
6713 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6717 if (TREE_CODE (decl
) != FUNCTION_DECL
&& TREE_CODE (decl
) != VAR_DECL
)
6719 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6720 *no_add_attrs
= true;
6722 else if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
6723 || (TREE_CODE (decl
) != FUNCTION_DECL
6724 && TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
6725 /* A static variable declaration is always a tentative definition,
6726 but the alias is a non-tentative definition which overrides. */
6727 || (TREE_CODE (decl
) != FUNCTION_DECL
6728 && ! TREE_PUBLIC (decl
) && DECL_INITIAL (decl
)))
6730 error ("%q+D defined both normally and as an alias", decl
);
6731 *no_add_attrs
= true;
6734 /* Note that the very first time we process a nested declaration,
6735 decl_function_context will not be set. Indeed, *would* never
6736 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6737 we do below. After such frobbery, pushdecl would set the context.
6738 In any case, this is never what we want. */
6739 else if (decl_function_context (decl
) == 0 && current_function_decl
== NULL
)
6743 id
= TREE_VALUE (args
);
6744 if (TREE_CODE (id
) != STRING_CST
)
6746 error ("alias argument not a string");
6747 *no_add_attrs
= true;
6750 id
= get_identifier (TREE_STRING_POINTER (id
));
6751 /* This counts as a use of the object pointed to. */
6754 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6755 DECL_INITIAL (decl
) = error_mark_node
;
6758 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
6759 DECL_EXTERNAL (decl
) = 1;
6761 DECL_EXTERNAL (decl
) = 0;
6762 TREE_STATIC (decl
) = 1;
6767 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6768 *no_add_attrs
= true;
6774 /* Handle a "weakref" attribute; arguments as in struct
6775 attribute_spec.handler. */
6778 handle_weakref_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
6779 int flags
, bool *no_add_attrs
)
6781 tree attr
= NULL_TREE
;
6783 /* We must ignore the attribute when it is associated with
6784 local-scoped decls, since attribute alias is ignored and many
6785 such symbols do not even have a DECL_WEAK field. */
6786 if (decl_function_context (*node
)
6787 || current_function_decl
6788 || (TREE_CODE (*node
) != VAR_DECL
&& TREE_CODE (*node
) != FUNCTION_DECL
))
6790 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6791 *no_add_attrs
= true;
6795 /* The idea here is that `weakref("name")' mutates into `weakref,
6796 alias("name")', and weakref without arguments, in turn,
6797 implicitly adds weak. */
6801 attr
= tree_cons (get_identifier ("alias"), args
, attr
);
6802 attr
= tree_cons (get_identifier ("weakref"), NULL_TREE
, attr
);
6804 *no_add_attrs
= true;
6806 decl_attributes (node
, attr
, flags
);
6810 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node
)))
6811 error_at (DECL_SOURCE_LOCATION (*node
),
6812 "weakref attribute must appear before alias attribute");
6814 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6815 and that isn't supported; and because it wants to add it to
6816 the list of weak decls, which isn't helpful. */
6817 DECL_WEAK (*node
) = 1;
6823 /* Handle an "visibility" attribute; arguments as in
6824 struct attribute_spec.handler. */
6827 handle_visibility_attribute (tree
*node
, tree name
, tree args
,
6828 int ARG_UNUSED (flags
),
6829 bool *ARG_UNUSED (no_add_attrs
))
6832 tree id
= TREE_VALUE (args
);
6833 enum symbol_visibility vis
;
6837 if (TREE_CODE (*node
) == ENUMERAL_TYPE
)
6839 else if (TREE_CODE (*node
) != RECORD_TYPE
&& TREE_CODE (*node
) != UNION_TYPE
)
6841 warning (OPT_Wattributes
, "%qE attribute ignored on non-class types",
6845 else if (TYPE_FIELDS (*node
))
6847 error ("%qE attribute ignored because %qT is already defined",
6852 else if (decl_function_context (decl
) != 0 || !TREE_PUBLIC (decl
))
6854 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6858 if (TREE_CODE (id
) != STRING_CST
)
6860 error ("visibility argument not a string");
6864 /* If this is a type, set the visibility on the type decl. */
6867 decl
= TYPE_NAME (decl
);
6870 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6872 warning (OPT_Wattributes
, "%qE attribute ignored on types",
6878 if (strcmp (TREE_STRING_POINTER (id
), "default") == 0)
6879 vis
= VISIBILITY_DEFAULT
;
6880 else if (strcmp (TREE_STRING_POINTER (id
), "internal") == 0)
6881 vis
= VISIBILITY_INTERNAL
;
6882 else if (strcmp (TREE_STRING_POINTER (id
), "hidden") == 0)
6883 vis
= VISIBILITY_HIDDEN
;
6884 else if (strcmp (TREE_STRING_POINTER (id
), "protected") == 0)
6885 vis
= VISIBILITY_PROTECTED
;
6888 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6889 vis
= VISIBILITY_DEFAULT
;
6892 if (DECL_VISIBILITY_SPECIFIED (decl
)
6893 && vis
!= DECL_VISIBILITY (decl
))
6895 tree attributes
= (TYPE_P (*node
)
6896 ? TYPE_ATTRIBUTES (*node
)
6897 : DECL_ATTRIBUTES (decl
));
6898 if (lookup_attribute ("visibility", attributes
))
6899 error ("%qD redeclared with different visibility", decl
);
6900 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6901 && lookup_attribute ("dllimport", attributes
))
6902 error ("%qD was declared %qs which implies default visibility",
6904 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6905 && lookup_attribute ("dllexport", attributes
))
6906 error ("%qD was declared %qs which implies default visibility",
6910 DECL_VISIBILITY (decl
) = vis
;
6911 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
6913 /* Go ahead and attach the attribute to the node as well. This is needed
6914 so we can determine whether we have VISIBILITY_DEFAULT because the
6915 visibility was not specified, or because it was explicitly overridden
6916 from the containing scope. */
6921 /* Determine the ELF symbol visibility for DECL, which is either a
6922 variable or a function. It is an error to use this function if a
6923 definition of DECL is not available in this translation unit.
6924 Returns true if the final visibility has been determined by this
6925 function; false if the caller is free to make additional
6929 c_determine_visibility (tree decl
)
6931 gcc_assert (TREE_CODE (decl
) == VAR_DECL
6932 || TREE_CODE (decl
) == FUNCTION_DECL
);
6934 /* If the user explicitly specified the visibility with an
6935 attribute, honor that. DECL_VISIBILITY will have been set during
6936 the processing of the attribute. We check for an explicit
6937 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6938 to distinguish the use of an attribute from the use of a "#pragma
6939 GCC visibility push(...)"; in the latter case we still want other
6940 considerations to be able to overrule the #pragma. */
6941 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
))
6942 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6943 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl
))
6944 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))))
6947 /* Set default visibility to whatever the user supplied with
6948 visibility_specified depending on #pragma GCC visibility. */
6949 if (!DECL_VISIBILITY_SPECIFIED (decl
))
6951 if (visibility_options
.inpragma
6952 || DECL_VISIBILITY (decl
) != default_visibility
)
6954 DECL_VISIBILITY (decl
) = default_visibility
;
6955 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
6956 /* If visibility changed and DECL already has DECL_RTL, ensure
6957 symbol flags are updated. */
6958 if (((TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
6959 || TREE_CODE (decl
) == FUNCTION_DECL
)
6960 && DECL_RTL_SET_P (decl
))
6961 make_decl_rtl (decl
);
6967 /* Handle an "tls_model" attribute; arguments as in
6968 struct attribute_spec.handler. */
6971 handle_tls_model_attribute (tree
*node
, tree name
, tree args
,
6972 int ARG_UNUSED (flags
), bool *no_add_attrs
)
6976 enum tls_model kind
;
6978 *no_add_attrs
= true;
6980 if (TREE_CODE (decl
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (decl
))
6982 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
6986 kind
= DECL_TLS_MODEL (decl
);
6987 id
= TREE_VALUE (args
);
6988 if (TREE_CODE (id
) != STRING_CST
)
6990 error ("tls_model argument not a string");
6994 if (!strcmp (TREE_STRING_POINTER (id
), "local-exec"))
6995 kind
= TLS_MODEL_LOCAL_EXEC
;
6996 else if (!strcmp (TREE_STRING_POINTER (id
), "initial-exec"))
6997 kind
= TLS_MODEL_INITIAL_EXEC
;
6998 else if (!strcmp (TREE_STRING_POINTER (id
), "local-dynamic"))
6999 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
7000 else if (!strcmp (TREE_STRING_POINTER (id
), "global-dynamic"))
7001 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
7003 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7005 DECL_TLS_MODEL (decl
) = kind
;
7009 /* Handle a "no_instrument_function" attribute; arguments as in
7010 struct attribute_spec.handler. */
7013 handle_no_instrument_function_attribute (tree
*node
, tree name
,
7014 tree
ARG_UNUSED (args
),
7015 int ARG_UNUSED (flags
),
7020 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7022 error_at (DECL_SOURCE_LOCATION (decl
),
7023 "%qE attribute applies only to functions", name
);
7024 *no_add_attrs
= true;
7026 else if (DECL_INITIAL (decl
))
7028 error_at (DECL_SOURCE_LOCATION (decl
),
7029 "can%'t set %qE attribute after definition", name
);
7030 *no_add_attrs
= true;
7033 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
7038 /* Handle a "malloc" attribute; arguments as in
7039 struct attribute_spec.handler. */
7042 handle_malloc_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7043 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7045 if (TREE_CODE (*node
) == FUNCTION_DECL
7046 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
7047 DECL_IS_MALLOC (*node
) = 1;
7050 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7051 *no_add_attrs
= true;
7057 /* Handle a "alloc_size" attribute; arguments as in
7058 struct attribute_spec.handler. */
7061 handle_alloc_size_attribute (tree
*node
, tree
ARG_UNUSED (name
), tree args
,
7062 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7064 unsigned arg_count
= type_num_arguments (*node
);
7065 for (; args
; args
= TREE_CHAIN (args
))
7067 tree position
= TREE_VALUE (args
);
7069 if (TREE_CODE (position
) != INTEGER_CST
7070 || TREE_INT_CST_HIGH (position
)
7071 || TREE_INT_CST_LOW (position
) < 1
7072 || TREE_INT_CST_LOW (position
) > arg_count
)
7074 warning (OPT_Wattributes
,
7075 "alloc_size parameter outside range");
7076 *no_add_attrs
= true;
7083 /* Handle a "returns_twice" attribute; arguments as in
7084 struct attribute_spec.handler. */
7087 handle_returns_twice_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7088 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7090 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7091 DECL_IS_RETURNS_TWICE (*node
) = 1;
7094 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7095 *no_add_attrs
= true;
7101 /* Handle a "no_limit_stack" attribute; arguments as in
7102 struct attribute_spec.handler. */
7105 handle_no_limit_stack_attribute (tree
*node
, tree name
,
7106 tree
ARG_UNUSED (args
),
7107 int ARG_UNUSED (flags
),
7112 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7114 error_at (DECL_SOURCE_LOCATION (decl
),
7115 "%qE attribute applies only to functions", name
);
7116 *no_add_attrs
= true;
7118 else if (DECL_INITIAL (decl
))
7120 error_at (DECL_SOURCE_LOCATION (decl
),
7121 "can%'t set %qE attribute after definition", name
);
7122 *no_add_attrs
= true;
7125 DECL_NO_LIMIT_STACK (decl
) = 1;
7130 /* Handle a "pure" attribute; arguments as in
7131 struct attribute_spec.handler. */
7134 handle_pure_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7135 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7137 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7138 DECL_PURE_P (*node
) = 1;
7139 /* ??? TODO: Support types. */
7142 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7143 *no_add_attrs
= true;
7149 /* Handle a "no vops" attribute; arguments as in
7150 struct attribute_spec.handler. */
7153 handle_novops_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7154 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
7155 bool *ARG_UNUSED (no_add_attrs
))
7157 gcc_assert (TREE_CODE (*node
) == FUNCTION_DECL
);
7158 DECL_IS_NOVOPS (*node
) = 1;
7162 /* Handle a "deprecated" attribute; arguments as in
7163 struct attribute_spec.handler. */
7166 handle_deprecated_attribute (tree
*node
, tree name
,
7167 tree args
, int flags
,
7170 tree type
= NULL_TREE
;
7172 tree what
= NULL_TREE
;
7175 *no_add_attrs
= true;
7176 else if (TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
7178 error ("deprecated message is not a string");
7179 *no_add_attrs
= true;
7185 type
= TREE_TYPE (decl
);
7187 if (TREE_CODE (decl
) == TYPE_DECL
7188 || TREE_CODE (decl
) == PARM_DECL
7189 || TREE_CODE (decl
) == VAR_DECL
7190 || TREE_CODE (decl
) == FUNCTION_DECL
7191 || TREE_CODE (decl
) == FIELD_DECL
)
7192 TREE_DEPRECATED (decl
) = 1;
7196 else if (TYPE_P (*node
))
7198 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
7199 *node
= build_variant_type_copy (*node
);
7200 TREE_DEPRECATED (*node
) = 1;
7208 *no_add_attrs
= true;
7209 if (type
&& TYPE_NAME (type
))
7211 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
7212 what
= TYPE_NAME (*node
);
7213 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
7214 && DECL_NAME (TYPE_NAME (type
)))
7215 what
= DECL_NAME (TYPE_NAME (type
));
7218 warning (OPT_Wattributes
, "%qE attribute ignored for %qE", name
, what
);
7220 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7226 /* Handle a "vector_size" attribute; arguments as in
7227 struct attribute_spec.handler. */
7230 handle_vector_size_attribute (tree
*node
, tree name
, tree args
,
7231 int ARG_UNUSED (flags
),
7234 unsigned HOST_WIDE_INT vecsize
, nunits
;
7235 enum machine_mode orig_mode
;
7236 tree type
= *node
, new_type
, size
;
7238 *no_add_attrs
= true;
7240 size
= TREE_VALUE (args
);
7242 if (!host_integerp (size
, 1))
7244 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7248 /* Get the vector size (in bytes). */
7249 vecsize
= tree_low_cst (size
, 1);
7251 /* We need to provide for vector pointers, vector arrays, and
7252 functions returning vectors. For example:
7254 __attribute__((vector_size(16))) short *foo;
7256 In this case, the mode is SI, but the type being modified is
7257 HI, so we need to look further. */
7259 while (POINTER_TYPE_P (type
)
7260 || TREE_CODE (type
) == FUNCTION_TYPE
7261 || TREE_CODE (type
) == METHOD_TYPE
7262 || TREE_CODE (type
) == ARRAY_TYPE
7263 || TREE_CODE (type
) == OFFSET_TYPE
)
7264 type
= TREE_TYPE (type
);
7266 /* Get the mode of the type being modified. */
7267 orig_mode
= TYPE_MODE (type
);
7269 if ((!INTEGRAL_TYPE_P (type
)
7270 && !SCALAR_FLOAT_TYPE_P (type
)
7271 && !FIXED_POINT_TYPE_P (type
))
7272 || (!SCALAR_FLOAT_MODE_P (orig_mode
)
7273 && GET_MODE_CLASS (orig_mode
) != MODE_INT
7274 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode
))
7275 || !host_integerp (TYPE_SIZE_UNIT (type
), 1)
7276 || TREE_CODE (type
) == BOOLEAN_TYPE
)
7278 error ("invalid vector type for attribute %qE", name
);
7282 if (vecsize
% tree_low_cst (TYPE_SIZE_UNIT (type
), 1))
7284 error ("vector size not an integral multiple of component size");
7290 error ("zero vector size");
7294 /* Calculate how many units fit in the vector. */
7295 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
7296 if (nunits
& (nunits
- 1))
7298 error ("number of components of the vector not a power of two");
7302 new_type
= build_vector_type (type
, nunits
);
7304 /* Build back pointers if needed. */
7305 *node
= lang_hooks
.types
.reconstruct_complex_type (*node
, new_type
);
7310 /* Handle the "nonnull" attribute. */
7312 handle_nonnull_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7313 tree args
, int ARG_UNUSED (flags
),
7317 unsigned HOST_WIDE_INT attr_arg_num
;
7319 /* If no arguments are specified, all pointer arguments should be
7320 non-null. Verify a full prototype is given so that the arguments
7321 will have the correct types when we actually check them later. */
7324 if (!TYPE_ARG_TYPES (type
))
7326 error ("nonnull attribute without arguments on a non-prototype");
7327 *no_add_attrs
= true;
7332 /* Argument list specified. Verify that each argument number references
7333 a pointer argument. */
7334 for (attr_arg_num
= 1; args
; args
= TREE_CHAIN (args
))
7337 unsigned HOST_WIDE_INT arg_num
= 0, ck_num
;
7339 if (!get_nonnull_operand (TREE_VALUE (args
), &arg_num
))
7341 error ("nonnull argument has invalid operand number (argument %lu)",
7342 (unsigned long) attr_arg_num
);
7343 *no_add_attrs
= true;
7347 argument
= TYPE_ARG_TYPES (type
);
7350 for (ck_num
= 1; ; ck_num
++)
7352 if (!argument
|| ck_num
== arg_num
)
7354 argument
= TREE_CHAIN (argument
);
7358 || TREE_CODE (TREE_VALUE (argument
)) == VOID_TYPE
)
7360 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7361 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7362 *no_add_attrs
= true;
7366 if (TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
)
7368 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7369 (unsigned long) attr_arg_num
, (unsigned long) arg_num
);
7370 *no_add_attrs
= true;
7379 /* Check the argument list of a function call for null in argument slots
7380 that are marked as requiring a non-null pointer argument. The NARGS
7381 arguments are passed in the array ARGARRAY.
7385 check_function_nonnull (tree attrs
, int nargs
, tree
*argarray
)
7390 for (a
= attrs
; a
; a
= TREE_CHAIN (a
))
7392 if (is_attribute_p ("nonnull", TREE_PURPOSE (a
)))
7394 args
= TREE_VALUE (a
);
7396 /* Walk the argument list. If we encounter an argument number we
7397 should check for non-null, do it. If the attribute has no args,
7398 then every pointer argument is checked (in which case the check
7399 for pointer type is done in check_nonnull_arg). */
7400 for (i
= 0; i
< nargs
; i
++)
7402 if (!args
|| nonnull_check_p (args
, i
+ 1))
7403 check_function_arguments_recurse (check_nonnull_arg
, NULL
,
7411 /* Check that the Nth argument of a function call (counting backwards
7412 from the end) is a (pointer)0. The NARGS arguments are passed in the
7416 check_function_sentinel (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7418 tree attr
= lookup_attribute ("sentinel", attrs
);
7426 /* Skip over the named arguments. */
7427 while (typelist
&& len
< nargs
)
7429 typelist
= TREE_CHAIN (typelist
);
7433 if (TREE_VALUE (attr
))
7435 tree p
= TREE_VALUE (TREE_VALUE (attr
));
7436 pos
= TREE_INT_CST_LOW (p
);
7439 /* The sentinel must be one of the varargs, i.e.
7440 in position >= the number of fixed arguments. */
7441 if ((nargs
- 1 - pos
) < len
)
7443 warning (OPT_Wformat
,
7444 "not enough variable arguments to fit a sentinel");
7448 /* Validate the sentinel. */
7449 sentinel
= argarray
[nargs
- 1 - pos
];
7450 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel
))
7451 || !integer_zerop (sentinel
))
7452 /* Although __null (in C++) is only an integer we allow it
7453 nevertheless, as we are guaranteed that it's exactly
7454 as wide as a pointer, and we don't want to force
7455 users to cast the NULL they have written there.
7456 We warn with -Wstrict-null-sentinel, though. */
7457 && (warn_strict_null_sentinel
|| null_node
!= sentinel
))
7458 warning (OPT_Wformat
, "missing sentinel in function call");
7462 /* Helper for check_function_nonnull; given a list of operands which
7463 must be non-null in ARGS, determine if operand PARAM_NUM should be
7467 nonnull_check_p (tree args
, unsigned HOST_WIDE_INT param_num
)
7469 unsigned HOST_WIDE_INT arg_num
= 0;
7471 for (; args
; args
= TREE_CHAIN (args
))
7473 bool found
= get_nonnull_operand (TREE_VALUE (args
), &arg_num
);
7477 if (arg_num
== param_num
)
7483 /* Check that the function argument PARAM (which is operand number
7484 PARAM_NUM) is non-null. This is called by check_function_nonnull
7485 via check_function_arguments_recurse. */
7488 check_nonnull_arg (void * ARG_UNUSED (ctx
), tree param
,
7489 unsigned HOST_WIDE_INT param_num
)
7491 /* Just skip checking the argument if it's not a pointer. This can
7492 happen if the "nonnull" attribute was given without an operand
7493 list (which means to check every pointer argument). */
7495 if (TREE_CODE (TREE_TYPE (param
)) != POINTER_TYPE
)
7498 if (integer_zerop (param
))
7499 warning (OPT_Wnonnull
, "null argument where non-null required "
7500 "(argument %lu)", (unsigned long) param_num
);
7503 /* Helper for nonnull attribute handling; fetch the operand number
7504 from the attribute argument list. */
7507 get_nonnull_operand (tree arg_num_expr
, unsigned HOST_WIDE_INT
*valp
)
7509 /* Verify the arg number is a constant. */
7510 if (TREE_CODE (arg_num_expr
) != INTEGER_CST
7511 || TREE_INT_CST_HIGH (arg_num_expr
) != 0)
7514 *valp
= TREE_INT_CST_LOW (arg_num_expr
);
7518 /* Handle a "nothrow" attribute; arguments as in
7519 struct attribute_spec.handler. */
7522 handle_nothrow_attribute (tree
*node
, tree name
, tree
ARG_UNUSED (args
),
7523 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7525 if (TREE_CODE (*node
) == FUNCTION_DECL
)
7526 TREE_NOTHROW (*node
) = 1;
7527 /* ??? TODO: Support types. */
7530 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7531 *no_add_attrs
= true;
7537 /* Handle a "cleanup" attribute; arguments as in
7538 struct attribute_spec.handler. */
7541 handle_cleanup_attribute (tree
*node
, tree name
, tree args
,
7542 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7545 tree cleanup_id
, cleanup_decl
;
7547 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7548 for global destructors in C++. This requires infrastructure that
7549 we don't have generically at the moment. It's also not a feature
7550 we'd be missing too much, since we do have attribute constructor. */
7551 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
7553 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7554 *no_add_attrs
= true;
7558 /* Verify that the argument is a function in scope. */
7559 /* ??? We could support pointers to functions here as well, if
7560 that was considered desirable. */
7561 cleanup_id
= TREE_VALUE (args
);
7562 if (TREE_CODE (cleanup_id
) != IDENTIFIER_NODE
)
7564 error ("cleanup argument not an identifier");
7565 *no_add_attrs
= true;
7568 cleanup_decl
= lookup_name (cleanup_id
);
7569 if (!cleanup_decl
|| TREE_CODE (cleanup_decl
) != FUNCTION_DECL
)
7571 error ("cleanup argument not a function");
7572 *no_add_attrs
= true;
7576 /* That the function has proper type is checked with the
7577 eventual call to build_function_call. */
7582 /* Handle a "warn_unused_result" attribute. No special handling. */
7585 handle_warn_unused_result_attribute (tree
*node
, tree name
,
7586 tree
ARG_UNUSED (args
),
7587 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7589 /* Ignore the attribute for functions not returning any value. */
7590 if (VOID_TYPE_P (TREE_TYPE (*node
)))
7592 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7593 *no_add_attrs
= true;
7599 /* Handle a "sentinel" attribute. */
7602 handle_sentinel_attribute (tree
*node
, tree name
, tree args
,
7603 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7605 tree params
= TYPE_ARG_TYPES (*node
);
7609 warning (OPT_Wattributes
,
7610 "%qE attribute requires prototypes with named arguments", name
);
7611 *no_add_attrs
= true;
7615 while (TREE_CHAIN (params
))
7616 params
= TREE_CHAIN (params
);
7618 if (VOID_TYPE_P (TREE_VALUE (params
)))
7620 warning (OPT_Wattributes
,
7621 "%qE attribute only applies to variadic functions", name
);
7622 *no_add_attrs
= true;
7628 tree position
= TREE_VALUE (args
);
7630 if (TREE_CODE (position
) != INTEGER_CST
)
7632 warning (OPT_Wattributes
,
7633 "requested position is not an integer constant");
7634 *no_add_attrs
= true;
7638 if (tree_int_cst_lt (position
, integer_zero_node
))
7640 warning (OPT_Wattributes
,
7641 "requested position is less than zero");
7642 *no_add_attrs
= true;
7650 /* Handle a "type_generic" attribute. */
7653 handle_type_generic_attribute (tree
*node
, tree
ARG_UNUSED (name
),
7654 tree
ARG_UNUSED (args
), int ARG_UNUSED (flags
),
7655 bool * ARG_UNUSED (no_add_attrs
))
7659 /* Ensure we have a function type. */
7660 gcc_assert (TREE_CODE (*node
) == FUNCTION_TYPE
);
7662 params
= TYPE_ARG_TYPES (*node
);
7663 while (params
&& ! VOID_TYPE_P (TREE_VALUE (params
)))
7664 params
= TREE_CHAIN (params
);
7666 /* Ensure we have a variadic function. */
7667 gcc_assert (!params
);
7672 /* Handle a "target" attribute. */
7675 handle_target_attribute (tree
*node
, tree name
, tree args
, int flags
,
7678 /* Ensure we have a function type. */
7679 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7681 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7682 *no_add_attrs
= true;
7684 else if (! targetm
.target_option
.valid_attribute_p (*node
, name
, args
,
7686 *no_add_attrs
= true;
7691 /* Arguments being collected for optimization. */
7692 typedef const char *const_char_p
; /* For DEF_VEC_P. */
7693 DEF_VEC_P(const_char_p
);
7694 DEF_VEC_ALLOC_P(const_char_p
, gc
);
7695 static GTY(()) VEC(const_char_p
, gc
) *optimize_args
;
7698 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7699 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7700 false for #pragma GCC optimize. */
7703 parse_optimize_options (tree args
, bool attr_p
)
7708 int saved_flag_strict_aliasing
;
7709 const char **opt_argv
;
7712 /* Build up argv vector. Just in case the string is stored away, use garbage
7713 collected strings. */
7714 VEC_truncate (const_char_p
, optimize_args
, 0);
7715 VEC_safe_push (const_char_p
, gc
, optimize_args
, NULL
);
7717 for (ap
= args
; ap
!= NULL_TREE
; ap
= TREE_CHAIN (ap
))
7719 tree value
= TREE_VALUE (ap
);
7721 if (TREE_CODE (value
) == INTEGER_CST
)
7724 sprintf (buffer
, "-O%ld", (long) TREE_INT_CST_LOW (value
));
7725 VEC_safe_push (const_char_p
, gc
, optimize_args
, ggc_strdup (buffer
));
7728 else if (TREE_CODE (value
) == STRING_CST
)
7730 /* Split string into multiple substrings. */
7731 size_t len
= TREE_STRING_LENGTH (value
);
7732 char *p
= ASTRDUP (TREE_STRING_POINTER (value
));
7733 char *end
= p
+ len
;
7737 while (next_p
!= NULL
)
7743 comma
= strchr (p
, ',');
7756 r
= q
= (char *) ggc_alloc (len2
+ 3);
7758 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7760 if (*p
== '-' && p
[1] != 'O' && p
[1] != 'f')
7764 warning (OPT_Wattributes
,
7765 "Bad option %s to optimize attribute.", p
);
7767 warning (OPT_Wpragmas
,
7768 "Bad option %s to pragma attribute", p
);
7776 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7777 itself is -Os, and any other switch begins with a -f. */
7778 if ((*p
>= '0' && *p
<= '9')
7779 || (p
[0] == 's' && p
[1] == '\0'))
7785 memcpy (r
, p
, len2
);
7787 VEC_safe_push (const_char_p
, gc
, optimize_args
, q
);
7793 opt_argc
= VEC_length (const_char_p
, optimize_args
);
7794 opt_argv
= (const char **) alloca (sizeof (char *) * (opt_argc
+ 1));
7796 for (i
= 1; i
< opt_argc
; i
++)
7797 opt_argv
[i
] = VEC_index (const_char_p
, optimize_args
, i
);
7799 saved_flag_strict_aliasing
= flag_strict_aliasing
;
7801 /* Now parse the options. */
7802 decode_options (opt_argc
, opt_argv
);
7804 /* Don't allow changing -fstrict-aliasing. */
7805 flag_strict_aliasing
= saved_flag_strict_aliasing
;
7807 VEC_truncate (const_char_p
, optimize_args
, 0);
7811 /* For handling "optimize" attribute. arguments as in
7812 struct attribute_spec.handler. */
7815 handle_optimize_attribute (tree
*node
, tree name
, tree args
,
7816 int ARG_UNUSED (flags
), bool *no_add_attrs
)
7818 /* Ensure we have a function type. */
7819 if (TREE_CODE (*node
) != FUNCTION_DECL
)
7821 warning (OPT_Wattributes
, "%qE attribute ignored", name
);
7822 *no_add_attrs
= true;
7826 struct cl_optimization cur_opts
;
7827 tree old_opts
= DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
);
7829 /* Save current options. */
7830 cl_optimization_save (&cur_opts
);
7832 /* If we previously had some optimization options, use them as the
7835 cl_optimization_restore (TREE_OPTIMIZATION (old_opts
));
7837 /* Parse options, and update the vector. */
7838 parse_optimize_options (args
, true);
7839 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node
)
7840 = build_optimization_node ();
7842 /* Restore current options. */
7843 cl_optimization_restore (&cur_opts
);
7849 /* Check for valid arguments being passed to a function.
7850 ATTRS is a list of attributes. There are NARGS arguments in the array
7851 ARGARRAY. TYPELIST is the list of argument types for the function.
7854 check_function_arguments (tree attrs
, int nargs
, tree
*argarray
, tree typelist
)
7856 /* Check for null being passed in a pointer argument that must be
7857 non-null. We also need to do this if format checking is enabled. */
7860 check_function_nonnull (attrs
, nargs
, argarray
);
7862 /* Check for errors in format strings. */
7864 if (warn_format
|| warn_missing_format_attribute
)
7865 check_function_format (attrs
, nargs
, argarray
);
7868 check_function_sentinel (attrs
, nargs
, argarray
, typelist
);
7871 /* Generic argument checking recursion routine. PARAM is the argument to
7872 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7873 once the argument is resolved. CTX is context for the callback. */
7875 check_function_arguments_recurse (void (*callback
)
7876 (void *, tree
, unsigned HOST_WIDE_INT
),
7877 void *ctx
, tree param
,
7878 unsigned HOST_WIDE_INT param_num
)
7880 if (CONVERT_EXPR_P (param
)
7881 && (TYPE_PRECISION (TREE_TYPE (param
))
7882 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param
, 0)))))
7884 /* Strip coercion. */
7885 check_function_arguments_recurse (callback
, ctx
,
7886 TREE_OPERAND (param
, 0), param_num
);
7890 if (TREE_CODE (param
) == CALL_EXPR
)
7892 tree type
= TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param
)));
7894 bool found_format_arg
= false;
7896 /* See if this is a call to a known internationalization function
7897 that modifies a format arg. Such a function may have multiple
7898 format_arg attributes (for example, ngettext). */
7900 for (attrs
= TYPE_ATTRIBUTES (type
);
7902 attrs
= TREE_CHAIN (attrs
))
7903 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs
)))
7906 tree format_num_expr
;
7909 call_expr_arg_iterator iter
;
7911 /* Extract the argument number, which was previously checked
7913 format_num_expr
= TREE_VALUE (TREE_VALUE (attrs
));
7915 gcc_assert (TREE_CODE (format_num_expr
) == INTEGER_CST
7916 && !TREE_INT_CST_HIGH (format_num_expr
));
7918 format_num
= TREE_INT_CST_LOW (format_num_expr
);
7920 for (inner_arg
= first_call_expr_arg (param
, &iter
), i
= 1;
7922 inner_arg
= next_call_expr_arg (&iter
), i
++)
7923 if (i
== format_num
)
7925 check_function_arguments_recurse (callback
, ctx
,
7926 inner_arg
, param_num
);
7927 found_format_arg
= true;
7932 /* If we found a format_arg attribute and did a recursive check,
7933 we are done with checking this argument. Otherwise, we continue
7934 and this will be considered a non-literal. */
7935 if (found_format_arg
)
7939 if (TREE_CODE (param
) == COND_EXPR
)
7941 /* Check both halves of the conditional expression. */
7942 check_function_arguments_recurse (callback
, ctx
,
7943 TREE_OPERAND (param
, 1), param_num
);
7944 check_function_arguments_recurse (callback
, ctx
,
7945 TREE_OPERAND (param
, 2), param_num
);
7949 (*callback
) (ctx
, param
, param_num
);
7952 /* Checks the number of arguments NARGS against the required number
7953 REQUIRED and issues an error if there is a mismatch. Returns true
7954 if the number of arguments is correct, otherwise false. */
7957 validate_nargs (tree fndecl
, int nargs
, int required
)
7959 if (nargs
< required
)
7961 error ("not enough arguments to function %qE", fndecl
);
7964 else if (nargs
> required
)
7966 error ("too many arguments to function %qE", fndecl
);
7972 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7973 Returns false if there was an error, otherwise true. */
7976 check_builtin_function_arguments (tree fndecl
, int nargs
, tree
*args
)
7978 if (!DECL_BUILT_IN (fndecl
)
7979 || DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
7982 switch (DECL_FUNCTION_CODE (fndecl
))
7984 case BUILT_IN_CONSTANT_P
:
7985 return validate_nargs (fndecl
, nargs
, 1);
7987 case BUILT_IN_ISFINITE
:
7988 case BUILT_IN_ISINF
:
7989 case BUILT_IN_ISINF_SIGN
:
7990 case BUILT_IN_ISNAN
:
7991 case BUILT_IN_ISNORMAL
:
7992 if (validate_nargs (fndecl
, nargs
, 1))
7994 if (TREE_CODE (TREE_TYPE (args
[0])) != REAL_TYPE
)
7996 error ("non-floating-point argument in call to "
7997 "function %qE", fndecl
);
8004 case BUILT_IN_ISGREATER
:
8005 case BUILT_IN_ISGREATEREQUAL
:
8006 case BUILT_IN_ISLESS
:
8007 case BUILT_IN_ISLESSEQUAL
:
8008 case BUILT_IN_ISLESSGREATER
:
8009 case BUILT_IN_ISUNORDERED
:
8010 if (validate_nargs (fndecl
, nargs
, 2))
8012 enum tree_code code0
, code1
;
8013 code0
= TREE_CODE (TREE_TYPE (args
[0]));
8014 code1
= TREE_CODE (TREE_TYPE (args
[1]));
8015 if (!((code0
== REAL_TYPE
&& code1
== REAL_TYPE
)
8016 || (code0
== REAL_TYPE
&& code1
== INTEGER_TYPE
)
8017 || (code0
== INTEGER_TYPE
&& code1
== REAL_TYPE
)))
8019 error ("non-floating-point arguments in call to "
8020 "function %qE", fndecl
);
8027 case BUILT_IN_FPCLASSIFY
:
8028 if (validate_nargs (fndecl
, nargs
, 6))
8033 if (TREE_CODE (args
[i
]) != INTEGER_CST
)
8035 error ("non-const integer argument %u in call to function %qE",
8040 if (TREE_CODE (TREE_TYPE (args
[5])) != REAL_TYPE
)
8042 error ("non-floating-point argument in call to function %qE",
8055 /* Function to help qsort sort FIELD_DECLs by name order. */
8058 field_decl_cmp (const void *x_p
, const void *y_p
)
8060 const tree
*const x
= (const tree
*const) x_p
;
8061 const tree
*const y
= (const tree
*const) y_p
;
8063 if (DECL_NAME (*x
) == DECL_NAME (*y
))
8064 /* A nontype is "greater" than a type. */
8065 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
8066 if (DECL_NAME (*x
) == NULL_TREE
)
8068 if (DECL_NAME (*y
) == NULL_TREE
)
8070 if (DECL_NAME (*x
) < DECL_NAME (*y
))
8076 gt_pointer_operator new_value
;
8080 /* This routine compares two fields like field_decl_cmp but using the
8081 pointer operator in resort_data. */
8084 resort_field_decl_cmp (const void *x_p
, const void *y_p
)
8086 const tree
*const x
= (const tree
*const) x_p
;
8087 const tree
*const y
= (const tree
*const) y_p
;
8089 if (DECL_NAME (*x
) == DECL_NAME (*y
))
8090 /* A nontype is "greater" than a type. */
8091 return (TREE_CODE (*y
) == TYPE_DECL
) - (TREE_CODE (*x
) == TYPE_DECL
);
8092 if (DECL_NAME (*x
) == NULL_TREE
)
8094 if (DECL_NAME (*y
) == NULL_TREE
)
8097 tree d1
= DECL_NAME (*x
);
8098 tree d2
= DECL_NAME (*y
);
8099 resort_data
.new_value (&d1
, resort_data
.cookie
);
8100 resort_data
.new_value (&d2
, resort_data
.cookie
);
8107 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8110 resort_sorted_fields (void *obj
,
8111 void * ARG_UNUSED (orig_obj
),
8112 gt_pointer_operator new_value
,
8115 struct sorted_fields_type
*sf
= (struct sorted_fields_type
*) obj
;
8116 resort_data
.new_value
= new_value
;
8117 resort_data
.cookie
= cookie
;
8118 qsort (&sf
->elts
[0], sf
->len
, sizeof (tree
),
8119 resort_field_decl_cmp
);
8122 /* Subroutine of c_parse_error.
8123 Return the result of concatenating LHS and RHS. RHS is really
8124 a string literal, its first character is indicated by RHS_START and
8125 RHS_SIZE is its length (including the terminating NUL character).
8127 The caller is responsible for deleting the returned pointer. */
8130 catenate_strings (const char *lhs
, const char *rhs_start
, int rhs_size
)
8132 const int lhs_size
= strlen (lhs
);
8133 char *result
= XNEWVEC (char, lhs_size
+ rhs_size
);
8134 strncpy (result
, lhs
, lhs_size
);
8135 strncpy (result
+ lhs_size
, rhs_start
, rhs_size
);
8139 /* Issue the error given by GMSGID, indicating that it occurred before
8140 TOKEN, which had the associated VALUE. */
8143 c_parse_error (const char *gmsgid
, enum cpp_ttype token_type
,
8144 tree value
, unsigned char token_flags
)
8146 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8148 char *message
= NULL
;
8150 if (token_type
== CPP_EOF
)
8151 message
= catenate_messages (gmsgid
, " at end of input");
8152 else if (token_type
== CPP_CHAR
8153 || token_type
== CPP_WCHAR
8154 || token_type
== CPP_CHAR16
8155 || token_type
== CPP_CHAR32
)
8157 unsigned int val
= TREE_INT_CST_LOW (value
);
8176 if (val
<= UCHAR_MAX
&& ISGRAPH (val
))
8177 message
= catenate_messages (gmsgid
, " before %s'%c'");
8179 message
= catenate_messages (gmsgid
, " before %s'\\x%x'");
8181 error (message
, prefix
, val
);
8185 else if (token_type
== CPP_STRING
8186 || token_type
== CPP_WSTRING
8187 || token_type
== CPP_STRING16
8188 || token_type
== CPP_STRING32
)
8189 message
= catenate_messages (gmsgid
, " before string constant");
8190 else if (token_type
== CPP_NUMBER
)
8191 message
= catenate_messages (gmsgid
, " before numeric constant");
8192 else if (token_type
== CPP_NAME
)
8194 message
= catenate_messages (gmsgid
, " before %qE");
8195 error (message
, value
);
8199 else if (token_type
== CPP_PRAGMA
)
8200 message
= catenate_messages (gmsgid
, " before %<#pragma%>");
8201 else if (token_type
== CPP_PRAGMA_EOL
)
8202 message
= catenate_messages (gmsgid
, " before end of line");
8203 else if (token_type
< N_TTYPES
)
8205 message
= catenate_messages (gmsgid
, " before %qs token");
8206 error (message
, cpp_type2name (token_type
, token_flags
));
8218 #undef catenate_messages
8221 /* Callback from cpp_error for PFILE to print diagnostics from the
8222 preprocessor. The diagnostic is of type LEVEL, at location
8223 LOCATION unless this is after lexing and the compiler's location
8224 should be used instead, with column number possibly overridden by
8225 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8226 the arguments. Returns true if a diagnostic was emitted, false
8230 c_cpp_error (cpp_reader
*pfile ATTRIBUTE_UNUSED
, int level
,
8231 location_t location
, unsigned int column_override
,
8232 const char *msg
, va_list *ap
)
8234 diagnostic_info diagnostic
;
8235 diagnostic_t dlevel
;
8236 int save_warn_system_headers
= warn_system_headers
;
8241 case CPP_DL_WARNING_SYSHDR
:
8244 warn_system_headers
= 1;
8246 case CPP_DL_WARNING
:
8249 dlevel
= DK_WARNING
;
8251 case CPP_DL_PEDWARN
:
8252 if (flag_no_output
&& !flag_pedantic_errors
)
8254 dlevel
= DK_PEDWARN
;
8272 location
= input_location
;
8273 diagnostic_set_info_translated (&diagnostic
, msg
, ap
,
8275 if (column_override
)
8276 diagnostic_override_column (&diagnostic
, column_override
);
8277 ret
= report_diagnostic (&diagnostic
);
8278 if (level
== CPP_DL_WARNING_SYSHDR
)
8279 warn_system_headers
= save_warn_system_headers
;
8283 /* Convert a character from the host to the target execution character
8284 set. cpplib handles this, mostly. */
8287 c_common_to_target_charset (HOST_WIDE_INT c
)
8289 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8290 zero-extended under -fno-signed-char. cpplib insists that characters
8291 and character constants are always unsigned. Hence we must convert
8293 cppchar_t uc
= ((cppchar_t
)c
) & ((((cppchar_t
)1) << CHAR_BIT
)-1);
8295 uc
= cpp_host_to_exec_charset (parse_in
, uc
);
8297 if (flag_signed_char
)
8298 return ((HOST_WIDE_INT
)uc
) << (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
)
8299 >> (HOST_BITS_PER_WIDE_INT
- CHAR_TYPE_SIZE
);
8304 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8305 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8306 NULL, at the bottom; much like the traditional rendering of offsetof as a
8307 macro. Returns the folded and properly cast result. */
8310 fold_offsetof_1 (tree expr
, tree stop_ref
)
8312 enum tree_code code
= PLUS_EXPR
;
8315 if (expr
== stop_ref
&& TREE_CODE (expr
) != ERROR_MARK
)
8316 return size_zero_node
;
8318 switch (TREE_CODE (expr
))
8324 error ("cannot apply %<offsetof%> to static data member %qD", expr
);
8325 return error_mark_node
;
8329 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8330 return error_mark_node
;
8333 gcc_assert (integer_zerop (expr
));
8334 return size_zero_node
;
8338 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8339 gcc_assert (base
== error_mark_node
|| base
== size_zero_node
);
8343 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8344 if (base
== error_mark_node
)
8347 t
= TREE_OPERAND (expr
, 1);
8348 if (DECL_C_BIT_FIELD (t
))
8350 error ("attempt to take address of bit-field structure "
8352 return error_mark_node
;
8354 off
= size_binop_loc (input_location
, PLUS_EXPR
, DECL_FIELD_OFFSET (t
),
8355 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t
),
8361 base
= fold_offsetof_1 (TREE_OPERAND (expr
, 0), stop_ref
);
8362 if (base
== error_mark_node
)
8365 t
= TREE_OPERAND (expr
, 1);
8366 if (TREE_CODE (t
) == INTEGER_CST
&& tree_int_cst_sgn (t
) < 0)
8369 t
= fold_build1_loc (input_location
, NEGATE_EXPR
, TREE_TYPE (t
), t
);
8371 t
= convert (sizetype
, t
);
8372 off
= size_binop (MULT_EXPR
, TYPE_SIZE_UNIT (TREE_TYPE (expr
)), t
);
8376 /* Handle static members of volatile structs. */
8377 t
= TREE_OPERAND (expr
, 1);
8378 gcc_assert (TREE_CODE (t
) == VAR_DECL
);
8379 return fold_offsetof_1 (t
, stop_ref
);
8385 return size_binop (code
, base
, off
);
8389 fold_offsetof (tree expr
, tree stop_ref
)
8391 /* Convert back from the internal sizetype to size_t. */
8392 return convert (size_type_node
, fold_offsetof_1 (expr
, stop_ref
));
8395 /* Print an error message for an invalid lvalue. USE says
8396 how the lvalue is being used and so selects the error message. */
8399 lvalue_error (enum lvalue_use use
)
8404 error ("lvalue required as left operand of assignment");
8407 error ("lvalue required as increment operand");
8410 error ("lvalue required as decrement operand");
8413 error ("lvalue required as unary %<&%> operand");
8416 error ("lvalue required in asm statement");
8423 /* *PTYPE is an incomplete array. Complete it with a domain based on
8424 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8425 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8426 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8429 complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
8431 tree maxindex
, type
, main_type
, elt
, unqual_elt
;
8432 int failure
= 0, quals
;
8433 hashval_t hashcode
= 0;
8435 maxindex
= size_zero_node
;
8438 if (TREE_CODE (initial_value
) == STRING_CST
)
8441 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8442 maxindex
= size_int (TREE_STRING_LENGTH (initial_value
)/eltsize
- 1);
8444 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8446 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
8448 if (VEC_empty (constructor_elt
, v
))
8452 maxindex
= integer_minus_one_node
;
8457 unsigned HOST_WIDE_INT cnt
;
8458 constructor_elt
*ce
;
8459 bool fold_p
= false;
8461 if (VEC_index (constructor_elt
, v
, 0)->index
)
8462 maxindex
= fold_convert_loc (input_location
, sizetype
,
8463 VEC_index (constructor_elt
,
8465 curindex
= maxindex
;
8468 VEC_iterate (constructor_elt
, v
, cnt
, ce
);
8471 bool curfold_p
= false;
8473 curindex
= ce
->index
, curfold_p
= true;
8477 curindex
= fold_convert (sizetype
, curindex
);
8478 curindex
= size_binop (PLUS_EXPR
, curindex
,
8481 if (tree_int_cst_lt (maxindex
, curindex
))
8482 maxindex
= curindex
, fold_p
= curfold_p
;
8485 maxindex
= fold_convert (sizetype
, maxindex
);
8490 /* Make an error message unless that happened already. */
8491 if (initial_value
!= error_mark_node
)
8503 elt
= TREE_TYPE (type
);
8504 quals
= TYPE_QUALS (strip_array_types (elt
));
8508 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
8510 /* Using build_distinct_type_copy and modifying things afterward instead
8511 of using build_array_type to create a new type preserves all of the
8512 TYPE_LANG_FLAG_? bits that the front end may have set. */
8513 main_type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
8514 TREE_TYPE (main_type
) = unqual_elt
;
8515 TYPE_DOMAIN (main_type
) = build_index_type (maxindex
);
8516 layout_type (main_type
);
8518 /* Make sure we have the canonical MAIN_TYPE. */
8519 hashcode
= iterative_hash_object (TYPE_HASH (unqual_elt
), hashcode
);
8520 hashcode
= iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type
)),
8522 main_type
= type_hash_canon (hashcode
, main_type
);
8524 /* Fix the canonical type. */
8525 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type
))
8526 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type
)))
8527 SET_TYPE_STRUCTURAL_EQUALITY (main_type
);
8528 else if (TYPE_CANONICAL (TREE_TYPE (main_type
)) != TREE_TYPE (main_type
)
8529 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type
))
8530 != TYPE_DOMAIN (main_type
)))
8531 TYPE_CANONICAL (main_type
)
8532 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type
)),
8533 TYPE_CANONICAL (TYPE_DOMAIN (main_type
)));
8535 TYPE_CANONICAL (main_type
) = main_type
;
8540 type
= c_build_qualified_type (main_type
, quals
);
8542 if (COMPLETE_TYPE_P (type
)
8543 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
8544 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
8546 error ("size of array is too large");
8547 /* If we proceed with the array type as it is, we'll eventually
8548 crash in tree_low_cst(). */
8549 type
= error_mark_node
;
8557 /* Used to help initialize the builtin-types.def table. When a type of
8558 the correct size doesn't exist, use error_mark_node instead of NULL.
8559 The later results in segfaults even when a decl using the type doesn't
8563 builtin_type_for_size (int size
, bool unsignedp
)
8565 tree type
= lang_hooks
.types
.type_for_size (size
, unsignedp
);
8566 return type
? type
: error_mark_node
;
8569 /* A helper function for resolve_overloaded_builtin in resolving the
8570 overloaded __sync_ builtins. Returns a positive power of 2 if the
8571 first operand of PARAMS is a pointer to a supported data type.
8572 Returns 0 if an error is encountered. */
8575 sync_resolve_size (tree function
, VEC(tree
,gc
) *params
)
8580 if (VEC_empty (tree
, params
))
8582 error ("too few arguments to function %qE", function
);
8586 type
= TREE_TYPE (VEC_index (tree
, params
, 0));
8587 if (TREE_CODE (type
) != POINTER_TYPE
)
8590 type
= TREE_TYPE (type
);
8591 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
8594 size
= tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
8595 if (size
== 1 || size
== 2 || size
== 4 || size
== 8 || size
== 16)
8599 error ("incompatible type for argument %d of %qE", 1, function
);
8603 /* A helper function for resolve_overloaded_builtin. Adds casts to
8604 PARAMS to make arguments match up with those of FUNCTION. Drops
8605 the variadic arguments at the end. Returns false if some error
8606 was encountered; true on success. */
8609 sync_resolve_params (tree orig_function
, tree function
, VEC(tree
, gc
) *params
)
8611 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
8614 unsigned int parmnum
;
8616 /* We've declared the implementation functions to use "volatile void *"
8617 as the pointer parameter, so we shouldn't get any complaints from the
8618 call to check_function_arguments what ever type the user used. */
8619 arg_types
= TREE_CHAIN (arg_types
);
8620 ptype
= TREE_TYPE (TREE_TYPE (VEC_index (tree
, params
, 0)));
8623 /* For the rest of the values, we need to cast these to FTYPE, so that we
8624 don't get warnings for passing pointer types, etc. */
8626 while (arg_types
!= void_list_node
)
8631 if (VEC_length (tree
, params
) <= parmnum
)
8633 error ("too few arguments to function %qE", orig_function
);
8637 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8638 so that we get warnings for anything that doesn't match the pointer
8639 type. This isn't portable across the C and C++ front ends atm. */
8640 val
= VEC_index (tree
, params
, parmnum
);
8641 val
= convert (ptype
, val
);
8642 val
= convert (TREE_VALUE (arg_types
), val
);
8643 VEC_replace (tree
, params
, parmnum
, val
);
8645 arg_types
= TREE_CHAIN (arg_types
);
8649 /* The definition of these primitives is variadic, with the remaining
8650 being "an optional list of variables protected by the memory barrier".
8651 No clue what that's supposed to mean, precisely, but we consider all
8652 call-clobbered variables to be protected so we're safe. */
8653 VEC_truncate (tree
, params
, parmnum
+ 1);
8658 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8659 RESULT to make it match the type of the first pointer argument in
8663 sync_resolve_return (tree first_param
, tree result
)
8665 tree ptype
= TREE_TYPE (TREE_TYPE (first_param
));
8666 ptype
= TYPE_MAIN_VARIANT (ptype
);
8667 return convert (ptype
, result
);
8670 /* Some builtin functions are placeholders for other expressions. This
8671 function should be called immediately after parsing the call expression
8672 before surrounding code has committed to the type of the expression.
8674 LOC is the location of the builtin call.
8676 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8677 PARAMS is the argument list for the call. The return value is non-null
8678 when expansion is complete, and null if normal processing should
8682 resolve_overloaded_builtin (location_t loc
, tree function
, VEC(tree
,gc
) *params
)
8684 enum built_in_function orig_code
= DECL_FUNCTION_CODE (function
);
8685 switch (DECL_BUILT_IN_CLASS (function
))
8687 case BUILT_IN_NORMAL
:
8690 if (targetm
.resolve_overloaded_builtin
)
8691 return targetm
.resolve_overloaded_builtin (loc
, function
, params
);
8698 /* Handle BUILT_IN_NORMAL here. */
8701 case BUILT_IN_FETCH_AND_ADD_N
:
8702 case BUILT_IN_FETCH_AND_SUB_N
:
8703 case BUILT_IN_FETCH_AND_OR_N
:
8704 case BUILT_IN_FETCH_AND_AND_N
:
8705 case BUILT_IN_FETCH_AND_XOR_N
:
8706 case BUILT_IN_FETCH_AND_NAND_N
:
8707 case BUILT_IN_ADD_AND_FETCH_N
:
8708 case BUILT_IN_SUB_AND_FETCH_N
:
8709 case BUILT_IN_OR_AND_FETCH_N
:
8710 case BUILT_IN_AND_AND_FETCH_N
:
8711 case BUILT_IN_XOR_AND_FETCH_N
:
8712 case BUILT_IN_NAND_AND_FETCH_N
:
8713 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N
:
8714 case BUILT_IN_VAL_COMPARE_AND_SWAP_N
:
8715 case BUILT_IN_LOCK_TEST_AND_SET_N
:
8716 case BUILT_IN_LOCK_RELEASE_N
:
8718 int n
= sync_resolve_size (function
, params
);
8719 tree new_function
, first_param
, result
;
8722 return error_mark_node
;
8724 new_function
= built_in_decls
[orig_code
+ exact_log2 (n
) + 1];
8725 if (!sync_resolve_params (function
, new_function
, params
))
8726 return error_mark_node
;
8728 first_param
= VEC_index (tree
, params
, 0);
8729 result
= build_function_call_vec (loc
, new_function
, params
, NULL
);
8730 if (orig_code
!= BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8731 && orig_code
!= BUILT_IN_LOCK_RELEASE_N
)
8732 result
= sync_resolve_return (first_param
, result
);
8742 /* Ignoring their sign, return true if two scalar types are the same. */
8744 same_scalar_type_ignoring_signedness (tree t1
, tree t2
)
8746 enum tree_code c1
= TREE_CODE (t1
), c2
= TREE_CODE (t2
);
8748 gcc_assert ((c1
== INTEGER_TYPE
|| c1
== REAL_TYPE
|| c1
== FIXED_POINT_TYPE
)
8749 && (c2
== INTEGER_TYPE
|| c2
== REAL_TYPE
8750 || c2
== FIXED_POINT_TYPE
));
8752 /* Equality works here because c_common_signed_type uses
8753 TYPE_MAIN_VARIANT. */
8754 return c_common_signed_type (t1
)
8755 == c_common_signed_type (t2
);
8758 /* Check for missing format attributes on function pointers. LTYPE is
8759 the new type or left-hand side type. RTYPE is the old type or
8760 right-hand side type. Returns TRUE if LTYPE is missing the desired
8764 check_missing_format_attribute (tree ltype
, tree rtype
)
8766 tree
const ttr
= TREE_TYPE (rtype
), ttl
= TREE_TYPE (ltype
);
8769 for (ra
= TYPE_ATTRIBUTES (ttr
); ra
; ra
= TREE_CHAIN (ra
))
8770 if (is_attribute_p ("format", TREE_PURPOSE (ra
)))
8775 for (la
= TYPE_ATTRIBUTES (ttl
); la
; la
= TREE_CHAIN (la
))
8776 if (is_attribute_p ("format", TREE_PURPOSE (la
)))
8784 /* Subscripting with type char is likely to lose on a machine where
8785 chars are signed. So warn on any machine, but optionally. Don't
8786 warn for unsigned char since that type is safe. Don't warn for
8787 signed char because anyone who uses that must have done so
8788 deliberately. Furthermore, we reduce the false positive load by
8789 warning only for non-constant value of type char. */
8792 warn_array_subscript_with_type_char (tree index
)
8794 if (TYPE_MAIN_VARIANT (TREE_TYPE (index
)) == char_type_node
8795 && TREE_CODE (index
) != INTEGER_CST
)
8796 warning (OPT_Wchar_subscripts
, "array subscript has type %<char%>");
8799 /* Implement -Wparentheses for the unexpected C precedence rules, to
8800 cover cases like x + y << z which readers are likely to
8801 misinterpret. We have seen an expression in which CODE is a binary
8802 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8803 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8804 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8805 expression was not formed using a binary or unary operator, or it
8806 was enclosed in parentheses. */
8809 warn_about_parentheses (enum tree_code code
,
8810 enum tree_code code_left
, tree arg_left
,
8811 enum tree_code code_right
, tree arg_right
)
8813 if (!warn_parentheses
)
8816 /* This macro tests that the expression ARG with original tree code
8817 CODE appears to be a boolean expression. or the result of folding a
8818 boolean expression. */
8819 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8820 (truth_value_p (TREE_CODE (ARG)) \
8821 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8822 /* Folding may create 0 or 1 integers from other expressions. */ \
8823 || ((CODE) != INTEGER_CST \
8824 && (integer_onep (ARG) || integer_zerop (ARG))))
8829 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8830 warning (OPT_Wparentheses
,
8831 "suggest parentheses around %<+%> inside %<<<%>");
8832 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8833 warning (OPT_Wparentheses
,
8834 "suggest parentheses around %<-%> inside %<<<%>");
8838 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8839 warning (OPT_Wparentheses
,
8840 "suggest parentheses around %<+%> inside %<>>%>");
8841 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8842 warning (OPT_Wparentheses
,
8843 "suggest parentheses around %<-%> inside %<>>%>");
8846 case TRUTH_ORIF_EXPR
:
8847 if (code_left
== TRUTH_ANDIF_EXPR
|| code_right
== TRUTH_ANDIF_EXPR
)
8848 warning (OPT_Wparentheses
,
8849 "suggest parentheses around %<&&%> within %<||%>");
8853 if (code_left
== BIT_AND_EXPR
|| code_left
== BIT_XOR_EXPR
8854 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8855 || code_right
== BIT_AND_EXPR
|| code_right
== BIT_XOR_EXPR
8856 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8857 warning (OPT_Wparentheses
,
8858 "suggest parentheses around arithmetic in operand of %<|%>");
8859 /* Check cases like x|y==z */
8860 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8861 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8862 warning (OPT_Wparentheses
,
8863 "suggest parentheses around comparison in operand of %<|%>");
8864 /* Check cases like !x | y */
8865 else if (code_left
== TRUTH_NOT_EXPR
8866 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
8867 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
8868 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8872 if (code_left
== BIT_AND_EXPR
8873 || code_left
== PLUS_EXPR
|| code_left
== MINUS_EXPR
8874 || code_right
== BIT_AND_EXPR
8875 || code_right
== PLUS_EXPR
|| code_right
== MINUS_EXPR
)
8876 warning (OPT_Wparentheses
,
8877 "suggest parentheses around arithmetic in operand of %<^%>");
8878 /* Check cases like x^y==z */
8879 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8880 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8881 warning (OPT_Wparentheses
,
8882 "suggest parentheses around comparison in operand of %<^%>");
8886 if (code_left
== PLUS_EXPR
|| code_right
== PLUS_EXPR
)
8887 warning (OPT_Wparentheses
,
8888 "suggest parentheses around %<+%> in operand of %<&%>");
8889 else if (code_left
== MINUS_EXPR
|| code_right
== MINUS_EXPR
)
8890 warning (OPT_Wparentheses
,
8891 "suggest parentheses around %<-%> in operand of %<&%>");
8892 /* Check cases like x&y==z */
8893 else if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8894 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8895 warning (OPT_Wparentheses
,
8896 "suggest parentheses around comparison in operand of %<&%>");
8897 /* Check cases like !x & y */
8898 else if (code_left
== TRUTH_NOT_EXPR
8899 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right
, arg_right
))
8900 warning (OPT_Wparentheses
, "suggest parentheses around operand of "
8901 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8905 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8906 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8907 warning (OPT_Wparentheses
,
8908 "suggest parentheses around comparison in operand of %<==%>");
8911 if (TREE_CODE_CLASS (code_left
) == tcc_comparison
8912 || TREE_CODE_CLASS (code_right
) == tcc_comparison
)
8913 warning (OPT_Wparentheses
,
8914 "suggest parentheses around comparison in operand of %<!=%>");
8918 if (TREE_CODE_CLASS (code
) == tcc_comparison
8919 && ((TREE_CODE_CLASS (code_left
) == tcc_comparison
8920 && code_left
!= NE_EXPR
&& code_left
!= EQ_EXPR
8921 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left
)))
8922 || (TREE_CODE_CLASS (code_right
) == tcc_comparison
8923 && code_right
!= NE_EXPR
&& code_right
!= EQ_EXPR
8924 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right
)))))
8925 warning (OPT_Wparentheses
, "comparisons like %<X<=Y<=Z%> do not "
8926 "have their mathematical meaning");
8929 #undef NOT_A_BOOLEAN_EXPR_P
8932 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8935 warn_for_unused_label (tree label
)
8937 if (!TREE_USED (label
))
8939 if (DECL_INITIAL (label
))
8940 warning (OPT_Wunused_label
, "label %q+D defined but not used", label
);
8942 warning (OPT_Wunused_label
, "label %q+D declared but not defined", label
);
8946 #ifndef TARGET_HAS_TARGETCM
8947 struct gcc_targetcm targetcm
= TARGETCM_INITIALIZER
;
8950 /* Warn for division by zero according to the value of DIVISOR. LOC
8951 is the location of the division operator. */
8954 warn_for_div_by_zero (location_t loc
, tree divisor
)
8956 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8957 about division by zero. Do not issue a warning if DIVISOR has a
8958 floating-point type, since we consider 0.0/0.0 a valid way of
8959 generating a NaN. */
8960 if (c_inhibit_evaluation_warnings
== 0
8961 && (integer_zerop (divisor
) || fixed_zerop (divisor
)))
8962 warning_at (loc
, OPT_Wdiv_by_zero
, "division by zero");
8965 /* Subroutine of build_binary_op. Give warnings for comparisons
8966 between signed and unsigned quantities that may fail. Do the
8967 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8968 so that casts will be considered, but default promotions won't
8971 LOCATION is the location of the comparison operator.
8973 The arguments of this function map directly to local variables
8974 of build_binary_op. */
8977 warn_for_sign_compare (location_t location
,
8978 tree orig_op0
, tree orig_op1
,
8980 tree result_type
, enum tree_code resultcode
)
8982 int op0_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op0
));
8983 int op1_signed
= !TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
8984 int unsignedp0
, unsignedp1
;
8986 /* In C++, check for comparison of different enum types. */
8988 && TREE_CODE (TREE_TYPE (orig_op0
)) == ENUMERAL_TYPE
8989 && TREE_CODE (TREE_TYPE (orig_op1
)) == ENUMERAL_TYPE
8990 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0
))
8991 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1
)))
8993 warning_at (location
,
8994 OPT_Wsign_compare
, "comparison between types %qT and %qT",
8995 TREE_TYPE (orig_op0
), TREE_TYPE (orig_op1
));
8998 /* Do not warn if the comparison is being done in a signed type,
8999 since the signed type will only be chosen if it can represent
9000 all the values of the unsigned type. */
9001 if (!TYPE_UNSIGNED (result_type
))
9003 /* Do not warn if both operands are unsigned. */
9004 else if (op0_signed
== op1_signed
)
9008 tree sop
, uop
, base_type
;
9012 sop
= orig_op0
, uop
= orig_op1
;
9014 sop
= orig_op1
, uop
= orig_op0
;
9016 STRIP_TYPE_NOPS (sop
);
9017 STRIP_TYPE_NOPS (uop
);
9018 base_type
= (TREE_CODE (result_type
) == COMPLEX_TYPE
9019 ? TREE_TYPE (result_type
) : result_type
);
9021 /* Do not warn if the signed quantity is an unsuffixed integer
9022 literal (or some static constant expression involving such
9023 literals or a conditional expression involving such literals)
9024 and it is non-negative. */
9025 if (tree_expr_nonnegative_warnv_p (sop
, &ovf
))
9027 /* Do not warn if the comparison is an equality operation, the
9028 unsigned quantity is an integral constant, and it would fit
9029 in the result if the result were signed. */
9030 else if (TREE_CODE (uop
) == INTEGER_CST
9031 && (resultcode
== EQ_EXPR
|| resultcode
== NE_EXPR
)
9032 && int_fits_type_p (uop
, c_common_signed_type (base_type
)))
9034 /* In C, do not warn if the unsigned quantity is an enumeration
9035 constant and its maximum value would fit in the result if the
9036 result were signed. */
9037 else if (!c_dialect_cxx() && TREE_CODE (uop
) == INTEGER_CST
9038 && TREE_CODE (TREE_TYPE (uop
)) == ENUMERAL_TYPE
9039 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop
)),
9040 c_common_signed_type (base_type
)))
9043 warning_at (location
,
9045 "comparison between signed and unsigned integer expressions");
9048 /* Warn if two unsigned values are being compared in a size larger
9049 than their original size, and one (and only one) is the result of
9050 a `~' operator. This comparison will always fail.
9052 Also warn if one operand is a constant, and the constant does not
9053 have all bits set that are set in the ~ operand when it is
9056 op0
= get_narrower (op0
, &unsignedp0
);
9057 op1
= get_narrower (op1
, &unsignedp1
);
9059 if ((TREE_CODE (op0
) == BIT_NOT_EXPR
)
9060 ^ (TREE_CODE (op1
) == BIT_NOT_EXPR
))
9062 if (TREE_CODE (op0
) == BIT_NOT_EXPR
)
9063 op0
= get_narrower (TREE_OPERAND (op0
, 0), &unsignedp0
);
9064 if (TREE_CODE (op1
) == BIT_NOT_EXPR
)
9065 op1
= get_narrower (TREE_OPERAND (op1
, 0), &unsignedp1
);
9067 if (host_integerp (op0
, 0) || host_integerp (op1
, 0))
9070 HOST_WIDE_INT constant
, mask
;
9074 if (host_integerp (op0
, 0))
9077 unsignedp
= unsignedp1
;
9078 constant
= tree_low_cst (op0
, 0);
9083 unsignedp
= unsignedp0
;
9084 constant
= tree_low_cst (op1
, 0);
9087 bits
= TYPE_PRECISION (TREE_TYPE (primop
));
9088 if (bits
< TYPE_PRECISION (result_type
)
9089 && bits
< HOST_BITS_PER_LONG
&& unsignedp
)
9091 mask
= (~ (HOST_WIDE_INT
) 0) << bits
;
9092 if ((mask
& constant
) != mask
)
9095 warning (OPT_Wsign_compare
,
9096 "promoted ~unsigned is always non-zero");
9098 warning_at (location
, OPT_Wsign_compare
,
9099 "comparison of promoted ~unsigned with constant");
9103 else if (unsignedp0
&& unsignedp1
9104 && (TYPE_PRECISION (TREE_TYPE (op0
))
9105 < TYPE_PRECISION (result_type
))
9106 && (TYPE_PRECISION (TREE_TYPE (op1
))
9107 < TYPE_PRECISION (result_type
)))
9108 warning_at (location
, OPT_Wsign_compare
,
9109 "comparison of promoted ~unsigned with unsigned");
9113 /* Setup a TYPE_DECL node as a typedef representation.
9115 X is a TYPE_DECL for a typedef statement. Create a brand new
9116 ..._TYPE node (which will be just a variant of the existing
9117 ..._TYPE node with identical properties) and then install X
9118 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9120 The whole point here is to end up with a situation where each
9121 and every ..._TYPE node the compiler creates will be uniquely
9122 associated with AT MOST one node representing a typedef name.
9123 This way, even though the compiler substitutes corresponding
9124 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9125 early on, later parts of the compiler can always do the reverse
9126 translation and get back the corresponding typedef name. For
9129 typedef struct S MY_TYPE;
9132 Later parts of the compiler might only know that `object' was of
9133 type `struct S' if it were not for code just below. With this
9134 code however, later parts of the compiler see something like:
9136 struct S' == struct S
9137 typedef struct S' MY_TYPE;
9140 And they can then deduce (from the node for type struct S') that
9141 the original object declaration was:
9145 Being able to do this is important for proper support of protoize,
9146 and also for generating precise symbolic debugging information
9147 which takes full account of the programmer's (typedef) vocabulary.
9149 Obviously, we don't want to generate a duplicate ..._TYPE node if
9150 the TYPE_DECL node that we are now processing really represents a
9151 standard built-in type. */
9154 set_underlying_type (tree x
)
9156 if (x
== error_mark_node
)
9158 if (DECL_IS_BUILTIN (x
))
9160 if (TYPE_NAME (TREE_TYPE (x
)) == 0)
9161 TYPE_NAME (TREE_TYPE (x
)) = x
;
9163 else if (TREE_TYPE (x
) != error_mark_node
9164 && DECL_ORIGINAL_TYPE (x
) == NULL_TREE
)
9166 tree tt
= TREE_TYPE (x
);
9167 DECL_ORIGINAL_TYPE (x
) = tt
;
9168 tt
= build_variant_type_copy (tt
);
9169 TYPE_STUB_DECL (tt
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
9171 TREE_USED (tt
) = TREE_USED (x
);
9176 /* Returns true if X is a typedef decl. */
9179 is_typedef_decl (tree x
)
9181 return (x
&& TREE_CODE (x
) == TYPE_DECL
9182 && DECL_ORIGINAL_TYPE (x
) != NULL_TREE
);
9185 /* The C and C++ parsers both use vectors to hold function arguments.
9186 For efficiency, we keep a cache of unused vectors. This is the
9189 typedef VEC(tree
,gc
)* tree_gc_vec
;
9190 DEF_VEC_P(tree_gc_vec
);
9191 DEF_VEC_ALLOC_P(tree_gc_vec
,gc
);
9192 static GTY((deletable
)) VEC(tree_gc_vec
,gc
) *tree_vector_cache
;
9194 /* Return a new vector from the cache. If the cache is empty,
9195 allocate a new vector. These vectors are GC'ed, so it is OK if the
9196 pointer is not released.. */
9199 make_tree_vector (void)
9201 if (!VEC_empty (tree_gc_vec
, tree_vector_cache
))
9202 return VEC_pop (tree_gc_vec
, tree_vector_cache
);
9205 /* Passing 0 to VEC_alloc returns NULL, and our callers require
9206 that we always return a non-NULL value. The vector code uses
9207 4 when growing a NULL vector, so we do too. */
9208 return VEC_alloc (tree
, gc
, 4);
9212 /* Release a vector of trees back to the cache. */
9215 release_tree_vector (VEC(tree
,gc
) *vec
)
9219 VEC_truncate (tree
, vec
, 0);
9220 VEC_safe_push (tree_gc_vec
, gc
, tree_vector_cache
, vec
);
9224 /* Get a new tree vector holding a single tree. */
9227 make_tree_vector_single (tree t
)
9229 VEC(tree
,gc
) *ret
= make_tree_vector ();
9230 VEC_quick_push (tree
, ret
, t
);
9234 /* Get a new tree vector which is a copy of an existing one. */
9237 make_tree_vector_copy (const VEC(tree
,gc
) *orig
)
9243 ret
= make_tree_vector ();
9244 VEC_reserve (tree
, gc
, ret
, VEC_length (tree
, orig
));
9245 for (ix
= 0; VEC_iterate (tree
, orig
, ix
, t
); ++ix
)
9246 VEC_quick_push (tree
, ret
, t
);
9250 #include "gt-c-common.h"