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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
51 #include "target-def.h"
53 cpp_reader *parse_in; /* Declared in c-pragma.h. */
55 /* We let tm.h override the types used here, to handle trivial differences
56 such as the choice of unsigned int or long unsigned int for size_t.
57 When machines start needing nontrivial differences in the size type,
58 it would be best to do something here to figure out automatically
59 from other information what type to use. */
62 #define SIZE_TYPE "long unsigned int"
66 #define PID_TYPE "int"
70 #define WCHAR_TYPE "int"
73 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
74 #define MODIFIED_WCHAR_TYPE \
75 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
78 #define PTRDIFF_TYPE "long int"
82 #define WINT_TYPE "unsigned int"
86 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
88 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
94 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
96 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
97 ? "long unsigned int" \
98 : "long long unsigned int"))
101 /* The following symbols are subsumed in the c_global_trees array, and
102 listed here individually for documentation purposes.
104 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
106 tree short_integer_type_node;
107 tree long_integer_type_node;
108 tree long_long_integer_type_node;
110 tree short_unsigned_type_node;
111 tree long_unsigned_type_node;
112 tree long_long_unsigned_type_node;
114 tree truthvalue_type_node;
115 tree truthvalue_false_node;
116 tree truthvalue_true_node;
118 tree ptrdiff_type_node;
120 tree unsigned_char_type_node;
121 tree signed_char_type_node;
122 tree wchar_type_node;
123 tree signed_wchar_type_node;
124 tree unsigned_wchar_type_node;
126 tree float_type_node;
127 tree double_type_node;
128 tree long_double_type_node;
130 tree complex_integer_type_node;
131 tree complex_float_type_node;
132 tree complex_double_type_node;
133 tree complex_long_double_type_node;
135 tree dfloat32_type_node;
136 tree dfloat64_type_node;
137 tree_dfloat128_type_node;
139 tree intQI_type_node;
140 tree intHI_type_node;
141 tree intSI_type_node;
142 tree intDI_type_node;
143 tree intTI_type_node;
145 tree unsigned_intQI_type_node;
146 tree unsigned_intHI_type_node;
147 tree unsigned_intSI_type_node;
148 tree unsigned_intDI_type_node;
149 tree unsigned_intTI_type_node;
151 tree widest_integer_literal_type_node;
152 tree widest_unsigned_literal_type_node;
154 Nodes for types `void *' and `const void *'.
156 tree ptr_type_node, const_ptr_type_node;
158 Nodes for types `char *' and `const char *'.
160 tree string_type_node, const_string_type_node;
162 Type `char[SOMENUMBER]'.
163 Used when an array of char is needed and the size is irrelevant.
165 tree char_array_type_node;
167 Type `int[SOMENUMBER]' or something like it.
168 Used when an array of int needed and the size is irrelevant.
170 tree int_array_type_node;
172 Type `wchar_t[SOMENUMBER]' or something like it.
173 Used when a wide string literal is created.
175 tree wchar_array_type_node;
177 Type `int ()' -- used for implicit declaration of functions.
179 tree default_function_type;
181 A VOID_TYPE node, packaged in a TREE_LIST.
185 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
186 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
187 VAR_DECLS, but C++ does.)
189 tree function_name_decl_node;
190 tree pretty_function_name_decl_node;
191 tree c99_function_name_decl_node;
193 Stack of nested function name VAR_DECLs.
195 tree saved_function_name_decls;
199 tree c_global_trees[CTI_MAX];
201 /* Switches common to the C front ends. */
203 /* Nonzero if prepreprocessing only. */
205 int flag_preprocess_only;
207 /* Nonzero means don't output line number information. */
209 char flag_no_line_commands;
211 /* Nonzero causes -E output not to be done, but directives such as
212 #define that have side effects are still obeyed. */
216 /* Nonzero means dump macros in some fashion. */
218 char flag_dump_macros;
220 /* Nonzero means pass #include lines through to the output. */
222 char flag_dump_includes;
224 /* Nonzero means process PCH files while preprocessing. */
226 bool flag_pch_preprocess;
228 /* The file name to which we should write a precompiled header, or
229 NULL if no header will be written in this compile. */
231 const char *pch_file;
233 /* Nonzero if an ISO standard was selected. It rejects macros in the
237 /* Nonzero if -undef was given. It suppresses target built-in macros
241 /* Nonzero means don't recognize the non-ANSI builtin functions. */
245 /* Nonzero means don't recognize the non-ANSI builtin functions.
248 int flag_no_nonansi_builtin;
250 /* Nonzero means give `double' the same size as `float'. */
252 int flag_short_double;
254 /* Nonzero means give `wchar_t' the same size as `short'. */
256 int flag_short_wchar;
258 /* Nonzero means allow implicit conversions between vectors with
259 differing numbers of subparts and/or differing element types. */
260 int flag_lax_vector_conversions;
262 /* Nonzero means allow Microsoft extensions without warnings or errors. */
263 int flag_ms_extensions;
265 /* Nonzero means don't recognize the keyword `asm'. */
269 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
271 int flag_signed_bitfields = 1;
273 /* Warn about #pragma directives that are not recognized. */
275 int warn_unknown_pragmas; /* Tri state variable. */
277 /* Warn about format/argument anomalies in calls to formatted I/O functions
278 (*printf, *scanf, strftime, strfmon, etc.). */
282 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
283 with GCC this doesn't matter as __null is guaranteed to have the right
286 int warn_strict_null_sentinel;
288 /* Zero means that faster, ...NonNil variants of objc_msgSend...
289 calls will be used in ObjC; passing nil receivers to such calls
290 will most likely result in crashes. */
291 int flag_nil_receivers = 1;
293 /* Nonzero means that code generation will be altered to support
294 "zero-link" execution. This currently affects ObjC only, but may
295 affect other languages in the future. */
296 int flag_zero_link = 0;
298 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
299 unit. It will inform the ObjC runtime that class definition(s) herein
300 contained are to replace one(s) previously loaded. */
301 int flag_replace_objc_classes = 0;
303 /* C/ObjC language option variables. */
306 /* Nonzero means allow type mismatches in conditional expressions;
307 just make their values `void'. */
309 int flag_cond_mismatch;
311 /* Nonzero means enable C89 Amendment 1 features. */
315 /* Nonzero means use the ISO C99 dialect of C. */
319 /* Nonzero means that we have builtin functions, and main is an int. */
323 /* Warn if main is suspicious. */
328 /* ObjC language option variables. */
331 /* Open and close the file for outputting class declarations, if
334 int flag_gen_declaration;
336 /* Tells the compiler that this is a special run. Do not perform any
337 compiling, instead we are to test some platform dependent features
338 and output a C header file with appropriate definitions. */
340 int print_struct_values;
342 /* Tells the compiler what is the constant string class for Objc. */
344 const char *constant_string_class_name;
347 /* C++ language option variables. */
350 /* Nonzero means don't recognize any extension keywords. */
352 int flag_no_gnu_keywords;
354 /* Nonzero means do emit exported implementations of functions even if
355 they can be inlined. */
357 int flag_implement_inlines = 1;
359 /* Nonzero means that implicit instantiations will be emitted if needed. */
361 int flag_implicit_templates = 1;
363 /* Nonzero means that implicit instantiations of inline templates will be
364 emitted if needed, even if instantiations of non-inline templates
367 int flag_implicit_inline_templates = 1;
369 /* Nonzero means generate separate instantiation control files and
370 juggle them at link time. */
372 int flag_use_repository;
374 /* Nonzero if we want to issue diagnostics that the standard says are not
377 int flag_optional_diags = 1;
379 /* Nonzero means we should attempt to elide constructors when possible. */
381 int flag_elide_constructors = 1;
383 /* Nonzero means that member functions defined in class scope are
384 inline by default. */
386 int flag_default_inline = 1;
388 /* Controls whether compiler generates 'type descriptor' that give
389 run-time type information. */
393 /* Nonzero if we want to conserve space in the .o files. We do this
394 by putting uninitialized data and runtime initialized data into
395 .common instead of .data at the expense of not flagging multiple
398 int flag_conserve_space;
400 /* Nonzero if we want to obey access control semantics. */
402 int flag_access_control = 1;
404 /* Nonzero if we want to check the return value of new and avoid calling
405 constructors if it is a null pointer. */
409 /* The C++ dialect being used. C++98 is the default. */
411 enum cxx_dialect cxx_dialect = cxx98;
413 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
414 initialization variables.
415 0: Old rules, set by -fno-for-scope.
416 2: New ISO rules, set by -ffor-scope.
417 1: Try to implement new ISO rules, but with backup compatibility
418 (and warnings). This is the default, for now. */
420 int flag_new_for_scope = 1;
422 /* Nonzero if we want to emit defined symbols with common-like linkage as
423 weak symbols where possible, in order to conform to C++ semantics.
424 Otherwise, emit them as local symbols. */
428 /* 0 means we want the preprocessor to not emit line directives for
429 the current working directory. 1 means we want it to do it. -1
430 means we should decide depending on whether debugging information
431 is being emitted or not. */
433 int flag_working_directory = -1;
435 /* Nonzero to use __cxa_atexit, rather than atexit, to register
436 destructors for local statics and global objects. '2' means it has been
437 set nonzero as a default, not by a command-line flag. */
439 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
441 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
442 code. '2' means it has not been set explicitly on the command line. */
444 int flag_use_cxa_get_exception_ptr = 2;
446 /* Nonzero means make the default pedwarns warnings instead of errors.
447 The value of this flag is ignored if -pedantic is specified. */
451 /* Nonzero means to implement standard semantics for exception
452 specifications, calling unexpected if an exception is thrown that
453 doesn't match the specification. Zero means to treat them as
454 assertions and optimize accordingly, but not check them. */
456 int flag_enforce_eh_specs = 1;
458 /* Nonzero means to generate thread-safe code for initializing local
461 int flag_threadsafe_statics = 1;
463 /* Nonzero means warn about implicit declarations. */
465 int warn_implicit = 1;
467 /* Maximum template instantiation depth. This limit is rather
468 arbitrary, but it exists to limit the time it takes to notice
469 infinite template instantiations. */
471 int max_tinst_depth = 500;
475 /* The elements of `ridpointers' are identifier nodes for the reserved
476 type names and storage classes. It is indexed by a RID_... value. */
479 tree (*make_fname_decl) (tree, int);
481 /* Nonzero means the expression being parsed will never be evaluated.
482 This is a count, since unevaluated expressions can nest. */
485 /* Information about how a function name is generated. */
488 tree *const decl; /* pointer to the VAR_DECL. */
489 const unsigned rid; /* RID number for the identifier. */
490 const int pretty; /* How pretty is it? */
493 /* The three ways of getting then name of the current function. */
495 const struct fname_var_t fname_vars[] =
497 /* C99 compliant __func__, must be first. */
498 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
499 /* GCC __FUNCTION__ compliant. */
500 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
501 /* GCC __PRETTY_FUNCTION__ compliant. */
502 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
506 static tree check_case_value (tree);
507 static bool check_case_bounds (tree, tree, tree *, tree *);
509 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
510 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
511 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
512 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
513 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
514 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
515 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
516 static tree handle_always_inline_attribute (tree *, tree, tree, int,
518 static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
520 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
521 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
522 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
523 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
525 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_transparent_union_attribute (tree *, tree, tree,
528 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
532 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
533 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
534 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
535 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
536 static tree handle_visibility_attribute (tree *, tree, tree, int,
538 static tree handle_tls_model_attribute (tree *, tree, tree, int,
540 static tree handle_no_instrument_function_attribute (tree *, tree,
542 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
543 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
544 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
546 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
547 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
548 static tree handle_deprecated_attribute (tree *, tree, tree, int,
550 static tree handle_vector_size_attribute (tree *, tree, tree, int,
552 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
553 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
554 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
555 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
557 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
558 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
559 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
561 static void check_function_nonnull (tree, int, tree *);
562 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
563 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
564 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
565 static int resort_field_decl_cmp (const void *, const void *);
567 /* Table of machine-independent attributes common to all C-like languages. */
568 const struct attribute_spec c_common_attribute_table[] =
570 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
571 { "packed", 0, 0, false, false, false,
572 handle_packed_attribute },
573 { "nocommon", 0, 0, true, false, false,
574 handle_nocommon_attribute },
575 { "common", 0, 0, true, false, false,
576 handle_common_attribute },
577 /* FIXME: logically, noreturn attributes should be listed as
578 "false, true, true" and apply to function types. But implementing this
579 would require all the places in the compiler that use TREE_THIS_VOLATILE
580 on a decl to identify non-returning functions to be located and fixed
581 to check the function type instead. */
582 { "noreturn", 0, 0, true, false, false,
583 handle_noreturn_attribute },
584 { "volatile", 0, 0, true, false, false,
585 handle_noreturn_attribute },
586 { "noinline", 0, 0, true, false, false,
587 handle_noinline_attribute },
588 { "always_inline", 0, 0, true, false, false,
589 handle_always_inline_attribute },
590 { "gnu_inline", 0, 0, true, false, false,
591 handle_gnu_inline_attribute },
592 { "flatten", 0, 0, true, false, false,
593 handle_flatten_attribute },
594 { "used", 0, 0, true, false, false,
595 handle_used_attribute },
596 { "unused", 0, 0, false, false, false,
597 handle_unused_attribute },
598 { "externally_visible", 0, 0, true, false, false,
599 handle_externally_visible_attribute },
600 /* The same comments as for noreturn attributes apply to const ones. */
601 { "const", 0, 0, true, false, false,
602 handle_const_attribute },
603 { "transparent_union", 0, 0, false, false, false,
604 handle_transparent_union_attribute },
605 { "constructor", 0, 1, true, false, false,
606 handle_constructor_attribute },
607 { "destructor", 0, 1, true, false, false,
608 handle_destructor_attribute },
609 { "mode", 1, 1, false, true, false,
610 handle_mode_attribute },
611 { "section", 1, 1, true, false, false,
612 handle_section_attribute },
613 { "aligned", 0, 1, false, false, false,
614 handle_aligned_attribute },
615 { "weak", 0, 0, true, false, false,
616 handle_weak_attribute },
617 { "alias", 1, 1, true, false, false,
618 handle_alias_attribute },
619 { "weakref", 0, 1, true, false, false,
620 handle_weakref_attribute },
621 { "no_instrument_function", 0, 0, true, false, false,
622 handle_no_instrument_function_attribute },
623 { "malloc", 0, 0, true, false, false,
624 handle_malloc_attribute },
625 { "returns_twice", 0, 0, true, false, false,
626 handle_returns_twice_attribute },
627 { "no_stack_limit", 0, 0, true, false, false,
628 handle_no_limit_stack_attribute },
629 { "pure", 0, 0, true, false, false,
630 handle_pure_attribute },
631 /* For internal use (marking of builtins) only. The name contains space
632 to prevent its usage in source code. */
633 { "no vops", 0, 0, true, false, false,
634 handle_novops_attribute },
635 { "deprecated", 0, 0, false, false, false,
636 handle_deprecated_attribute },
637 { "vector_size", 1, 1, false, true, false,
638 handle_vector_size_attribute },
639 { "visibility", 1, 1, false, false, false,
640 handle_visibility_attribute },
641 { "tls_model", 1, 1, true, false, false,
642 handle_tls_model_attribute },
643 { "nonnull", 0, -1, false, true, true,
644 handle_nonnull_attribute },
645 { "nothrow", 0, 0, true, false, false,
646 handle_nothrow_attribute },
647 { "may_alias", 0, 0, false, true, false, NULL },
648 { "cleanup", 1, 1, true, false, false,
649 handle_cleanup_attribute },
650 { "warn_unused_result", 0, 0, false, true, true,
651 handle_warn_unused_result_attribute },
652 { "sentinel", 0, 1, false, true, true,
653 handle_sentinel_attribute },
654 /* For internal use (marking of builtins) only. The name contains space
655 to prevent its usage in source code. */
656 { "type generic", 0, 0, false, true, true,
657 handle_type_generic_attribute },
658 { "alloc_size", 1, 2, false, true, true,
659 handle_alloc_size_attribute },
660 { "cold", 0, 0, true, false, false,
661 handle_cold_attribute },
662 { "hot", 0, 0, true, false, false,
663 handle_hot_attribute },
664 { NULL, 0, 0, false, false, false, NULL }
667 /* Give the specifications for the format attributes, used by C and all
670 const struct attribute_spec c_common_format_attribute_table[] =
672 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
673 { "format", 3, 3, false, true, true,
674 handle_format_attribute },
675 { "format_arg", 1, 1, false, true, true,
676 handle_format_arg_attribute },
677 { NULL, 0, 0, false, false, false, NULL }
680 /* Push current bindings for the function name VAR_DECLS. */
683 start_fname_decls (void)
686 tree saved = NULL_TREE;
688 for (ix = 0; fname_vars[ix].decl; ix++)
690 tree decl = *fname_vars[ix].decl;
694 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
695 *fname_vars[ix].decl = NULL_TREE;
698 if (saved || saved_function_name_decls)
699 /* Normally they'll have been NULL, so only push if we've got a
700 stack, or they are non-NULL. */
701 saved_function_name_decls = tree_cons (saved, NULL_TREE,
702 saved_function_name_decls);
705 /* Finish up the current bindings, adding them into the current function's
706 statement tree. This must be done _before_ finish_stmt_tree is called.
707 If there is no current function, we must be at file scope and no statements
708 are involved. Pop the previous bindings. */
711 finish_fname_decls (void)
714 tree stmts = NULL_TREE;
715 tree stack = saved_function_name_decls;
717 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
718 append_to_statement_list (TREE_VALUE (stack), &stmts);
722 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
724 if (TREE_CODE (*bodyp) == BIND_EXPR)
725 bodyp = &BIND_EXPR_BODY (*bodyp);
727 append_to_statement_list_force (*bodyp, &stmts);
731 for (ix = 0; fname_vars[ix].decl; ix++)
732 *fname_vars[ix].decl = NULL_TREE;
736 /* We had saved values, restore them. */
739 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
741 tree decl = TREE_PURPOSE (saved);
742 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
744 *fname_vars[ix].decl = decl;
746 stack = TREE_CHAIN (stack);
748 saved_function_name_decls = stack;
751 /* Return the text name of the current function, suitably prettified
752 by PRETTY_P. Return string must be freed by caller. */
755 fname_as_string (int pretty_p)
757 const char *name = "top level";
767 if (current_function_decl)
768 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
770 if (c_lex_string_translate)
772 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
773 cpp_string cstr = { 0, 0 }, strname;
775 namep = XNEWVEC (char, len);
776 snprintf (namep, len, "\"%s\"", name);
777 strname.text = (unsigned char *) namep;
778 strname.len = len - 1;
780 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
783 return (const char *) cstr.text;
787 namep = xstrdup (name);
792 /* Expand DECL if it declares an entity not handled by the
796 c_expand_decl (tree decl)
798 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
800 /* Let the back-end know about this variable. */
801 if (!anon_aggr_type_p (TREE_TYPE (decl)))
802 emit_local_var (decl);
804 expand_anon_union_decl (decl, NULL_TREE,
805 DECL_ANON_UNION_ELEMS (decl));
814 /* Return the VAR_DECL for a const char array naming the current
815 function. If the VAR_DECL has not yet been created, create it
816 now. RID indicates how it should be formatted and IDENTIFIER_NODE
817 ID is its name (unfortunately C and C++ hold the RID values of
818 keywords in different places, so we can't derive RID from ID in
819 this language independent code. */
822 fname_decl (unsigned int rid, tree id)
825 tree decl = NULL_TREE;
827 for (ix = 0; fname_vars[ix].decl; ix++)
828 if (fname_vars[ix].rid == rid)
831 decl = *fname_vars[ix].decl;
834 /* If a tree is built here, it would normally have the lineno of
835 the current statement. Later this tree will be moved to the
836 beginning of the function and this line number will be wrong.
837 To avoid this problem set the lineno to 0 here; that prevents
838 it from appearing in the RTL. */
840 location_t saved_location = input_location;
841 #ifdef USE_MAPPED_LOCATION
842 input_location = UNKNOWN_LOCATION;
847 stmts = push_stmt_list ();
848 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
849 stmts = pop_stmt_list (stmts);
850 if (!IS_EMPTY_STMT (stmts))
851 saved_function_name_decls
852 = tree_cons (decl, stmts, saved_function_name_decls);
853 *fname_vars[ix].decl = decl;
854 input_location = saved_location;
856 if (!ix && !current_function_decl)
857 pedwarn ("%qD is not defined outside of function scope", decl);
862 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
865 fix_string_type (tree value)
867 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
868 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
869 int length = TREE_STRING_LENGTH (value);
871 tree e_type, i_type, a_type;
873 /* Compute the number of elements, for the array type. */
874 nchars = wide_flag ? length / wchar_bytes : length;
876 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
877 limit in C++98 Annex B is very large (65536) and is not normative,
878 so we do not diagnose it (warn_overlength_strings is forced off
879 in c_common_post_options). */
880 if (warn_overlength_strings)
882 const int nchars_max = flag_isoc99 ? 4095 : 509;
883 const int relevant_std = flag_isoc99 ? 99 : 90;
884 if (nchars - 1 > nchars_max)
885 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
886 separate the %d from the 'C'. 'ISO' should not be
887 translated, but it may be moved after 'C%d' in languages
888 where modifiers follow nouns. */
889 pedwarn ("string length %qd is greater than the length %qd "
890 "ISO C%d compilers are required to support",
891 nchars - 1, nchars_max, relevant_std);
894 /* Create the array type for the string constant. The ISO C++
895 standard says that a string literal has type `const char[N]' or
896 `const wchar_t[N]'. We use the same logic when invoked as a C
897 front-end with -Wwrite-strings.
898 ??? We should change the type of an expression depending on the
899 state of a warning flag. We should just be warning -- see how
900 this is handled in the C++ front-end for the deprecated implicit
901 conversion from string literals to `char*' or `wchar_t*'.
903 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
904 array type being the unqualified version of that type.
905 Therefore, if we are constructing an array of const char, we must
906 construct the matching unqualified array type first. The C front
907 end does not require this, but it does no harm, so we do it
909 e_type = wide_flag ? wchar_type_node : char_type_node;
910 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
911 a_type = build_array_type (e_type, i_type);
912 if (c_dialect_cxx() || warn_write_strings)
913 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
915 TREE_TYPE (value) = a_type;
916 TREE_CONSTANT (value) = 1;
917 TREE_INVARIANT (value) = 1;
918 TREE_READONLY (value) = 1;
919 TREE_STATIC (value) = 1;
923 /* Print a warning if a constant expression had overflow in folding.
924 Invoke this function on every expression that the language
925 requires to be a constant expression.
926 Note the ANSI C standard says it is erroneous for a
927 constant expression to overflow. */
930 constant_expression_warning (tree value)
932 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
933 || TREE_CODE (value) == VECTOR_CST
934 || TREE_CODE (value) == COMPLEX_CST)
935 && TREE_OVERFLOW (value)
938 pedwarn ("overflow in constant expression");
941 /* Print a warning if an expression had overflow in folding and its
944 Invoke this function on every expression that
945 (1) appears in the source code, and
946 (2) is a constant expression that overflowed, and
947 (3) is not already checked by convert_and_check;
948 however, do not invoke this function on operands of explicit casts
949 or when the expression is the result of an operator and any operand
950 already overflowed. */
953 overflow_warning (tree value)
955 if (skip_evaluation) return;
957 switch (TREE_CODE (value))
960 warning (OPT_Woverflow, "integer overflow in expression");
964 warning (OPT_Woverflow, "floating point overflow in expression");
968 warning (OPT_Woverflow, "vector overflow in expression");
972 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
973 warning (OPT_Woverflow, "complex integer overflow in expression");
974 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
975 warning (OPT_Woverflow, "complex floating point overflow in expression");
984 /* Warn about use of a logical || / && operator being used in a
985 context where it is likely that the bitwise equivalent was intended
986 by the programmer. CODE is the TREE_CODE of the operator, ARG1
987 and ARG2 the arguments. */
990 warn_logical_operator (enum tree_code code, tree arg1, tree
995 case TRUTH_ANDIF_EXPR:
996 case TRUTH_ORIF_EXPR:
999 if (!TREE_NO_WARNING (arg1)
1000 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
1001 && !CONSTANT_CLASS_P (arg1)
1002 && TREE_CODE (arg2) == INTEGER_CST
1003 && !integer_zerop (arg2))
1005 warning (OPT_Wlogical_op,
1006 "logical %<%s%> with non-zero constant "
1007 "will always evaluate as true",
1008 ((code == TRUTH_ANDIF_EXPR)
1009 || (code == TRUTH_AND_EXPR)) ? "&&" : "||");
1010 TREE_NO_WARNING (arg1) = true;
1019 /* Print a warning about casts that might indicate violation
1020 of strict aliasing rules if -Wstrict-aliasing is used and
1021 strict aliasing mode is in effect. OTYPE is the original
1022 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1025 strict_aliasing_warning (tree otype, tree type, tree expr)
1027 if (!(flag_strict_aliasing && POINTER_TYPE_P (type)
1028 && POINTER_TYPE_P (otype) && !VOID_TYPE_P (TREE_TYPE (type))))
1031 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1032 && (DECL_P (TREE_OPERAND (expr, 0))
1033 || handled_component_p (TREE_OPERAND (expr, 0))))
1035 /* Casting the address of an object to non void pointer. Warn
1036 if the cast breaks type based aliasing. */
1037 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1039 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1040 "might break strict-aliasing rules");
1045 /* warn_strict_aliasing >= 3. This includes the default (3).
1046 Only warn if the cast is dereferenced immediately. */
1047 HOST_WIDE_INT set1 =
1048 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1049 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1051 if (!alias_sets_conflict_p (set1, set2))
1053 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1054 "pointer will break strict-aliasing rules");
1057 else if (warn_strict_aliasing == 2
1058 && !alias_sets_must_conflict_p (set1, set2))
1060 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1061 "pointer might break strict-aliasing rules");
1067 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1069 /* At this level, warn for any conversions, even if an address is
1070 not taken in the same statement. This will likely produce many
1071 false positives, but could be useful to pinpoint problems that
1072 are not revealed at higher levels. */
1073 HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (otype));
1074 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1075 if (!COMPLETE_TYPE_P(type)
1076 || !alias_sets_must_conflict_p (set1, set2))
1078 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1079 "pointer might break strict-aliasing rules");
1087 /* Print a warning about if (); or if () .. else; constructs
1088 via the special empty statement node that we create. INNER_THEN
1089 and INNER_ELSE are the statement lists of the if and the else
1093 empty_if_body_warning (tree inner_then, tree inner_else)
1095 if (TREE_CODE (inner_then) == STATEMENT_LIST
1096 && STATEMENT_LIST_TAIL (inner_then))
1097 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1099 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1100 && STATEMENT_LIST_TAIL (inner_else))
1101 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1103 if (IS_EMPTY_STMT (inner_then) && !inner_else)
1104 warning (OPT_Wempty_body, "%Hsuggest braces around empty body "
1105 "in an %<if%> statement", EXPR_LOCUS (inner_then));
1107 else if (inner_else && IS_EMPTY_STMT (inner_else))
1108 warning (OPT_Wempty_body, "%Hsuggest braces around empty body "
1109 "in an %<else%> statement", EXPR_LOCUS (inner_else));
1112 /* Warn for unlikely, improbable, or stupid DECL declarations
1116 check_main_parameter_types (tree decl)
1121 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1122 args = TREE_CHAIN (args))
1124 tree type = args ? TREE_VALUE (args) : 0;
1126 if (type == void_type_node || type == error_mark_node )
1133 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1134 pedwarn ("first argument of %q+D should be %<int%>", decl);
1138 if (TREE_CODE (type) != POINTER_TYPE
1139 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1140 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1142 pedwarn ("second argument of %q+D should be %<char **%>",
1147 if (TREE_CODE (type) != POINTER_TYPE
1148 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1149 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1151 pedwarn ("third argument of %q+D should probably be "
1152 "%<char **%>", decl);
1157 /* It is intentional that this message does not mention the third
1158 argument because it's only mentioned in an appendix of the
1160 if (argct > 0 && (argct < 2 || argct > 3))
1161 pedwarn ("%q+D takes only zero or two arguments", decl);
1164 /* True if vector types T1 and T2 can be converted to each other
1165 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1166 can only be converted with -flax-vector-conversions yet that is not
1167 in effect, emit a note telling the user about that option if such
1168 a note has not previously been emitted. */
1170 vector_types_convertible_p (tree t1, tree t2, bool emit_lax_note)
1172 static bool emitted_lax_note = false;
1173 bool convertible_lax;
1175 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1176 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1180 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1181 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1182 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1183 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1184 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1186 if (!convertible_lax || flag_lax_vector_conversions)
1187 return convertible_lax;
1189 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1190 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
1193 if (emit_lax_note && !emitted_lax_note)
1195 emitted_lax_note = true;
1196 inform ("use -flax-vector-conversions to permit "
1197 "conversions between vectors with differing "
1198 "element types or numbers of subparts");
1204 /* Warns if the conversion of EXPR to TYPE may alter a value.
1205 This is a helper function for warnings_for_convert_and_check. */
1208 conversion_warning (tree type, tree expr)
1210 bool give_warning = false;
1212 unsigned int formal_prec = TYPE_PRECISION (type);
1214 if (!warn_conversion && !warn_sign_conversion)
1217 if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST)
1219 /* Warn for real constant that is not an exact integer converted
1221 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1222 && TREE_CODE (type) == INTEGER_TYPE)
1224 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (TREE_TYPE (expr))))
1225 give_warning = true;
1227 /* Warn for an integer constant that does not fit into integer type. */
1228 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1229 && TREE_CODE (type) == INTEGER_TYPE
1230 && !int_fits_type_p (expr, type))
1232 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr)))
1233 warning (OPT_Wsign_conversion,
1234 "negative integer implicitly converted to unsigned type");
1235 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (TREE_TYPE (expr)))
1236 warning (OPT_Wsign_conversion,
1237 "conversion of unsigned constant value to negative integer");
1239 give_warning = true;
1241 else if (TREE_CODE (type) == REAL_TYPE)
1243 /* Warn for an integer constant that does not fit into real type. */
1244 if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE)
1246 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1247 if (!exact_real_truncate (TYPE_MODE (type), &a))
1248 give_warning = true;
1250 /* Warn for a real constant that does not fit into a smaller
1252 else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1253 && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1255 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1256 if (!exact_real_truncate (TYPE_MODE (type), &a))
1257 give_warning = true;
1262 warning (OPT_Wconversion,
1263 "conversion to %qT alters %qT constant value",
1264 type, TREE_TYPE (expr));
1266 else /* 'expr' is not a constant. */
1268 /* Warn for real types converted to integer types. */
1269 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1270 && TREE_CODE (type) == INTEGER_TYPE)
1271 give_warning = true;
1273 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1274 && TREE_CODE (type) == INTEGER_TYPE)
1276 /* Warn for integer types converted to smaller integer types. */
1277 if (formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1278 give_warning = true;
1280 /* When they are the same width but different signedness,
1281 then the value may change. */
1282 else if ((formal_prec == TYPE_PRECISION (TREE_TYPE (expr))
1283 && TYPE_UNSIGNED (TREE_TYPE (expr)) != TYPE_UNSIGNED (type))
1284 /* Even when converted to a bigger type, if the type is
1285 unsigned but expr is signed, then negative values
1287 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr))))
1288 warning (OPT_Wsign_conversion,
1289 "conversion to %qT from %qT may change the sign of the result",
1290 type, TREE_TYPE (expr));
1293 /* Warn for integer types converted to real types if and only if
1294 all the range of values of the integer type cannot be
1295 represented by the real type. */
1296 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1297 && TREE_CODE (type) == REAL_TYPE)
1299 tree type_low_bound = TYPE_MIN_VALUE (TREE_TYPE (expr));
1300 tree type_high_bound = TYPE_MAX_VALUE (TREE_TYPE (expr));
1301 REAL_VALUE_TYPE real_low_bound = real_value_from_int_cst (0, type_low_bound);
1302 REAL_VALUE_TYPE real_high_bound = real_value_from_int_cst (0, type_high_bound);
1304 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1305 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1306 give_warning = true;
1309 /* Warn for real types converted to smaller real types. */
1310 else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1311 && TREE_CODE (type) == REAL_TYPE
1312 && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1313 give_warning = true;
1317 warning (OPT_Wconversion,
1318 "conversion to %qT from %qT may alter its value",
1319 type, TREE_TYPE (expr));
1323 /* Produce warnings after a conversion. RESULT is the result of
1324 converting EXPR to TYPE. This is a helper function for
1325 convert_and_check and cp_convert_and_check. */
1328 warnings_for_convert_and_check (tree type, tree expr, tree result)
1330 if (TREE_CODE (expr) == INTEGER_CST
1331 && (TREE_CODE (type) == INTEGER_TYPE
1332 || TREE_CODE (type) == ENUMERAL_TYPE)
1333 && !int_fits_type_p (expr, type))
1335 /* Do not diagnose overflow in a constant expression merely
1336 because a conversion overflowed. */
1337 if (TREE_OVERFLOW (result))
1338 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1340 if (TYPE_UNSIGNED (type))
1342 /* This detects cases like converting -129 or 256 to
1344 if (!int_fits_type_p (expr, c_common_signed_type (type)))
1345 warning (OPT_Woverflow,
1346 "large integer implicitly truncated to unsigned type");
1348 conversion_warning (type, expr);
1350 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
1351 warning (OPT_Woverflow,
1352 "overflow in implicit constant conversion");
1353 /* No warning for converting 0x80000000 to int. */
1355 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1356 || TYPE_PRECISION (TREE_TYPE (expr))
1357 != TYPE_PRECISION (type)))
1358 warning (OPT_Woverflow,
1359 "overflow in implicit constant conversion");
1362 conversion_warning (type, expr);
1364 else if (TREE_CODE (result) == INTEGER_CST && TREE_OVERFLOW (result))
1365 warning (OPT_Woverflow,
1366 "overflow in implicit constant conversion");
1368 conversion_warning (type, expr);
1372 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1373 Invoke this function on every expression that is converted implicitly,
1374 i.e. because of language rules and not because of an explicit cast. */
1377 convert_and_check (tree type, tree expr)
1381 if (TREE_TYPE (expr) == type)
1384 result = convert (type, expr);
1386 if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
1387 warnings_for_convert_and_check (type, expr, result);
1392 /* A node in a list that describes references to variables (EXPR), which are
1393 either read accesses if WRITER is zero, or write accesses, in which case
1394 WRITER is the parent of EXPR. */
1401 /* Used to implement a cache the results of a call to verify_tree. We only
1402 use this for SAVE_EXPRs. */
1405 struct tlist_cache *next;
1406 struct tlist *cache_before_sp;
1407 struct tlist *cache_after_sp;
1411 /* Obstack to use when allocating tlist structures, and corresponding
1413 static struct obstack tlist_obstack;
1414 static char *tlist_firstobj = 0;
1416 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1418 static struct tlist *warned_ids;
1419 /* SAVE_EXPRs need special treatment. We process them only once and then
1420 cache the results. */
1421 static struct tlist_cache *save_expr_cache;
1423 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1424 static void merge_tlist (struct tlist **, struct tlist *, int);
1425 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1426 static int warning_candidate_p (tree);
1427 static void warn_for_collisions (struct tlist *);
1428 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1429 static struct tlist *new_tlist (struct tlist *, tree, tree);
1431 /* Create a new struct tlist and fill in its fields. */
1432 static struct tlist *
1433 new_tlist (struct tlist *next, tree t, tree writer)
1436 l = XOBNEW (&tlist_obstack, struct tlist);
1443 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1444 is nonnull, we ignore any node we find which has a writer equal to it. */
1447 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1451 struct tlist *next = add->next;
1454 if (!exclude_writer || add->writer != exclude_writer)
1455 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1460 /* Merge the nodes of ADD into TO. This merging process is done so that for
1461 each variable that already exists in TO, no new node is added; however if
1462 there is a write access recorded in ADD, and an occurrence on TO is only
1463 a read access, then the occurrence in TO will be modified to record the
1467 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1469 struct tlist **end = to;
1472 end = &(*end)->next;
1478 struct tlist *next = add->next;
1480 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1481 if (tmp2->expr == add->expr)
1485 tmp2->writer = add->writer;
1489 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1490 end = &(*end)->next;
1497 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1498 references in list LIST conflict with it, excluding reads if ONLY writers
1502 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1507 /* Avoid duplicate warnings. */
1508 for (tmp = warned_ids; tmp; tmp = tmp->next)
1509 if (tmp->expr == written)
1514 if (list->expr == written
1515 && list->writer != writer
1516 && (!only_writes || list->writer)
1517 && DECL_NAME (list->expr))
1519 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1520 warning (0, "operation on %qE may be undefined", list->expr);
1526 /* Given a list LIST of references to variables, find whether any of these
1527 can cause conflicts due to missing sequence points. */
1530 warn_for_collisions (struct tlist *list)
1534 for (tmp = list; tmp; tmp = tmp->next)
1537 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1541 /* Return nonzero if X is a tree that can be verified by the sequence point
1544 warning_candidate_p (tree x)
1546 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1549 /* Walk the tree X, and record accesses to variables. If X is written by the
1550 parent tree, WRITER is the parent.
1551 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1552 expression or its only operand forces a sequence point, then everything up
1553 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1555 Once we return, we will have emitted warnings if any subexpression before
1556 such a sequence point could be undefined. On a higher level, however, the
1557 sequence point may not be relevant, and we'll merge the two lists.
1559 Example: (b++, a) + b;
1560 The call that processes the COMPOUND_EXPR will store the increment of B
1561 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1562 processes the PLUS_EXPR will need to merge the two lists so that
1563 eventually, all accesses end up on the same list (and we'll warn about the
1564 unordered subexpressions b++ and b.
1566 A note on merging. If we modify the former example so that our expression
1569 care must be taken not simply to add all three expressions into the final
1570 PNO_SP list. The function merge_tlist takes care of that by merging the
1571 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1572 way, so that no more than one access to B is recorded. */
1575 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1578 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1579 enum tree_code code;
1580 enum tree_code_class cl;
1582 /* X may be NULL if it is the operand of an empty statement expression
1588 code = TREE_CODE (x);
1589 cl = TREE_CODE_CLASS (code);
1591 if (warning_candidate_p (x))
1593 *pno_sp = new_tlist (*pno_sp, x, writer);
1603 case TRUTH_ANDIF_EXPR:
1604 case TRUTH_ORIF_EXPR:
1605 tmp_before = tmp_nosp = tmp_list3 = 0;
1606 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1607 warn_for_collisions (tmp_nosp);
1608 merge_tlist (pbefore_sp, tmp_before, 0);
1609 merge_tlist (pbefore_sp, tmp_nosp, 0);
1610 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1611 merge_tlist (pbefore_sp, tmp_list3, 0);
1615 tmp_before = tmp_list2 = 0;
1616 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1617 warn_for_collisions (tmp_list2);
1618 merge_tlist (pbefore_sp, tmp_before, 0);
1619 merge_tlist (pbefore_sp, tmp_list2, 1);
1621 tmp_list3 = tmp_nosp = 0;
1622 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1623 warn_for_collisions (tmp_nosp);
1624 merge_tlist (pbefore_sp, tmp_list3, 0);
1626 tmp_list3 = tmp_list2 = 0;
1627 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1628 warn_for_collisions (tmp_list2);
1629 merge_tlist (pbefore_sp, tmp_list3, 0);
1630 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1631 two first, to avoid warning for (a ? b++ : b++). */
1632 merge_tlist (&tmp_nosp, tmp_list2, 0);
1633 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1636 case PREDECREMENT_EXPR:
1637 case PREINCREMENT_EXPR:
1638 case POSTDECREMENT_EXPR:
1639 case POSTINCREMENT_EXPR:
1640 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1644 tmp_before = tmp_nosp = tmp_list3 = 0;
1645 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1646 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1647 /* Expressions inside the LHS are not ordered wrt. the sequence points
1648 in the RHS. Example:
1650 Despite the fact that the modification of "a" is in the before_sp
1651 list (tmp_before), it conflicts with the use of "a" in the LHS.
1652 We can handle this by adding the contents of tmp_list3
1653 to those of tmp_before, and redoing the collision warnings for that
1655 add_tlist (&tmp_before, tmp_list3, x, 1);
1656 warn_for_collisions (tmp_before);
1657 /* Exclude the LHS itself here; we first have to merge it into the
1658 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1659 didn't exclude the LHS, we'd get it twice, once as a read and once
1661 add_tlist (pno_sp, tmp_list3, x, 0);
1662 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1664 merge_tlist (pbefore_sp, tmp_before, 0);
1665 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1666 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1667 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1671 /* We need to warn about conflicts among arguments and conflicts between
1672 args and the function address. Side effects of the function address,
1673 however, are not ordered by the sequence point of the call. */
1675 call_expr_arg_iterator iter;
1677 tmp_before = tmp_nosp = 0;
1678 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
1679 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
1681 tmp_list2 = tmp_list3 = 0;
1682 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
1683 merge_tlist (&tmp_list3, tmp_list2, 0);
1684 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1686 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1687 warn_for_collisions (tmp_before);
1688 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1693 /* Scan all the list, e.g. indices of multi dimensional array. */
1696 tmp_before = tmp_nosp = 0;
1697 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1698 merge_tlist (&tmp_nosp, tmp_before, 0);
1699 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1706 struct tlist_cache *t;
1707 for (t = save_expr_cache; t; t = t->next)
1713 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1714 t->next = save_expr_cache;
1716 save_expr_cache = t;
1718 tmp_before = tmp_nosp = 0;
1719 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1720 warn_for_collisions (tmp_nosp);
1725 struct tlist *t = tmp_nosp;
1727 merge_tlist (&tmp_list3, t, 0);
1729 t->cache_before_sp = tmp_before;
1730 t->cache_after_sp = tmp_list3;
1732 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1733 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1738 /* For other expressions, simply recurse on their operands.
1739 Manual tail recursion for unary expressions.
1740 Other non-expressions need not be processed. */
1741 if (cl == tcc_unary)
1743 x = TREE_OPERAND (x, 0);
1747 else if (IS_EXPR_CODE_CLASS (cl))
1750 int max = TREE_OPERAND_LENGTH (x);
1751 for (lp = 0; lp < max; lp++)
1753 tmp_before = tmp_nosp = 0;
1754 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1755 merge_tlist (&tmp_nosp, tmp_before, 0);
1756 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1763 /* Try to warn for undefined behavior in EXPR due to missing sequence
1767 verify_sequence_points (tree expr)
1769 struct tlist *before_sp = 0, *after_sp = 0;
1772 save_expr_cache = 0;
1773 if (tlist_firstobj == 0)
1775 gcc_obstack_init (&tlist_obstack);
1776 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1779 verify_tree (expr, &before_sp, &after_sp, 0);
1780 warn_for_collisions (after_sp);
1781 obstack_free (&tlist_obstack, tlist_firstobj);
1784 /* Validate the expression after `case' and apply default promotions. */
1787 check_case_value (tree value)
1789 if (value == NULL_TREE)
1792 /* ??? Can we ever get nops here for a valid case value? We
1794 STRIP_TYPE_NOPS (value);
1795 /* In C++, the following is allowed:
1798 switch (...) { case i: ... }
1800 So, we try to reduce the VALUE to a constant that way. */
1801 if (c_dialect_cxx ())
1803 value = decl_constant_value (value);
1804 STRIP_TYPE_NOPS (value);
1805 value = fold (value);
1808 if (TREE_CODE (value) == INTEGER_CST)
1809 /* Promote char or short to int. */
1810 value = perform_integral_promotions (value);
1811 else if (value != error_mark_node)
1813 error ("case label does not reduce to an integer constant");
1814 value = error_mark_node;
1817 constant_expression_warning (value);
1822 /* See if the case values LOW and HIGH are in the range of the original
1823 type (i.e. before the default conversion to int) of the switch testing
1825 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1826 the type before promoting it. CASE_LOW_P is a pointer to the lower
1827 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1828 if the case is not a case range.
1829 The caller has to make sure that we are not called with NULL for
1830 CASE_LOW_P (i.e. the default case).
1831 Returns true if the case label is in range of ORIG_TYPE (saturated or
1832 untouched) or false if the label is out of range. */
1835 check_case_bounds (tree type, tree orig_type,
1836 tree *case_low_p, tree *case_high_p)
1838 tree min_value, max_value;
1839 tree case_low = *case_low_p;
1840 tree case_high = case_high_p ? *case_high_p : case_low;
1842 /* If there was a problem with the original type, do nothing. */
1843 if (orig_type == error_mark_node)
1846 min_value = TYPE_MIN_VALUE (orig_type);
1847 max_value = TYPE_MAX_VALUE (orig_type);
1849 /* Case label is less than minimum for type. */
1850 if (tree_int_cst_compare (case_low, min_value) < 0
1851 && tree_int_cst_compare (case_high, min_value) < 0)
1853 warning (0, "case label value is less than minimum value for type");
1857 /* Case value is greater than maximum for type. */
1858 if (tree_int_cst_compare (case_low, max_value) > 0
1859 && tree_int_cst_compare (case_high, max_value) > 0)
1861 warning (0, "case label value exceeds maximum value for type");
1865 /* Saturate lower case label value to minimum. */
1866 if (tree_int_cst_compare (case_high, min_value) >= 0
1867 && tree_int_cst_compare (case_low, min_value) < 0)
1869 warning (0, "lower value in case label range"
1870 " less than minimum value for type");
1871 case_low = min_value;
1874 /* Saturate upper case label value to maximum. */
1875 if (tree_int_cst_compare (case_low, max_value) <= 0
1876 && tree_int_cst_compare (case_high, max_value) > 0)
1878 warning (0, "upper value in case label range"
1879 " exceeds maximum value for type");
1880 case_high = max_value;
1883 if (*case_low_p != case_low)
1884 *case_low_p = convert (type, case_low);
1885 if (case_high_p && *case_high_p != case_high)
1886 *case_high_p = convert (type, case_high);
1891 /* Return an integer type with BITS bits of precision,
1892 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1895 c_common_type_for_size (unsigned int bits, int unsignedp)
1897 if (bits == TYPE_PRECISION (integer_type_node))
1898 return unsignedp ? unsigned_type_node : integer_type_node;
1900 if (bits == TYPE_PRECISION (signed_char_type_node))
1901 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1903 if (bits == TYPE_PRECISION (short_integer_type_node))
1904 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1906 if (bits == TYPE_PRECISION (long_integer_type_node))
1907 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1909 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1910 return (unsignedp ? long_long_unsigned_type_node
1911 : long_long_integer_type_node);
1913 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1914 return (unsignedp ? widest_unsigned_literal_type_node
1915 : widest_integer_literal_type_node);
1917 if (bits <= TYPE_PRECISION (intQI_type_node))
1918 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1920 if (bits <= TYPE_PRECISION (intHI_type_node))
1921 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1923 if (bits <= TYPE_PRECISION (intSI_type_node))
1924 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1926 if (bits <= TYPE_PRECISION (intDI_type_node))
1927 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1932 /* Used for communication between c_common_type_for_mode and
1933 c_register_builtin_type. */
1934 static GTY(()) tree registered_builtin_types;
1936 /* Return a data type that has machine mode MODE.
1937 If the mode is an integer,
1938 then UNSIGNEDP selects between signed and unsigned types. */
1941 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1945 if (mode == TYPE_MODE (integer_type_node))
1946 return unsignedp ? unsigned_type_node : integer_type_node;
1948 if (mode == TYPE_MODE (signed_char_type_node))
1949 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1951 if (mode == TYPE_MODE (short_integer_type_node))
1952 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1954 if (mode == TYPE_MODE (long_integer_type_node))
1955 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1957 if (mode == TYPE_MODE (long_long_integer_type_node))
1958 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1960 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1961 return unsignedp ? widest_unsigned_literal_type_node
1962 : widest_integer_literal_type_node;
1965 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1968 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1971 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1974 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1976 #if HOST_BITS_PER_WIDE_INT >= 64
1977 if (mode == TYPE_MODE (intTI_type_node))
1978 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1981 if (mode == TYPE_MODE (float_type_node))
1982 return float_type_node;
1984 if (mode == TYPE_MODE (double_type_node))
1985 return double_type_node;
1987 if (mode == TYPE_MODE (long_double_type_node))
1988 return long_double_type_node;
1990 if (mode == TYPE_MODE (void_type_node))
1991 return void_type_node;
1993 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1995 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1996 : make_signed_type (GET_MODE_PRECISION (mode)));
1998 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2000 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2001 : make_signed_type (GET_MODE_PRECISION (mode)));
2003 if (COMPLEX_MODE_P (mode))
2005 enum machine_mode inner_mode;
2008 if (mode == TYPE_MODE (complex_float_type_node))
2009 return complex_float_type_node;
2010 if (mode == TYPE_MODE (complex_double_type_node))
2011 return complex_double_type_node;
2012 if (mode == TYPE_MODE (complex_long_double_type_node))
2013 return complex_long_double_type_node;
2015 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2016 return complex_integer_type_node;
2018 inner_mode = GET_MODE_INNER (mode);
2019 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2020 if (inner_type != NULL_TREE)
2021 return build_complex_type (inner_type);
2023 else if (VECTOR_MODE_P (mode))
2025 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2026 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2027 if (inner_type != NULL_TREE)
2028 return build_vector_type_for_mode (inner_type, mode);
2031 if (mode == TYPE_MODE (dfloat32_type_node))
2032 return dfloat32_type_node;
2033 if (mode == TYPE_MODE (dfloat64_type_node))
2034 return dfloat64_type_node;
2035 if (mode == TYPE_MODE (dfloat128_type_node))
2036 return dfloat128_type_node;
2038 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2039 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2040 return TREE_VALUE (t);
2046 c_common_unsigned_type (tree type)
2048 return c_common_signed_or_unsigned_type (1, type);
2051 /* Return a signed type the same as TYPE in other respects. */
2054 c_common_signed_type (tree type)
2056 return c_common_signed_or_unsigned_type (0, type);
2059 /* Return a type the same as TYPE except unsigned or
2060 signed according to UNSIGNEDP. */
2063 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2067 /* This block of code emulates the behavior of the old
2068 c_common_unsigned_type. In particular, it returns
2069 long_unsigned_type_node if passed a long, even when a int would
2070 have the same size. This is necessary for warnings to work
2071 correctly in archs where sizeof(int) == sizeof(long) */
2073 type1 = TYPE_MAIN_VARIANT (type);
2074 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2075 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2076 if (type1 == integer_type_node || type1 == unsigned_type_node)
2077 return unsignedp ? unsigned_type_node : integer_type_node;
2078 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2079 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2080 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2081 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2082 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
2083 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2084 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
2085 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
2086 #if HOST_BITS_PER_WIDE_INT >= 64
2087 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2088 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2090 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2091 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2092 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2093 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2094 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2095 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2096 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2097 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2099 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2100 the precision; they have precision set to match their range, but
2101 may use a wider mode to match an ABI. If we change modes, we may
2102 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2103 the precision as well, so as to yield correct results for
2104 bit-field types. C++ does not have these separate bit-field
2105 types, and producing a signed or unsigned variant of an
2106 ENUMERAL_TYPE may cause other problems as well. */
2108 if (!INTEGRAL_TYPE_P (type)
2109 || TYPE_UNSIGNED (type) == unsignedp)
2112 #define TYPE_OK(node) \
2113 (TYPE_MODE (type) == TYPE_MODE (node) \
2114 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
2115 if (TYPE_OK (signed_char_type_node))
2116 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2117 if (TYPE_OK (integer_type_node))
2118 return unsignedp ? unsigned_type_node : integer_type_node;
2119 if (TYPE_OK (short_integer_type_node))
2120 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2121 if (TYPE_OK (long_integer_type_node))
2122 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2123 if (TYPE_OK (long_long_integer_type_node))
2124 return (unsignedp ? long_long_unsigned_type_node
2125 : long_long_integer_type_node);
2126 if (TYPE_OK (widest_integer_literal_type_node))
2127 return (unsignedp ? widest_unsigned_literal_type_node
2128 : widest_integer_literal_type_node);
2130 #if HOST_BITS_PER_WIDE_INT >= 64
2131 if (TYPE_OK (intTI_type_node))
2132 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2134 if (TYPE_OK (intDI_type_node))
2135 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2136 if (TYPE_OK (intSI_type_node))
2137 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2138 if (TYPE_OK (intHI_type_node))
2139 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2140 if (TYPE_OK (intQI_type_node))
2141 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2144 if (c_dialect_cxx ())
2147 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2150 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2153 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2155 /* Extended integer types of the same width as a standard type have
2156 lesser rank, so those of the same width as int promote to int or
2157 unsigned int and are valid for printf formats expecting int or
2158 unsigned int. To avoid such special cases, avoid creating
2159 extended integer types for bit-fields if a standard integer type
2161 if (width == TYPE_PRECISION (integer_type_node))
2162 return unsignedp ? unsigned_type_node : integer_type_node;
2163 if (width == TYPE_PRECISION (signed_char_type_node))
2164 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2165 if (width == TYPE_PRECISION (short_integer_type_node))
2166 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2167 if (width == TYPE_PRECISION (long_integer_type_node))
2168 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2169 if (width == TYPE_PRECISION (long_long_integer_type_node))
2170 return (unsignedp ? long_long_unsigned_type_node
2171 : long_long_integer_type_node);
2172 return build_nonstandard_integer_type (width, unsignedp);
2175 /* The C version of the register_builtin_type langhook. */
2178 c_register_builtin_type (tree type, const char* name)
2182 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2183 DECL_ARTIFICIAL (decl) = 1;
2184 if (!TYPE_NAME (type))
2185 TYPE_NAME (type) = decl;
2188 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2192 /* Return the minimum number of bits needed to represent VALUE in a
2193 signed or unsigned type, UNSIGNEDP says which. */
2196 min_precision (tree value, int unsignedp)
2200 /* If the value is negative, compute its negative minus 1. The latter
2201 adjustment is because the absolute value of the largest negative value
2202 is one larger than the largest positive value. This is equivalent to
2203 a bit-wise negation, so use that operation instead. */
2205 if (tree_int_cst_sgn (value) < 0)
2206 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2208 /* Return the number of bits needed, taking into account the fact
2209 that we need one more bit for a signed than unsigned type. */
2211 if (integer_zerop (value))
2214 log = tree_floor_log2 (value);
2216 return log + 1 + !unsignedp;
2219 /* Print an error message for invalid operands to arith operation
2220 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */
2223 binary_op_error (enum tree_code code, tree type0, tree type1)
2230 opname = "+"; break;
2232 opname = "-"; break;
2234 opname = "*"; break;
2236 opname = "max"; break;
2238 opname = "min"; break;
2240 opname = "=="; break;
2242 opname = "!="; break;
2244 opname = "<="; break;
2246 opname = ">="; break;
2248 opname = "<"; break;
2250 opname = ">"; break;
2252 opname = "<<"; break;
2254 opname = ">>"; break;
2255 case TRUNC_MOD_EXPR:
2256 case FLOOR_MOD_EXPR:
2257 opname = "%"; break;
2258 case TRUNC_DIV_EXPR:
2259 case FLOOR_DIV_EXPR:
2260 opname = "/"; break;
2262 opname = "&"; break;
2264 opname = "|"; break;
2265 case TRUTH_ANDIF_EXPR:
2266 opname = "&&"; break;
2267 case TRUTH_ORIF_EXPR:
2268 opname = "||"; break;
2270 opname = "^"; break;
2274 error ("invalid operands to binary %s (have %qT and %qT)", opname,
2278 /* Subroutine of build_binary_op, used for comparison operations.
2279 See if the operands have both been converted from subword integer types
2280 and, if so, perhaps change them both back to their original type.
2281 This function is also responsible for converting the two operands
2282 to the proper common type for comparison.
2284 The arguments of this function are all pointers to local variables
2285 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2286 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2288 If this function returns nonzero, it means that the comparison has
2289 a constant value. What this function returns is an expression for
2293 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2294 enum tree_code *rescode_ptr)
2297 tree op0 = *op0_ptr;
2298 tree op1 = *op1_ptr;
2299 int unsignedp0, unsignedp1;
2301 tree primop0, primop1;
2302 enum tree_code code = *rescode_ptr;
2304 /* Throw away any conversions to wider types
2305 already present in the operands. */
2307 primop0 = get_narrower (op0, &unsignedp0);
2308 primop1 = get_narrower (op1, &unsignedp1);
2310 /* Handle the case that OP0 does not *contain* a conversion
2311 but it *requires* conversion to FINAL_TYPE. */
2313 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2314 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2315 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2316 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2318 /* If one of the operands must be floated, we cannot optimize. */
2319 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2320 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2322 /* If first arg is constant, swap the args (changing operation
2323 so value is preserved), for canonicalization. Don't do this if
2324 the second arg is 0. */
2326 if (TREE_CONSTANT (primop0)
2327 && !integer_zerop (primop1) && !real_zerop (primop1))
2330 int temi = unsignedp0;
2338 unsignedp0 = unsignedp1;
2361 *rescode_ptr = code;
2364 /* If comparing an integer against a constant more bits wide,
2365 maybe we can deduce a value of 1 or 0 independent of the data.
2366 Or else truncate the constant now
2367 rather than extend the variable at run time.
2369 This is only interesting if the constant is the wider arg.
2370 Also, it is not safe if the constant is unsigned and the
2371 variable arg is signed, since in this case the variable
2372 would be sign-extended and then regarded as unsigned.
2373 Our technique fails in this case because the lowest/highest
2374 possible unsigned results don't follow naturally from the
2375 lowest/highest possible values of the variable operand.
2376 For just EQ_EXPR and NE_EXPR there is another technique that
2377 could be used: see if the constant can be faithfully represented
2378 in the other operand's type, by truncating it and reextending it
2379 and see if that preserves the constant's value. */
2381 if (!real1 && !real2
2382 && TREE_CODE (primop1) == INTEGER_CST
2383 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2385 int min_gt, max_gt, min_lt, max_lt;
2386 tree maxval, minval;
2387 /* 1 if comparison is nominally unsigned. */
2388 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2391 type = c_common_signed_or_unsigned_type (unsignedp0,
2392 TREE_TYPE (primop0));
2394 maxval = TYPE_MAX_VALUE (type);
2395 minval = TYPE_MIN_VALUE (type);
2397 if (unsignedp && !unsignedp0)
2398 *restype_ptr = c_common_signed_type (*restype_ptr);
2400 if (TREE_TYPE (primop1) != *restype_ptr)
2402 /* Convert primop1 to target type, but do not introduce
2403 additional overflow. We know primop1 is an int_cst. */
2404 primop1 = force_fit_type_double (*restype_ptr,
2405 TREE_INT_CST_LOW (primop1),
2406 TREE_INT_CST_HIGH (primop1), 0,
2407 TREE_OVERFLOW (primop1));
2409 if (type != *restype_ptr)
2411 minval = convert (*restype_ptr, minval);
2412 maxval = convert (*restype_ptr, maxval);
2415 if (unsignedp && unsignedp0)
2417 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2418 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2419 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2420 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2424 min_gt = INT_CST_LT (primop1, minval);
2425 max_gt = INT_CST_LT (primop1, maxval);
2426 min_lt = INT_CST_LT (minval, primop1);
2427 max_lt = INT_CST_LT (maxval, primop1);
2431 /* This used to be a switch, but Genix compiler can't handle that. */
2432 if (code == NE_EXPR)
2434 if (max_lt || min_gt)
2435 val = truthvalue_true_node;
2437 else if (code == EQ_EXPR)
2439 if (max_lt || min_gt)
2440 val = truthvalue_false_node;
2442 else if (code == LT_EXPR)
2445 val = truthvalue_true_node;
2447 val = truthvalue_false_node;
2449 else if (code == GT_EXPR)
2452 val = truthvalue_true_node;
2454 val = truthvalue_false_node;
2456 else if (code == LE_EXPR)
2459 val = truthvalue_true_node;
2461 val = truthvalue_false_node;
2463 else if (code == GE_EXPR)
2466 val = truthvalue_true_node;
2468 val = truthvalue_false_node;
2471 /* If primop0 was sign-extended and unsigned comparison specd,
2472 we did a signed comparison above using the signed type bounds.
2473 But the comparison we output must be unsigned.
2475 Also, for inequalities, VAL is no good; but if the signed
2476 comparison had *any* fixed result, it follows that the
2477 unsigned comparison just tests the sign in reverse
2478 (positive values are LE, negative ones GE).
2479 So we can generate an unsigned comparison
2480 against an extreme value of the signed type. */
2482 if (unsignedp && !unsignedp0)
2489 primop1 = TYPE_MIN_VALUE (type);
2495 primop1 = TYPE_MAX_VALUE (type);
2502 type = c_common_unsigned_type (type);
2505 if (TREE_CODE (primop0) != INTEGER_CST)
2507 if (val == truthvalue_false_node)
2508 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
2509 if (val == truthvalue_true_node)
2510 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
2515 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2516 if (TREE_SIDE_EFFECTS (primop0))
2517 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2521 /* Value is not predetermined, but do the comparison
2522 in the type of the operand that is not constant.
2523 TYPE is already properly set. */
2526 /* If either arg is decimal float and the other is float, find the
2527 proper common type to use for comparison. */
2528 else if (real1 && real2
2529 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2530 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2531 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2533 else if (real1 && real2
2534 && (TYPE_PRECISION (TREE_TYPE (primop0))
2535 == TYPE_PRECISION (TREE_TYPE (primop1))))
2536 type = TREE_TYPE (primop0);
2538 /* If args' natural types are both narrower than nominal type
2539 and both extend in the same manner, compare them
2540 in the type of the wider arg.
2541 Otherwise must actually extend both to the nominal
2542 common type lest different ways of extending
2544 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2546 else if (unsignedp0 == unsignedp1 && real1 == real2
2547 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2548 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2550 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2551 type = c_common_signed_or_unsigned_type (unsignedp0
2552 || TYPE_UNSIGNED (*restype_ptr),
2554 /* Make sure shorter operand is extended the right way
2555 to match the longer operand. */
2557 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2558 TREE_TYPE (primop0)),
2561 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2562 TREE_TYPE (primop1)),
2567 /* Here we must do the comparison on the nominal type
2568 using the args exactly as we received them. */
2569 type = *restype_ptr;
2573 if (!real1 && !real2 && integer_zerop (primop1)
2574 && TYPE_UNSIGNED (*restype_ptr))
2580 /* All unsigned values are >= 0, so we warn. However,
2581 if OP0 is a constant that is >= 0, the signedness of
2582 the comparison isn't an issue, so suppress the
2584 if (warn_type_limits && !in_system_header
2585 && !(TREE_CODE (primop0) == INTEGER_CST
2586 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2588 warning (OPT_Wtype_limits,
2589 "comparison of unsigned expression >= 0 is always true");
2590 value = truthvalue_true_node;
2594 if (warn_type_limits && !in_system_header
2595 && !(TREE_CODE (primop0) == INTEGER_CST
2596 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2598 warning (OPT_Wtype_limits,
2599 "comparison of unsigned expression < 0 is always false");
2600 value = truthvalue_false_node;
2609 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2610 if (TREE_SIDE_EFFECTS (primop0))
2611 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2618 *op0_ptr = convert (type, primop0);
2619 *op1_ptr = convert (type, primop1);
2621 *restype_ptr = truthvalue_type_node;
2626 /* Return a tree for the sum or difference (RESULTCODE says which)
2627 of pointer PTROP and integer INTOP. */
2630 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2634 /* The result is a pointer of the same type that is being added. */
2635 tree result_type = TREE_TYPE (ptrop);
2637 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2639 if (pedantic || warn_pointer_arith)
2640 pedwarn ("pointer of type %<void *%> used in arithmetic");
2641 size_exp = integer_one_node;
2643 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2645 if (pedantic || warn_pointer_arith)
2646 pedwarn ("pointer to a function used in arithmetic");
2647 size_exp = integer_one_node;
2649 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2651 if (pedantic || warn_pointer_arith)
2652 pedwarn ("pointer to member function used in arithmetic");
2653 size_exp = integer_one_node;
2656 size_exp = size_in_bytes (TREE_TYPE (result_type));
2658 /* We are manipulating pointer values, so we don't need to warn
2659 about relying on undefined signed overflow. We disable the
2660 warning here because we use integer types so fold won't know that
2661 they are really pointers. */
2662 fold_defer_overflow_warnings ();
2664 /* If what we are about to multiply by the size of the elements
2665 contains a constant term, apply distributive law
2666 and multiply that constant term separately.
2667 This helps produce common subexpressions. */
2668 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2669 && !TREE_CONSTANT (intop)
2670 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2671 && TREE_CONSTANT (size_exp)
2672 /* If the constant comes from pointer subtraction,
2673 skip this optimization--it would cause an error. */
2674 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2675 /* If the constant is unsigned, and smaller than the pointer size,
2676 then we must skip this optimization. This is because it could cause
2677 an overflow error if the constant is negative but INTOP is not. */
2678 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2679 || (TYPE_PRECISION (TREE_TYPE (intop))
2680 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2682 enum tree_code subcode = resultcode;
2683 tree int_type = TREE_TYPE (intop);
2684 if (TREE_CODE (intop) == MINUS_EXPR)
2685 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2686 /* Convert both subexpression types to the type of intop,
2687 because weird cases involving pointer arithmetic
2688 can result in a sum or difference with different type args. */
2689 ptrop = build_binary_op (subcode, ptrop,
2690 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2691 intop = convert (int_type, TREE_OPERAND (intop, 0));
2694 /* Convert the integer argument to a type the same size as sizetype
2695 so the multiply won't overflow spuriously. */
2696 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2697 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2698 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2699 TYPE_UNSIGNED (sizetype)), intop);
2701 /* Replace the integer argument with a suitable product by the object size.
2702 Do this multiplication as signed, then convert to the appropriate
2703 type for the pointer operation. */
2704 intop = convert (sizetype,
2705 build_binary_op (MULT_EXPR, intop,
2706 convert (TREE_TYPE (intop), size_exp), 1));
2708 /* Create the sum or difference. */
2709 if (resultcode == MINUS_EXPR)
2710 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
2712 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
2714 fold_undefer_and_ignore_overflow_warnings ();
2719 /* Return whether EXPR is a declaration whose address can never be
2723 decl_with_nonnull_addr_p (tree expr)
2725 return (DECL_P (expr)
2726 && (TREE_CODE (expr) == PARM_DECL
2727 || TREE_CODE (expr) == LABEL_DECL
2728 || !DECL_WEAK (expr)));
2731 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2732 or for an `if' or `while' statement or ?..: exp. It should already
2733 have been validated to be of suitable type; otherwise, a bad
2734 diagnostic may result.
2736 This preparation consists of taking the ordinary
2737 representation of an expression expr and producing a valid tree
2738 boolean expression describing whether expr is nonzero. We could
2739 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2740 but we optimize comparisons, &&, ||, and !.
2742 The resulting type should always be `truthvalue_type_node'. */
2745 c_common_truthvalue_conversion (tree expr)
2747 switch (TREE_CODE (expr))
2749 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2750 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2751 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2752 case ORDERED_EXPR: case UNORDERED_EXPR:
2753 if (TREE_TYPE (expr) == truthvalue_type_node)
2755 return build2 (TREE_CODE (expr), truthvalue_type_node,
2756 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2758 case TRUTH_ANDIF_EXPR:
2759 case TRUTH_ORIF_EXPR:
2760 case TRUTH_AND_EXPR:
2762 case TRUTH_XOR_EXPR:
2763 if (TREE_TYPE (expr) == truthvalue_type_node)
2765 return build2 (TREE_CODE (expr), truthvalue_type_node,
2766 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2767 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2769 case TRUTH_NOT_EXPR:
2770 if (TREE_TYPE (expr) == truthvalue_type_node)
2772 return build1 (TREE_CODE (expr), truthvalue_type_node,
2773 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2779 return integer_zerop (expr) ? truthvalue_false_node
2780 : truthvalue_true_node;
2783 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2784 ? truthvalue_true_node
2785 : truthvalue_false_node;
2788 expr = build_unary_op (ADDR_EXPR, expr, 0);
2793 tree inner = TREE_OPERAND (expr, 0);
2794 if (decl_with_nonnull_addr_p (inner))
2796 /* Common Ada/Pascal programmer's mistake. */
2797 warning (OPT_Waddress,
2798 "the address of %qD will always evaluate as %<true%>",
2800 return truthvalue_true_node;
2803 /* If we still have a decl, it is possible for its address to
2804 be NULL, so we cannot optimize. */
2807 gcc_assert (DECL_WEAK (inner));
2811 if (TREE_SIDE_EFFECTS (inner))
2812 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2813 inner, truthvalue_true_node);
2815 return truthvalue_true_node;
2819 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2820 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2821 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2822 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2828 /* These don't change whether an object is nonzero or zero. */
2829 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2833 /* These don't change whether an object is zero or nonzero, but
2834 we can't ignore them if their second arg has side-effects. */
2835 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2836 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2837 TREE_OPERAND (expr, 1),
2838 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2840 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2843 /* Distribute the conversion into the arms of a COND_EXPR. */
2844 return fold_build3 (COND_EXPR, truthvalue_type_node,
2845 TREE_OPERAND (expr, 0),
2846 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2847 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2851 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2852 since that affects how `default_conversion' will behave. */
2853 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2854 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2856 /* If this is widening the argument, we can ignore it. */
2857 if (TYPE_PRECISION (TREE_TYPE (expr))
2858 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2859 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2863 if (!TREE_NO_WARNING (expr)
2864 && warn_parentheses)
2866 warning (OPT_Wparentheses,
2867 "suggest parentheses around assignment used as truth value");
2868 TREE_NO_WARNING (expr) = 1;
2876 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2878 tree t = save_expr (expr);
2879 return (build_binary_op
2880 ((TREE_SIDE_EFFECTS (expr)
2881 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2882 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2883 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2887 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2890 static void def_builtin_1 (enum built_in_function fncode,
2892 enum built_in_class fnclass,
2893 tree fntype, tree libtype,
2894 bool both_p, bool fallback_p, bool nonansi_p,
2895 tree fnattrs, bool implicit_p);
2897 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2898 down to the element type of an array. */
2901 c_build_qualified_type (tree type, int type_quals)
2903 if (type == error_mark_node)
2906 if (TREE_CODE (type) == ARRAY_TYPE)
2909 tree element_type = c_build_qualified_type (TREE_TYPE (type),
2912 /* See if we already have an identically qualified type. */
2913 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2915 if (TYPE_QUALS (strip_array_types (t)) == type_quals
2916 && TYPE_NAME (t) == TYPE_NAME (type)
2917 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2918 && attribute_list_equal (TYPE_ATTRIBUTES (t),
2919 TYPE_ATTRIBUTES (type)))
2924 tree domain = TYPE_DOMAIN (type);
2926 t = build_variant_type_copy (type);
2927 TREE_TYPE (t) = element_type;
2929 if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
2930 || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
2931 SET_TYPE_STRUCTURAL_EQUALITY (t);
2932 else if (TYPE_CANONICAL (element_type) != element_type
2933 || (domain && TYPE_CANONICAL (domain) != domain))
2935 tree unqualified_canon
2936 = build_array_type (TYPE_CANONICAL (element_type),
2937 domain? TYPE_CANONICAL (domain)
2940 = c_build_qualified_type (unqualified_canon, type_quals);
2943 TYPE_CANONICAL (t) = t;
2948 /* A restrict-qualified pointer type must be a pointer to object or
2949 incomplete type. Note that the use of POINTER_TYPE_P also allows
2950 REFERENCE_TYPEs, which is appropriate for C++. */
2951 if ((type_quals & TYPE_QUAL_RESTRICT)
2952 && (!POINTER_TYPE_P (type)
2953 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2955 error ("invalid use of %<restrict%>");
2956 type_quals &= ~TYPE_QUAL_RESTRICT;
2959 return build_qualified_type (type, type_quals);
2962 /* Apply the TYPE_QUALS to the new DECL. */
2965 c_apply_type_quals_to_decl (int type_quals, tree decl)
2967 tree type = TREE_TYPE (decl);
2969 if (type == error_mark_node)
2972 if (((type_quals & TYPE_QUAL_CONST)
2973 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2974 /* An object declared 'const' is only readonly after it is
2975 initialized. We don't have any way of expressing this currently,
2976 so we need to be conservative and unset TREE_READONLY for types
2977 with constructors. Otherwise aliasing code will ignore stores in
2978 an inline constructor. */
2979 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2980 TREE_READONLY (decl) = 1;
2981 if (type_quals & TYPE_QUAL_VOLATILE)
2983 TREE_SIDE_EFFECTS (decl) = 1;
2984 TREE_THIS_VOLATILE (decl) = 1;
2986 if (type_quals & TYPE_QUAL_RESTRICT)
2988 while (type && TREE_CODE (type) == ARRAY_TYPE)
2989 /* Allow 'restrict' on arrays of pointers.
2990 FIXME currently we just ignore it. */
2991 type = TREE_TYPE (type);
2993 || !POINTER_TYPE_P (type)
2994 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2995 error ("invalid use of %<restrict%>");
2996 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2997 /* Indicate we need to make a unique alias set for this pointer.
2998 We can't do it here because it might be pointing to an
3000 DECL_POINTER_ALIAS_SET (decl) = -2;
3004 /* Hash function for the problem of multiple type definitions in
3005 different files. This must hash all types that will compare
3006 equal via comptypes to the same value. In practice it hashes
3007 on some of the simple stuff and leaves the details to comptypes. */
3010 c_type_hash (const void *p)
3014 const_tree const t = (const_tree) p;
3016 switch (TREE_CODE (t))
3018 /* For pointers, hash on pointee type plus some swizzling. */
3020 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3021 /* Hash on number of elements and total size. */
3024 t2 = TYPE_VALUES (t);
3028 t2 = TYPE_FIELDS (t);
3030 case QUAL_UNION_TYPE:
3032 t2 = TYPE_FIELDS (t);
3036 t2 = TYPE_FIELDS (t);
3041 for (; t2; t2 = TREE_CHAIN (t2))
3043 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3044 return ((size << 24) | (i << shift));
3047 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3049 /* Return the typed-based alias set for T, which may be an expression
3050 or a type. Return -1 if we don't do anything special. */
3053 c_common_get_alias_set (tree t)
3058 /* Permit type-punning when accessing a union, provided the access
3059 is directly through the union. For example, this code does not
3060 permit taking the address of a union member and then storing
3061 through it. Even the type-punning allowed here is a GCC
3062 extension, albeit a common and useful one; the C standard says
3063 that such accesses have implementation-defined behavior. */
3065 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3066 u = TREE_OPERAND (u, 0))
3067 if (TREE_CODE (u) == COMPONENT_REF
3068 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3071 /* That's all the expressions we handle specially. */
3075 /* The C standard guarantees that any object may be accessed via an
3076 lvalue that has character type. */
3077 if (t == char_type_node
3078 || t == signed_char_type_node
3079 || t == unsigned_char_type_node)
3082 /* If it has the may_alias attribute, it can alias anything. */
3083 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
3086 /* The C standard specifically allows aliasing between signed and
3087 unsigned variants of the same type. We treat the signed
3088 variant as canonical. */
3089 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3091 tree t1 = c_common_signed_type (t);
3093 /* t1 == t can happen for boolean nodes which are always unsigned. */
3095 return get_alias_set (t1);
3097 else if (POINTER_TYPE_P (t))
3101 /* Unfortunately, there is no canonical form of a pointer type.
3102 In particular, if we have `typedef int I', then `int *', and
3103 `I *' are different types. So, we have to pick a canonical
3104 representative. We do this below.
3106 Technically, this approach is actually more conservative that
3107 it needs to be. In particular, `const int *' and `int *'
3108 should be in different alias sets, according to the C and C++
3109 standard, since their types are not the same, and so,
3110 technically, an `int **' and `const int **' cannot point at
3113 But, the standard is wrong. In particular, this code is
3118 const int* const* cipp = ipp;
3120 And, it doesn't make sense for that to be legal unless you
3121 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3122 the pointed-to types. This issue has been reported to the
3124 t1 = build_type_no_quals (t);
3126 return get_alias_set (t1);
3129 /* Handle the case of multiple type nodes referring to "the same" type,
3130 which occurs with IMA. These share an alias set. FIXME: Currently only
3131 C90 is handled. (In C99 type compatibility is not transitive, which
3132 complicates things mightily. The alias set splay trees can theoretically
3133 represent this, but insertion is tricky when you consider all the
3134 different orders things might arrive in.) */
3136 if (c_language != clk_c || flag_isoc99)
3139 /* Save time if there's only one input file. */
3140 if (num_in_fnames == 1)
3143 /* Pointers need special handling if they point to any type that
3144 needs special handling (below). */
3145 if (TREE_CODE (t) == POINTER_TYPE)
3148 /* Find bottom type under any nested POINTERs. */
3149 for (t2 = TREE_TYPE (t);
3150 TREE_CODE (t2) == POINTER_TYPE;
3151 t2 = TREE_TYPE (t2))
3153 if (TREE_CODE (t2) != RECORD_TYPE
3154 && TREE_CODE (t2) != ENUMERAL_TYPE
3155 && TREE_CODE (t2) != QUAL_UNION_TYPE
3156 && TREE_CODE (t2) != UNION_TYPE)
3158 if (TYPE_SIZE (t2) == 0)
3161 /* These are the only cases that need special handling. */
3162 if (TREE_CODE (t) != RECORD_TYPE
3163 && TREE_CODE (t) != ENUMERAL_TYPE
3164 && TREE_CODE (t) != QUAL_UNION_TYPE
3165 && TREE_CODE (t) != UNION_TYPE
3166 && TREE_CODE (t) != POINTER_TYPE)
3169 if (TYPE_SIZE (t) == 0)
3172 /* Look up t in hash table. Only one of the compatible types within each
3173 alias set is recorded in the table. */
3174 if (!type_hash_table)
3175 type_hash_table = htab_create_ggc (1021, c_type_hash,
3176 (htab_eq) lang_hooks.types_compatible_p,
3178 slot = htab_find_slot (type_hash_table, t, INSERT);
3181 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3182 return TYPE_ALIAS_SET ((tree)*slot);
3185 /* Our caller will assign and record (in t) a new alias set; all we need
3186 to do is remember t in the hash table. */
3192 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3193 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3194 flag controls whether we should diagnose possibly ill-formed
3195 constructs or not. */
3198 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3200 const char *op_name;
3202 enum tree_code type_code = TREE_CODE (type);
3204 op_name = is_sizeof ? "sizeof" : "__alignof__";
3206 if (type_code == FUNCTION_TYPE)
3210 if (complain && (pedantic || warn_pointer_arith))
3211 pedwarn ("invalid application of %<sizeof%> to a function type");
3212 value = size_one_node;
3215 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3217 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3219 if (type_code == VOID_TYPE
3220 && complain && (pedantic || warn_pointer_arith))
3221 pedwarn ("invalid application of %qs to a void type", op_name);
3222 value = size_one_node;
3224 else if (!COMPLETE_TYPE_P (type))
3227 error ("invalid application of %qs to incomplete type %qT ",
3229 value = size_zero_node;
3234 /* Convert in case a char is more than one unit. */
3235 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3236 size_int (TYPE_PRECISION (char_type_node)
3239 value = size_int (TYPE_ALIGN_UNIT (type));
3242 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3243 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3244 never happen. However, this node should really have type
3245 `size_t', which is just a typedef for an ordinary integer type. */
3246 value = fold_convert (size_type_node, value);
3247 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3252 /* Implement the __alignof keyword: Return the minimum required
3253 alignment of EXPR, measured in bytes. For VAR_DECLs,
3254 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3255 from an "aligned" __attribute__ specification). */
3258 c_alignof_expr (tree expr)
3262 if (VAR_OR_FUNCTION_DECL_P (expr))
3263 t = size_int (DECL_ALIGN_UNIT (expr));
3265 else if (TREE_CODE (expr) == COMPONENT_REF
3266 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3268 error ("%<__alignof%> applied to a bit-field");
3271 else if (TREE_CODE (expr) == COMPONENT_REF
3272 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3273 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3275 else if (TREE_CODE (expr) == INDIRECT_REF)
3277 tree t = TREE_OPERAND (expr, 0);
3279 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3281 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3282 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3286 t = TREE_OPERAND (t, 0);
3287 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3288 if (thisalign > bestalign)
3289 best = t, bestalign = thisalign;
3291 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3294 return c_alignof (TREE_TYPE (expr));
3296 return fold_convert (size_type_node, t);
3299 /* Handle C and C++ default attributes. */
3301 enum built_in_attribute
3303 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3304 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3305 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3306 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3307 #include "builtin-attrs.def"
3308 #undef DEF_ATTR_NULL_TREE
3310 #undef DEF_ATTR_IDENT
3311 #undef DEF_ATTR_TREE_LIST
3315 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3317 static void c_init_attributes (void);
3321 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3322 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3323 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3324 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3325 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3326 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3327 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3328 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3329 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3330 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3331 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3332 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3333 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3334 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3335 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3337 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3338 #include "builtin-types.def"
3339 #undef DEF_PRIMITIVE_TYPE
3340 #undef DEF_FUNCTION_TYPE_0
3341 #undef DEF_FUNCTION_TYPE_1
3342 #undef DEF_FUNCTION_TYPE_2
3343 #undef DEF_FUNCTION_TYPE_3
3344 #undef DEF_FUNCTION_TYPE_4
3345 #undef DEF_FUNCTION_TYPE_5
3346 #undef DEF_FUNCTION_TYPE_6
3347 #undef DEF_FUNCTION_TYPE_7
3348 #undef DEF_FUNCTION_TYPE_VAR_0
3349 #undef DEF_FUNCTION_TYPE_VAR_1
3350 #undef DEF_FUNCTION_TYPE_VAR_2
3351 #undef DEF_FUNCTION_TYPE_VAR_3
3352 #undef DEF_FUNCTION_TYPE_VAR_4
3353 #undef DEF_FUNCTION_TYPE_VAR_5
3354 #undef DEF_POINTER_TYPE
3358 typedef enum c_builtin_type builtin_type;
3360 /* A temporary array for c_common_nodes_and_builtins. Used in
3361 communication with def_fn_type. */
3362 static tree builtin_types[(int) BT_LAST + 1];
3364 /* A helper function for c_common_nodes_and_builtins. Build function type
3365 for DEF with return type RET and N arguments. If VAR is true, then the
3366 function should be variadic after those N arguments.
3368 Takes special care not to ICE if any of the types involved are
3369 error_mark_node, which indicates that said type is not in fact available
3370 (see builtin_type_for_size). In which case the function type as a whole
3371 should be error_mark_node. */
3374 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3376 tree args = NULL, t;
3381 for (i = 0; i < n; ++i)
3383 builtin_type a = va_arg (list, builtin_type);
3384 t = builtin_types[a];
3385 if (t == error_mark_node)
3387 args = tree_cons (NULL_TREE, t, args);
3391 args = nreverse (args);
3393 args = chainon (args, void_list_node);
3395 t = builtin_types[ret];
3396 if (t == error_mark_node)
3398 t = build_function_type (t, args);
3401 builtin_types[def] = t;
3404 /* Build builtin functions common to both C and C++ language
3408 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3410 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3411 builtin_types[ENUM] = VALUE;
3412 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3413 def_fn_type (ENUM, RETURN, 0, 0);
3414 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3415 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3416 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3417 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3418 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3419 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3420 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3421 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3422 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3423 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3424 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3426 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3427 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3429 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3430 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3431 def_fn_type (ENUM, RETURN, 1, 0);
3432 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3433 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3434 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3435 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3436 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3437 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3438 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3439 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3440 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3441 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3442 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3443 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3445 #include "builtin-types.def"
3447 #undef DEF_PRIMITIVE_TYPE
3448 #undef DEF_FUNCTION_TYPE_1
3449 #undef DEF_FUNCTION_TYPE_2
3450 #undef DEF_FUNCTION_TYPE_3
3451 #undef DEF_FUNCTION_TYPE_4
3452 #undef DEF_FUNCTION_TYPE_5
3453 #undef DEF_FUNCTION_TYPE_6
3454 #undef DEF_FUNCTION_TYPE_VAR_0
3455 #undef DEF_FUNCTION_TYPE_VAR_1
3456 #undef DEF_FUNCTION_TYPE_VAR_2
3457 #undef DEF_FUNCTION_TYPE_VAR_3
3458 #undef DEF_FUNCTION_TYPE_VAR_4
3459 #undef DEF_FUNCTION_TYPE_VAR_5
3460 #undef DEF_POINTER_TYPE
3461 builtin_types[(int) BT_LAST] = NULL_TREE;
3463 c_init_attributes ();
3465 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3466 NONANSI_P, ATTRS, IMPLICIT, COND) \
3468 def_builtin_1 (ENUM, NAME, CLASS, \
3469 builtin_types[(int) TYPE], \
3470 builtin_types[(int) LIBTYPE], \
3471 BOTH_P, FALLBACK_P, NONANSI_P, \
3472 built_in_attributes[(int) ATTRS], IMPLICIT);
3473 #include "builtins.def"
3476 targetm.init_builtins ();
3478 build_common_builtin_nodes ();
3484 /* Build tree nodes and builtin functions common to both C and C++ language
3488 c_common_nodes_and_builtins (void)
3490 int wchar_type_size;
3491 tree array_domain_type;
3492 tree va_list_ref_type_node;
3493 tree va_list_arg_type_node;
3495 /* Define `int' and `char' first so that dbx will output them first. */
3496 record_builtin_type (RID_INT, NULL, integer_type_node);
3497 record_builtin_type (RID_CHAR, "char", char_type_node);
3499 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3500 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3501 but not C. Are the conditionals here needed? */
3502 if (c_dialect_cxx ())
3503 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3504 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3505 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3506 record_builtin_type (RID_MAX, "long unsigned int",
3507 long_unsigned_type_node);
3508 if (c_dialect_cxx ())
3509 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3510 record_builtin_type (RID_MAX, "long long int",
3511 long_long_integer_type_node);
3512 record_builtin_type (RID_MAX, "long long unsigned int",
3513 long_long_unsigned_type_node);
3514 if (c_dialect_cxx ())
3515 record_builtin_type (RID_MAX, "long long unsigned",
3516 long_long_unsigned_type_node);
3517 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3518 record_builtin_type (RID_MAX, "short unsigned int",
3519 short_unsigned_type_node);
3520 if (c_dialect_cxx ())
3521 record_builtin_type (RID_MAX, "unsigned short",
3522 short_unsigned_type_node);
3524 /* Define both `signed char' and `unsigned char'. */
3525 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3526 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3528 /* These are types that c_common_type_for_size and
3529 c_common_type_for_mode use. */
3530 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3532 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3534 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3536 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3538 #if HOST_BITS_PER_WIDE_INT >= 64
3539 if (targetm.scalar_mode_supported_p (TImode))
3540 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3541 get_identifier ("__int128_t"),
3544 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3545 unsigned_intQI_type_node));
3546 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3547 unsigned_intHI_type_node));
3548 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3549 unsigned_intSI_type_node));
3550 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3551 unsigned_intDI_type_node));
3552 #if HOST_BITS_PER_WIDE_INT >= 64
3553 if (targetm.scalar_mode_supported_p (TImode))
3554 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3555 get_identifier ("__uint128_t"),
3556 unsigned_intTI_type_node));
3559 /* Create the widest literal types. */
3560 widest_integer_literal_type_node
3561 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3562 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3563 widest_integer_literal_type_node));
3565 widest_unsigned_literal_type_node
3566 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3567 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3568 widest_unsigned_literal_type_node));
3570 /* `unsigned long' is the standard type for sizeof.
3571 Note that stddef.h uses `unsigned long',
3572 and this must agree, even if long and int are the same size. */
3574 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3575 signed_size_type_node = c_common_signed_type (size_type_node);
3576 set_sizetype (size_type_node);
3579 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3581 build_common_tree_nodes_2 (flag_short_double);
3583 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3584 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3585 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3587 /* Only supported decimal floating point extension if the target
3588 actually supports underlying modes. */
3589 if (targetm.scalar_mode_supported_p (SDmode)
3590 && targetm.scalar_mode_supported_p (DDmode)
3591 && targetm.scalar_mode_supported_p (TDmode))
3593 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3594 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3595 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3598 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3599 get_identifier ("complex int"),
3600 complex_integer_type_node));
3601 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3602 get_identifier ("complex float"),
3603 complex_float_type_node));
3604 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3605 get_identifier ("complex double"),
3606 complex_double_type_node));
3607 lang_hooks.decls.pushdecl
3608 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3609 complex_long_double_type_node));
3611 if (c_dialect_cxx ())
3612 /* For C++, make fileptr_type_node a distinct void * type until
3613 FILE type is defined. */
3614 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3616 record_builtin_type (RID_VOID, NULL, void_type_node);
3618 /* Set the TYPE_NAME for any variants that were built before
3619 record_builtin_type gave names to the built-in types. */
3621 tree void_name = TYPE_NAME (void_type_node);
3622 TYPE_NAME (void_type_node) = NULL_TREE;
3623 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
3625 TYPE_NAME (void_type_node) = void_name;
3628 /* This node must not be shared. */
3629 void_zero_node = make_node (INTEGER_CST);
3630 TREE_TYPE (void_zero_node) = void_type_node;
3632 void_list_node = build_void_list_node ();
3634 /* Make a type to be the domain of a few array types
3635 whose domains don't really matter.
3636 200 is small enough that it always fits in size_t
3637 and large enough that it can hold most function names for the
3638 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3639 array_domain_type = build_index_type (size_int (200));
3641 /* Make a type for arrays of characters.
3642 With luck nothing will ever really depend on the length of this
3644 char_array_type_node
3645 = build_array_type (char_type_node, array_domain_type);
3647 /* Likewise for arrays of ints. */
3649 = build_array_type (integer_type_node, array_domain_type);
3651 string_type_node = build_pointer_type (char_type_node);
3652 const_string_type_node
3653 = build_pointer_type (build_qualified_type
3654 (char_type_node, TYPE_QUAL_CONST));
3656 /* This is special for C++ so functions can be overloaded. */
3657 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3658 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3659 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3660 if (c_dialect_cxx ())
3662 if (TYPE_UNSIGNED (wchar_type_node))
3663 wchar_type_node = make_unsigned_type (wchar_type_size);
3665 wchar_type_node = make_signed_type (wchar_type_size);
3666 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3670 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3671 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3674 /* This is for wide string constants. */
3675 wchar_array_type_node
3676 = build_array_type (wchar_type_node, array_domain_type);
3679 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3682 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3684 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3686 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3688 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3689 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3691 lang_hooks.decls.pushdecl
3692 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3693 va_list_type_node));
3695 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3697 va_list_arg_type_node = va_list_ref_type_node =
3698 build_pointer_type (TREE_TYPE (va_list_type_node));
3702 va_list_arg_type_node = va_list_type_node;
3703 va_list_ref_type_node = build_reference_type (va_list_type_node);
3706 if (!flag_preprocess_only)
3707 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
3709 main_identifier_node = get_identifier ("main");
3711 /* Create the built-in __null node. It is important that this is
3713 null_node = make_node (INTEGER_CST);
3714 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3716 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3717 memset (builtin_types, 0, sizeof (builtin_types));
3720 /* Look up the function in built_in_decls that corresponds to DECL
3721 and set ASMSPEC as its user assembler name. DECL must be a
3722 function decl that declares a builtin. */
3725 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3728 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3729 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3732 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3733 set_user_assembler_name (builtin, asmspec);
3734 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3735 init_block_move_fn (asmspec);
3736 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3737 init_block_clear_fn (asmspec);
3740 /* The number of named compound-literals generated thus far. */
3741 static GTY(()) int compound_literal_number;
3743 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3746 set_compound_literal_name (tree decl)
3749 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3750 compound_literal_number);
3751 compound_literal_number++;
3752 DECL_NAME (decl) = get_identifier (name);
3756 build_va_arg (tree expr, tree type)
3758 return build1 (VA_ARG_EXPR, type, expr);
3762 /* Linked list of disabled built-in functions. */
3764 typedef struct disabled_builtin
3767 struct disabled_builtin *next;
3769 static disabled_builtin *disabled_builtins = NULL;
3771 static bool builtin_function_disabled_p (const char *);
3773 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3774 begins with "__builtin_", give an error. */
3777 disable_builtin_function (const char *name)
3779 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3780 error ("cannot disable built-in function %qs", name);
3783 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3784 new_disabled_builtin->name = name;
3785 new_disabled_builtin->next = disabled_builtins;
3786 disabled_builtins = new_disabled_builtin;
3791 /* Return true if the built-in function NAME has been disabled, false
3795 builtin_function_disabled_p (const char *name)
3797 disabled_builtin *p;
3798 for (p = disabled_builtins; p != NULL; p = p->next)
3800 if (strcmp (name, p->name) == 0)
3807 /* Worker for DEF_BUILTIN.
3808 Possibly define a builtin function with one or two names.
3809 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3810 nonansi_p and flag_no_nonansi_builtin. */
3813 def_builtin_1 (enum built_in_function fncode,
3815 enum built_in_class fnclass,
3816 tree fntype, tree libtype,
3817 bool both_p, bool fallback_p, bool nonansi_p,
3818 tree fnattrs, bool implicit_p)
3821 const char *libname;
3823 if (fntype == error_mark_node)
3826 gcc_assert ((!both_p && !fallback_p)
3827 || !strncmp (name, "__builtin_",
3828 strlen ("__builtin_")));
3830 libname = name + strlen ("__builtin_");
3831 decl = add_builtin_function (name, fntype, fncode, fnclass,
3832 (fallback_p ? libname : NULL),
3835 && !flag_no_builtin && !builtin_function_disabled_p (libname)
3836 && !(nonansi_p && flag_no_nonansi_builtin))
3837 add_builtin_function (libname, libtype, fncode, fnclass,
3840 built_in_decls[(int) fncode] = decl;
3842 implicit_built_in_decls[(int) fncode] = decl;
3845 /* Nonzero if the type T promotes to int. This is (nearly) the
3846 integral promotions defined in ISO C99 6.3.1.1/2. */
3849 c_promoting_integer_type_p (tree t)
3851 switch (TREE_CODE (t))
3854 return (TYPE_MAIN_VARIANT (t) == char_type_node
3855 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3856 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3857 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3858 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3859 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3862 /* ??? Technically all enumerations not larger than an int
3863 promote to an int. But this is used along code paths
3864 that only want to notice a size change. */
3865 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3875 /* Return 1 if PARMS specifies a fixed number of parameters
3876 and none of their types is affected by default promotions. */
3879 self_promoting_args_p (tree parms)
3882 for (t = parms; t; t = TREE_CHAIN (t))
3884 tree type = TREE_VALUE (t);
3886 if (type == error_mark_node)
3889 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3895 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3898 if (c_promoting_integer_type_p (type))
3904 /* Recursively examines the array elements of TYPE, until a non-array
3905 element type is found. */
3908 strip_array_types (tree type)
3910 while (TREE_CODE (type) == ARRAY_TYPE)
3911 type = TREE_TYPE (type);
3916 /* Recursively remove any '*' or '&' operator from TYPE. */
3918 strip_pointer_operator (tree t)
3920 while (POINTER_TYPE_P (t))
3925 /* Recursively remove pointer or array type from TYPE. */
3927 strip_pointer_or_array_types (tree t)
3929 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
3934 /* Used to compare case labels. K1 and K2 are actually tree nodes
3935 representing case labels, or NULL_TREE for a `default' label.
3936 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3937 K2, and 0 if K1 and K2 are equal. */
3940 case_compare (splay_tree_key k1, splay_tree_key k2)
3942 /* Consider a NULL key (such as arises with a `default' label) to be
3943 smaller than anything else. */
3949 return tree_int_cst_compare ((tree) k1, (tree) k2);
3952 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3953 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3954 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3955 case label was declared using the usual C/C++ syntax, rather than
3956 the GNU case range extension. CASES is a tree containing all the
3957 case ranges processed so far; COND is the condition for the
3958 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3959 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3962 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3963 tree low_value, tree high_value)
3968 splay_tree_node node;
3970 /* Create the LABEL_DECL itself. */
3971 label = create_artificial_label ();
3973 /* If there was an error processing the switch condition, bail now
3974 before we get more confused. */
3975 if (!cond || cond == error_mark_node)
3978 if ((low_value && TREE_TYPE (low_value)
3979 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3980 || (high_value && TREE_TYPE (high_value)
3981 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3983 error ("pointers are not permitted as case values");
3987 /* Case ranges are a GNU extension. */
3988 if (high_value && pedantic)
3989 pedwarn ("range expressions in switch statements are non-standard");
3991 type = TREE_TYPE (cond);
3994 low_value = check_case_value (low_value);
3995 low_value = convert_and_check (type, low_value);
3996 if (low_value == error_mark_node)
4001 high_value = check_case_value (high_value);
4002 high_value = convert_and_check (type, high_value);
4003 if (high_value == error_mark_node)
4007 if (low_value && high_value)
4009 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4010 really a case range, even though it was written that way.
4011 Remove the HIGH_VALUE to simplify later processing. */
4012 if (tree_int_cst_equal (low_value, high_value))
4013 high_value = NULL_TREE;
4014 else if (!tree_int_cst_lt (low_value, high_value))
4015 warning (0, "empty range specified");
4018 /* See if the case is in range of the type of the original testing
4019 expression. If both low_value and high_value are out of range,
4020 don't insert the case label and return NULL_TREE. */
4022 && !check_case_bounds (type, orig_type,
4023 &low_value, high_value ? &high_value : NULL))
4026 /* Look up the LOW_VALUE in the table of case labels we already
4028 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4029 /* If there was not an exact match, check for overlapping ranges.
4030 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4031 that's a `default' label and the only overlap is an exact match. */
4032 if (!node && (low_value || high_value))
4034 splay_tree_node low_bound;
4035 splay_tree_node high_bound;
4037 /* Even though there wasn't an exact match, there might be an
4038 overlap between this case range and another case range.
4039 Since we've (inductively) not allowed any overlapping case
4040 ranges, we simply need to find the greatest low case label
4041 that is smaller that LOW_VALUE, and the smallest low case
4042 label that is greater than LOW_VALUE. If there is an overlap
4043 it will occur in one of these two ranges. */
4044 low_bound = splay_tree_predecessor (cases,
4045 (splay_tree_key) low_value);
4046 high_bound = splay_tree_successor (cases,
4047 (splay_tree_key) low_value);
4049 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4050 the LOW_VALUE, so there is no need to check unless the
4051 LOW_BOUND is in fact itself a case range. */
4053 && CASE_HIGH ((tree) low_bound->value)
4054 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4057 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4058 range is bigger than the low end of the current range, so we
4059 are only interested if the current range is a real range, and
4060 not an ordinary case label. */
4063 && (tree_int_cst_compare ((tree) high_bound->key,
4068 /* If there was an overlap, issue an error. */
4071 tree duplicate = CASE_LABEL ((tree) node->value);
4075 error ("duplicate (or overlapping) case value");
4076 error ("%Jthis is the first entry overlapping that value", duplicate);
4080 error ("duplicate case value") ;
4081 error ("%Jpreviously used here", duplicate);
4085 error ("multiple default labels in one switch");
4086 error ("%Jthis is the first default label", duplicate);
4091 /* Add a CASE_LABEL to the statement-tree. */
4092 case_label = add_stmt (build_case_label (low_value, high_value, label));
4093 /* Register this case label in the splay tree. */
4094 splay_tree_insert (cases,
4095 (splay_tree_key) low_value,
4096 (splay_tree_value) case_label);
4101 /* Add a label so that the back-end doesn't think that the beginning of
4102 the switch is unreachable. Note that we do not add a case label, as
4103 that just leads to duplicates and thence to failure later on. */
4106 tree t = create_artificial_label ();
4107 add_stmt (build_stmt (LABEL_EXPR, t));
4109 return error_mark_node;
4112 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4113 Used to verify that case values match up with enumerator values. */
4116 match_case_to_enum_1 (tree key, tree type, tree label)
4118 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4120 /* ??? Not working too hard to print the double-word value.
4121 Should perhaps be done with %lwd in the diagnostic routines? */
4122 if (TREE_INT_CST_HIGH (key) == 0)
4123 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4124 TREE_INT_CST_LOW (key));
4125 else if (!TYPE_UNSIGNED (type)
4126 && TREE_INT_CST_HIGH (key) == -1
4127 && TREE_INT_CST_LOW (key) != 0)
4128 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4129 -TREE_INT_CST_LOW (key));
4131 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4132 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
4134 if (TYPE_NAME (type) == 0)
4135 warning (0, "%Jcase value %qs not in enumerated type",
4136 CASE_LABEL (label), buf);
4138 warning (0, "%Jcase value %qs not in enumerated type %qT",
4139 CASE_LABEL (label), buf, type);
4142 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4143 Used to verify that case values match up with enumerator values. */
4146 match_case_to_enum (splay_tree_node node, void *data)
4148 tree label = (tree) node->value;
4149 tree type = (tree) data;
4151 /* Skip default case. */
4152 if (!CASE_LOW (label))
4155 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4156 when we did our enum->case scan. Reset our scratch bit after. */
4157 if (!CASE_LOW_SEEN (label))
4158 match_case_to_enum_1 (CASE_LOW (label), type, label);
4160 CASE_LOW_SEEN (label) = 0;
4162 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4163 not set, that means that CASE_HIGH did not appear when we did our
4164 enum->case scan. Reset our scratch bit after. */
4165 if (CASE_HIGH (label))
4167 if (!CASE_HIGH_SEEN (label))
4168 match_case_to_enum_1 (CASE_HIGH (label), type, label);
4170 CASE_HIGH_SEEN (label) = 0;
4176 /* Handle -Wswitch*. Called from the front end after parsing the
4177 switch construct. */
4178 /* ??? Should probably be somewhere generic, since other languages
4179 besides C and C++ would want this. At the moment, however, C/C++
4180 are the only tree-ssa languages that support enumerations at all,
4181 so the point is moot. */
4184 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4185 tree type, tree cond)
4187 splay_tree_node default_node;
4188 splay_tree_node node;
4191 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4194 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4196 warning (OPT_Wswitch_default, "%Hswitch missing default case",
4199 /* From here on, we only care about about enumerated types. */
4200 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4203 /* If the switch expression was an enumerated type, check that
4204 exactly all enumeration literals are covered by the cases.
4205 The check is made when -Wswitch was specified and there is no
4206 default case, or when -Wswitch-enum was specified. */
4208 if (!warn_switch_enum
4209 && !(warn_switch && !default_node))
4212 /* Clearing COND if it is not an integer constant simplifies
4213 the tests inside the loop below. */
4214 if (TREE_CODE (cond) != INTEGER_CST)
4217 /* The time complexity here is O(N*lg(N)) worst case, but for the
4218 common case of monotonically increasing enumerators, it is
4219 O(N), since the nature of the splay tree will keep the next
4220 element adjacent to the root at all times. */
4222 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4224 tree value = TREE_VALUE (chain);
4225 node = splay_tree_lookup (cases, (splay_tree_key) value);
4228 /* Mark the CASE_LOW part of the case entry as seen. */
4229 tree label = (tree) node->value;
4230 CASE_LOW_SEEN (label) = 1;
4234 /* Even though there wasn't an exact match, there might be a
4235 case range which includes the enumator's value. */
4236 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4237 if (node && CASE_HIGH ((tree) node->value))
4239 tree label = (tree) node->value;
4240 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4243 /* If we match the upper bound exactly, mark the CASE_HIGH
4244 part of the case entry as seen. */
4246 CASE_HIGH_SEEN (label) = 1;
4251 /* We've now determined that this enumerated literal isn't
4252 handled by the case labels of the switch statement. */
4254 /* If the switch expression is a constant, we only really care
4255 about whether that constant is handled by the switch. */
4256 if (cond && tree_int_cst_compare (cond, value))
4259 warning (0, "%Henumeration value %qE not handled in switch",
4260 &switch_location, TREE_PURPOSE (chain));
4263 /* Warn if there are case expressions that don't correspond to
4264 enumerators. This can occur since C and C++ don't enforce
4265 type-checking of assignments to enumeration variables.
4267 The time complexity here is now always O(N) worst case, since
4268 we should have marked both the lower bound and upper bound of
4269 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4270 above. This scan also resets those fields. */
4271 splay_tree_foreach (cases, match_case_to_enum, type);
4274 /* Finish an expression taking the address of LABEL (an
4275 IDENTIFIER_NODE). Returns an expression for the address. */
4278 finish_label_address_expr (tree label)
4283 pedwarn ("taking the address of a label is non-standard");
4285 if (label == error_mark_node)
4286 return error_mark_node;
4288 label = lookup_label (label);
4289 if (label == NULL_TREE)
4290 result = null_pointer_node;
4293 TREE_USED (label) = 1;
4294 result = build1 (ADDR_EXPR, ptr_type_node, label);
4295 /* The current function in not necessarily uninlinable.
4296 Computed gotos are incompatible with inlining, but the value
4297 here could be used only in a diagnostic, for example. */
4303 /* Hook used by expand_expr to expand language-specific tree codes. */
4304 /* The only things that should go here are bits needed to expand
4305 constant initializers. Everything else should be handled by the
4306 gimplification routines. */
4309 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4310 int modifier /* Actually enum_modifier. */,
4313 switch (TREE_CODE (exp))
4315 case COMPOUND_LITERAL_EXPR:
4317 /* Initialize the anonymous variable declared in the compound
4318 literal, then return the variable. */
4319 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4320 emit_local_var (decl);
4321 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4330 /* Generate the RTL for the body of FNDECL. */
4333 c_expand_body (tree fndecl)
4335 tree_rest_of_compilation (fndecl);
4338 /* Hook used by staticp to handle language-specific tree codes. */
4341 c_staticp (tree exp)
4343 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4344 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4349 /* Given a boolean expression ARG, return a tree representing an increment
4350 or decrement (as indicated by CODE) of ARG. The front end must check for
4351 invalid cases (e.g., decrement in C++). */
4353 boolean_increment (enum tree_code code, tree arg)
4356 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
4358 arg = stabilize_reference (arg);
4361 case PREINCREMENT_EXPR:
4362 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4364 case POSTINCREMENT_EXPR:
4365 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4366 arg = save_expr (arg);
4367 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4368 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4370 case PREDECREMENT_EXPR:
4371 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4372 invert_truthvalue (arg));
4374 case POSTDECREMENT_EXPR:
4375 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4376 invert_truthvalue (arg));
4377 arg = save_expr (arg);
4378 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4379 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4384 TREE_SIDE_EFFECTS (val) = 1;
4388 /* Built-in macros for stddef.h, that require macros defined in this
4391 c_stddef_cpp_builtins(void)
4393 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4394 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4395 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4396 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4397 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4398 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4402 c_init_attributes (void)
4404 /* Fill in the built_in_attributes array. */
4405 #define DEF_ATTR_NULL_TREE(ENUM) \
4406 built_in_attributes[(int) ENUM] = NULL_TREE;
4407 #define DEF_ATTR_INT(ENUM, VALUE) \
4408 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4409 #define DEF_ATTR_IDENT(ENUM, STRING) \
4410 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4411 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4412 built_in_attributes[(int) ENUM] \
4413 = tree_cons (built_in_attributes[(int) PURPOSE], \
4414 built_in_attributes[(int) VALUE], \
4415 built_in_attributes[(int) CHAIN]);
4416 #include "builtin-attrs.def"
4417 #undef DEF_ATTR_NULL_TREE
4419 #undef DEF_ATTR_IDENT
4420 #undef DEF_ATTR_TREE_LIST
4423 /* Attribute handlers common to C front ends. */
4425 /* Handle a "packed" attribute; arguments as in
4426 struct attribute_spec.handler. */
4429 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4430 int flags, bool *no_add_attrs)
4434 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4435 *node = build_variant_type_copy (*node);
4436 TYPE_PACKED (*node) = 1;
4438 else if (TREE_CODE (*node) == FIELD_DECL)
4440 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4441 warning (OPT_Wattributes,
4442 "%qE attribute ignored for field of type %qT",
4443 name, TREE_TYPE (*node));
4445 DECL_PACKED (*node) = 1;
4447 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4448 used for DECL_REGISTER. It wouldn't mean anything anyway.
4449 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4450 that changes what the typedef is typing. */
4453 warning (OPT_Wattributes, "%qE attribute ignored", name);
4454 *no_add_attrs = true;
4460 /* Handle a "nocommon" attribute; arguments as in
4461 struct attribute_spec.handler. */
4464 handle_nocommon_attribute (tree *node, tree name,
4465 tree ARG_UNUSED (args),
4466 int ARG_UNUSED (flags), bool *no_add_attrs)
4468 if (TREE_CODE (*node) == VAR_DECL)
4469 DECL_COMMON (*node) = 0;
4472 warning (OPT_Wattributes, "%qE attribute ignored", name);
4473 *no_add_attrs = true;
4479 /* Handle a "common" attribute; arguments as in
4480 struct attribute_spec.handler. */
4483 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4484 int ARG_UNUSED (flags), bool *no_add_attrs)
4486 if (TREE_CODE (*node) == VAR_DECL)
4487 DECL_COMMON (*node) = 1;
4490 warning (OPT_Wattributes, "%qE attribute ignored", name);
4491 *no_add_attrs = true;
4497 /* Handle a "noreturn" attribute; arguments as in
4498 struct attribute_spec.handler. */
4501 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4502 int ARG_UNUSED (flags), bool *no_add_attrs)
4504 tree type = TREE_TYPE (*node);
4506 /* See FIXME comment in c_common_attribute_table. */
4507 if (TREE_CODE (*node) == FUNCTION_DECL)
4508 TREE_THIS_VOLATILE (*node) = 1;
4509 else if (TREE_CODE (type) == POINTER_TYPE
4510 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4512 = build_pointer_type
4513 (build_type_variant (TREE_TYPE (type),
4514 TYPE_READONLY (TREE_TYPE (type)), 1));
4517 warning (OPT_Wattributes, "%qE attribute ignored", name);
4518 *no_add_attrs = true;
4524 /* Handle a "hot" and attribute; arguments as in
4525 struct attribute_spec.handler. */
4528 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4529 int ARG_UNUSED (flags), bool *no_add_attrs)
4531 if (TREE_CODE (*node) == FUNCTION_DECL)
4533 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
4535 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4537 *no_add_attrs = true;
4539 /* Do nothing else, just set the attribute. We'll get at
4540 it later with lookup_attribute. */
4544 warning (OPT_Wattributes, "%qE attribute ignored", name);
4545 *no_add_attrs = true;
4550 /* Handle a "cold" and attribute; arguments as in
4551 struct attribute_spec.handler. */
4554 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4555 int ARG_UNUSED (flags), bool *no_add_attrs)
4557 if (TREE_CODE (*node) == FUNCTION_DECL)
4559 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
4561 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4563 *no_add_attrs = true;
4565 /* Do nothing else, just set the attribute. We'll get at
4566 it later with lookup_attribute. */
4570 warning (OPT_Wattributes, "%qE attribute ignored", name);
4571 *no_add_attrs = true;
4577 /* Handle a "noinline" attribute; arguments as in
4578 struct attribute_spec.handler. */
4581 handle_noinline_attribute (tree *node, tree name,
4582 tree ARG_UNUSED (args),
4583 int ARG_UNUSED (flags), bool *no_add_attrs)
4585 if (TREE_CODE (*node) == FUNCTION_DECL)
4586 DECL_UNINLINABLE (*node) = 1;
4589 warning (OPT_Wattributes, "%qE attribute ignored", name);
4590 *no_add_attrs = true;
4596 /* Handle a "always_inline" attribute; arguments as in
4597 struct attribute_spec.handler. */
4600 handle_always_inline_attribute (tree *node, tree name,
4601 tree ARG_UNUSED (args),
4602 int ARG_UNUSED (flags),
4605 if (TREE_CODE (*node) == FUNCTION_DECL)
4607 /* Do nothing else, just set the attribute. We'll get at
4608 it later with lookup_attribute. */
4612 warning (OPT_Wattributes, "%qE attribute ignored", name);
4613 *no_add_attrs = true;
4619 /* Handle a "gnu_inline" attribute; arguments as in
4620 struct attribute_spec.handler. */
4623 handle_gnu_inline_attribute (tree *node, tree name,
4624 tree ARG_UNUSED (args),
4625 int ARG_UNUSED (flags),
4628 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4630 /* Do nothing else, just set the attribute. We'll get at
4631 it later with lookup_attribute. */
4635 warning (OPT_Wattributes, "%qE attribute ignored", name);
4636 *no_add_attrs = true;
4642 /* Handle a "flatten" attribute; arguments as in
4643 struct attribute_spec.handler. */
4646 handle_flatten_attribute (tree *node, tree name,
4647 tree args ATTRIBUTE_UNUSED,
4648 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4650 if (TREE_CODE (*node) == FUNCTION_DECL)
4651 /* Do nothing else, just set the attribute. We'll get at
4652 it later with lookup_attribute. */
4656 warning (OPT_Wattributes, "%qE attribute ignored", name);
4657 *no_add_attrs = true;
4664 /* Handle a "used" attribute; arguments as in
4665 struct attribute_spec.handler. */
4668 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4669 int ARG_UNUSED (flags), bool *no_add_attrs)
4673 if (TREE_CODE (node) == FUNCTION_DECL
4674 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4676 TREE_USED (node) = 1;
4677 DECL_PRESERVE_P (node) = 1;
4681 warning (OPT_Wattributes, "%qE attribute ignored", name);
4682 *no_add_attrs = true;
4688 /* Handle a "unused" attribute; arguments as in
4689 struct attribute_spec.handler. */
4692 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4693 int flags, bool *no_add_attrs)
4699 if (TREE_CODE (decl) == PARM_DECL
4700 || TREE_CODE (decl) == VAR_DECL
4701 || TREE_CODE (decl) == FUNCTION_DECL
4702 || TREE_CODE (decl) == LABEL_DECL
4703 || TREE_CODE (decl) == TYPE_DECL)
4704 TREE_USED (decl) = 1;
4707 warning (OPT_Wattributes, "%qE attribute ignored", name);
4708 *no_add_attrs = true;
4713 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4714 *node = build_variant_type_copy (*node);
4715 TREE_USED (*node) = 1;
4721 /* Handle a "externally_visible" attribute; arguments as in
4722 struct attribute_spec.handler. */
4725 handle_externally_visible_attribute (tree *pnode, tree name,
4726 tree ARG_UNUSED (args),
4727 int ARG_UNUSED (flags),
4732 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4734 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4735 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4737 warning (OPT_Wattributes,
4738 "%qE attribute have effect only on public objects", name);
4739 *no_add_attrs = true;
4744 warning (OPT_Wattributes, "%qE attribute ignored", name);
4745 *no_add_attrs = true;
4751 /* Handle a "const" attribute; arguments as in
4752 struct attribute_spec.handler. */
4755 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4756 int ARG_UNUSED (flags), bool *no_add_attrs)
4758 tree type = TREE_TYPE (*node);
4760 /* See FIXME comment on noreturn in c_common_attribute_table. */
4761 if (TREE_CODE (*node) == FUNCTION_DECL)
4762 TREE_READONLY (*node) = 1;
4763 else if (TREE_CODE (type) == POINTER_TYPE
4764 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4766 = build_pointer_type
4767 (build_type_variant (TREE_TYPE (type), 1,
4768 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4771 warning (OPT_Wattributes, "%qE attribute ignored", name);
4772 *no_add_attrs = true;
4778 /* Handle a "transparent_union" attribute; arguments as in
4779 struct attribute_spec.handler. */
4782 handle_transparent_union_attribute (tree *node, tree name,
4783 tree ARG_UNUSED (args), int flags,
4788 *no_add_attrs = true;
4792 if (TREE_CODE (*node) != TYPE_DECL)
4794 node = &TREE_TYPE (*node);
4797 else if (TYPE_P (*node))
4802 if (TREE_CODE (type) == UNION_TYPE)
4804 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4805 the code in finish_struct. */
4806 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4808 if (TYPE_FIELDS (type) == NULL_TREE
4809 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4812 /* A type variant isn't good enough, since we don't a cast
4813 to such a type removed as a no-op. */
4814 *node = type = build_duplicate_type (type);
4817 TYPE_TRANSPARENT_UNION (type) = 1;
4822 warning (OPT_Wattributes, "%qE attribute ignored", name);
4826 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
4827 get the requested priority for a constructor or destructor,
4828 possibly issuing diagnostics for invalid or reserved
4831 static priority_type
4832 get_priority (tree args, bool is_destructor)
4838 return DEFAULT_INIT_PRIORITY;
4840 if (!SUPPORTS_INIT_PRIORITY)
4843 error ("destructor priorities are not supported");
4845 error ("constructor priorities are not supported");
4846 return DEFAULT_INIT_PRIORITY;
4849 arg = TREE_VALUE (args);
4850 if (!host_integerp (arg, /*pos=*/0)
4851 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4854 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
4855 if (pri < 0 || pri > MAX_INIT_PRIORITY)
4858 if (pri <= MAX_RESERVED_INIT_PRIORITY)
4862 "destructor priorities from 0 to %d are reserved "
4863 "for the implementation",
4864 MAX_RESERVED_INIT_PRIORITY);
4867 "constructor priorities from 0 to %d are reserved "
4868 "for the implementation",
4869 MAX_RESERVED_INIT_PRIORITY);
4875 error ("destructor priorities must be integers from 0 to %d inclusive",
4878 error ("constructor priorities must be integers from 0 to %d inclusive",
4880 return DEFAULT_INIT_PRIORITY;
4883 /* Handle a "constructor" attribute; arguments as in
4884 struct attribute_spec.handler. */
4887 handle_constructor_attribute (tree *node, tree name, tree args,
4888 int ARG_UNUSED (flags),
4892 tree type = TREE_TYPE (decl);
4894 if (TREE_CODE (decl) == FUNCTION_DECL
4895 && TREE_CODE (type) == FUNCTION_TYPE
4896 && decl_function_context (decl) == 0)
4898 priority_type priority;
4899 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4900 priority = get_priority (args, /*is_destructor=*/false);
4901 SET_DECL_INIT_PRIORITY (decl, priority);
4902 TREE_USED (decl) = 1;
4906 warning (OPT_Wattributes, "%qE attribute ignored", name);
4907 *no_add_attrs = true;
4913 /* Handle a "destructor" attribute; arguments as in
4914 struct attribute_spec.handler. */
4917 handle_destructor_attribute (tree *node, tree name, tree args,
4918 int ARG_UNUSED (flags),
4922 tree type = TREE_TYPE (decl);
4924 if (TREE_CODE (decl) == FUNCTION_DECL
4925 && TREE_CODE (type) == FUNCTION_TYPE
4926 && decl_function_context (decl) == 0)
4928 priority_type priority;
4929 DECL_STATIC_DESTRUCTOR (decl) = 1;
4930 priority = get_priority (args, /*is_destructor=*/true);
4931 SET_DECL_FINI_PRIORITY (decl, priority);
4932 TREE_USED (decl) = 1;
4936 warning (OPT_Wattributes, "%qE attribute ignored", name);
4937 *no_add_attrs = true;
4943 /* Handle a "mode" attribute; arguments as in
4944 struct attribute_spec.handler. */
4947 handle_mode_attribute (tree *node, tree name, tree args,
4948 int ARG_UNUSED (flags), bool *no_add_attrs)
4952 *no_add_attrs = true;
4954 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4955 warning (OPT_Wattributes, "%qE attribute ignored", name);
4959 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4960 int len = strlen (p);
4961 enum machine_mode mode = VOIDmode;
4965 if (len > 4 && p[0] == '_' && p[1] == '_'
4966 && p[len - 1] == '_' && p[len - 2] == '_')
4968 char *newp = (char *) alloca (len - 1);
4970 strcpy (newp, &p[2]);
4971 newp[len - 4] = '\0';
4975 /* Change this type to have a type with the specified mode.
4976 First check for the special modes. */
4977 if (!strcmp (p, "byte"))
4979 else if (!strcmp (p, "word"))
4981 else if (!strcmp (p, "pointer"))
4983 else if (!strcmp (p, "libgcc_cmp_return"))
4984 mode = targetm.libgcc_cmp_return_mode ();
4985 else if (!strcmp (p, "libgcc_shift_count"))
4986 mode = targetm.libgcc_shift_count_mode ();
4988 for (j = 0; j < NUM_MACHINE_MODES; j++)
4989 if (!strcmp (p, GET_MODE_NAME (j)))
4991 mode = (enum machine_mode) j;
4995 if (mode == VOIDmode)
4997 error ("unknown machine mode %qs", p);
5002 switch (GET_MODE_CLASS (mode))
5005 case MODE_PARTIAL_INT:
5007 case MODE_DECIMAL_FLOAT:
5008 valid_mode = targetm.scalar_mode_supported_p (mode);
5011 case MODE_COMPLEX_INT:
5012 case MODE_COMPLEX_FLOAT:
5013 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5016 case MODE_VECTOR_INT:
5017 case MODE_VECTOR_FLOAT:
5018 warning (OPT_Wattributes, "specifying vector types with "
5019 "__attribute__ ((mode)) is deprecated");
5020 warning (OPT_Wattributes,
5021 "use __attribute__ ((vector_size)) instead");
5022 valid_mode = vector_mode_valid_p (mode);
5030 error ("unable to emulate %qs", p);
5034 if (POINTER_TYPE_P (type))
5036 tree (*fn)(tree, enum machine_mode, bool);
5038 if (!targetm.valid_pointer_mode (mode))
5040 error ("invalid pointer mode %qs", p);
5044 if (TREE_CODE (type) == POINTER_TYPE)
5045 fn = build_pointer_type_for_mode;
5047 fn = build_reference_type_for_mode;
5048 typefm = fn (TREE_TYPE (type), mode, false);
5051 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
5053 if (typefm == NULL_TREE)
5055 error ("no data type for mode %qs", p);
5058 else if (TREE_CODE (type) == ENUMERAL_TYPE)
5060 /* For enumeral types, copy the precision from the integer
5061 type returned above. If not an INTEGER_TYPE, we can't use
5062 this mode for this type. */
5063 if (TREE_CODE (typefm) != INTEGER_TYPE)
5065 error ("cannot use mode %qs for enumeral types", p);
5069 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5071 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5076 /* We cannot build a type variant, as there's code that assumes
5077 that TYPE_MAIN_VARIANT has the same mode. This includes the
5078 debug generators. Instead, create a subrange type. This
5079 results in all of the enumeral values being emitted only once
5080 in the original, and the subtype gets them by reference. */
5081 if (TYPE_UNSIGNED (type))
5082 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5084 typefm = make_signed_type (TYPE_PRECISION (typefm));
5085 TREE_TYPE (typefm) = type;
5088 else if (VECTOR_MODE_P (mode)
5089 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5090 : TREE_CODE (type) != TREE_CODE (typefm))
5092 error ("mode %qs applied to inappropriate type", p);
5102 /* Handle a "section" attribute; arguments as in
5103 struct attribute_spec.handler. */
5106 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5107 int ARG_UNUSED (flags), bool *no_add_attrs)
5111 if (targetm.have_named_sections)
5113 user_defined_section_attribute = true;
5115 if ((TREE_CODE (decl) == FUNCTION_DECL
5116 || TREE_CODE (decl) == VAR_DECL)
5117 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5119 if (TREE_CODE (decl) == VAR_DECL
5120 && current_function_decl != NULL_TREE
5121 && !TREE_STATIC (decl))
5123 error ("%Jsection attribute cannot be specified for "
5124 "local variables", decl);
5125 *no_add_attrs = true;
5128 /* The decl may have already been given a section attribute
5129 from a previous declaration. Ensure they match. */
5130 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5131 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5132 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5134 error ("section of %q+D conflicts with previous declaration",
5136 *no_add_attrs = true;
5139 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5143 error ("section attribute not allowed for %q+D", *node);
5144 *no_add_attrs = true;
5149 error ("%Jsection attributes are not supported for this target", *node);
5150 *no_add_attrs = true;
5156 /* Handle a "aligned" attribute; arguments as in
5157 struct attribute_spec.handler. */
5160 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5161 int flags, bool *no_add_attrs)
5163 tree decl = NULL_TREE;
5166 tree align_expr = (args ? TREE_VALUE (args)
5167 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5173 type = &TREE_TYPE (decl);
5174 is_type = TREE_CODE (*node) == TYPE_DECL;
5176 else if (TYPE_P (*node))
5177 type = node, is_type = 1;
5179 if (TREE_CODE (align_expr) != INTEGER_CST)
5181 error ("requested alignment is not a constant");
5182 *no_add_attrs = true;
5184 else if ((i = tree_log2 (align_expr)) == -1)
5186 error ("requested alignment is not a power of 2");
5187 *no_add_attrs = true;
5189 else if (i > HOST_BITS_PER_INT - 2)
5191 error ("requested alignment is too large");
5192 *no_add_attrs = true;
5196 /* If we have a TYPE_DECL, then copy the type, so that we
5197 don't accidentally modify a builtin type. See pushdecl. */
5198 if (decl && TREE_TYPE (decl) != error_mark_node
5199 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5201 tree tt = TREE_TYPE (decl);
5202 *type = build_variant_type_copy (*type);
5203 DECL_ORIGINAL_TYPE (decl) = tt;
5204 TYPE_NAME (*type) = decl;
5205 TREE_USED (*type) = TREE_USED (decl);
5206 TREE_TYPE (decl) = *type;
5208 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5209 *type = build_variant_type_copy (*type);
5211 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5212 TYPE_USER_ALIGN (*type) = 1;
5214 else if (! VAR_OR_FUNCTION_DECL_P (decl)
5215 && TREE_CODE (decl) != FIELD_DECL)
5217 error ("alignment may not be specified for %q+D", decl);
5218 *no_add_attrs = true;
5220 else if (TREE_CODE (decl) == FUNCTION_DECL
5221 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
5223 if (DECL_USER_ALIGN (decl))
5224 error ("alignment for %q+D was previously specified as %d "
5225 "and may not be decreased", decl,
5226 DECL_ALIGN (decl) / BITS_PER_UNIT);
5228 error ("alignment for %q+D must be at least %d", decl,
5229 DECL_ALIGN (decl) / BITS_PER_UNIT);
5230 *no_add_attrs = true;
5234 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5235 DECL_USER_ALIGN (decl) = 1;
5241 /* Handle a "weak" attribute; arguments as in
5242 struct attribute_spec.handler. */
5245 handle_weak_attribute (tree *node, tree name,
5246 tree ARG_UNUSED (args),
5247 int ARG_UNUSED (flags),
5248 bool * ARG_UNUSED (no_add_attrs))
5250 if (TREE_CODE (*node) == FUNCTION_DECL
5251 || TREE_CODE (*node) == VAR_DECL)
5252 declare_weak (*node);
5254 warning (OPT_Wattributes, "%qE attribute ignored", name);
5260 /* Handle an "alias" attribute; arguments as in
5261 struct attribute_spec.handler. */
5264 handle_alias_attribute (tree *node, tree name, tree args,
5265 int ARG_UNUSED (flags), bool *no_add_attrs)
5269 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5270 || (TREE_CODE (decl) != FUNCTION_DECL
5271 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
5272 /* A static variable declaration is always a tentative definition,
5273 but the alias is a non-tentative definition which overrides. */
5274 || (TREE_CODE (decl) != FUNCTION_DECL
5275 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
5277 error ("%q+D defined both normally and as an alias", decl);
5278 *no_add_attrs = true;
5281 /* Note that the very first time we process a nested declaration,
5282 decl_function_context will not be set. Indeed, *would* never
5283 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
5284 we do below. After such frobbery, pushdecl would set the context.
5285 In any case, this is never what we want. */
5286 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
5290 id = TREE_VALUE (args);
5291 if (TREE_CODE (id) != STRING_CST)
5293 error ("alias argument not a string");
5294 *no_add_attrs = true;
5297 id = get_identifier (TREE_STRING_POINTER (id));
5298 /* This counts as a use of the object pointed to. */
5301 if (TREE_CODE (decl) == FUNCTION_DECL)
5302 DECL_INITIAL (decl) = error_mark_node;
5305 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
5306 DECL_EXTERNAL (decl) = 1;
5308 DECL_EXTERNAL (decl) = 0;
5309 TREE_STATIC (decl) = 1;
5314 warning (OPT_Wattributes, "%qE attribute ignored", name);
5315 *no_add_attrs = true;
5321 /* Handle a "weakref" attribute; arguments as in struct
5322 attribute_spec.handler. */
5325 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5326 int flags, bool *no_add_attrs)
5328 tree attr = NULL_TREE;
5330 /* We must ignore the attribute when it is associated with
5331 local-scoped decls, since attribute alias is ignored and many
5332 such symbols do not even have a DECL_WEAK field. */
5333 if (decl_function_context (*node) || current_function_decl)
5335 warning (OPT_Wattributes, "%qE attribute ignored", name);
5336 *no_add_attrs = true;
5340 /* The idea here is that `weakref("name")' mutates into `weakref,
5341 alias("name")', and weakref without arguments, in turn,
5342 implicitly adds weak. */
5346 attr = tree_cons (get_identifier ("alias"), args, attr);
5347 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
5349 *no_add_attrs = true;
5351 decl_attributes (node, attr, flags);
5355 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
5356 error ("%Jweakref attribute must appear before alias attribute",
5359 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5360 and that isn't supported; and because it wants to add it to
5361 the list of weak decls, which isn't helpful. */
5362 DECL_WEAK (*node) = 1;
5368 /* Handle an "visibility" attribute; arguments as in
5369 struct attribute_spec.handler. */
5372 handle_visibility_attribute (tree *node, tree name, tree args,
5373 int ARG_UNUSED (flags),
5374 bool *ARG_UNUSED (no_add_attrs))
5377 tree id = TREE_VALUE (args);
5378 enum symbol_visibility vis;
5382 if (TREE_CODE (*node) == ENUMERAL_TYPE)
5384 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5386 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5390 else if (TYPE_FIELDS (*node))
5392 error ("%qE attribute ignored because %qT is already defined",
5397 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5399 warning (OPT_Wattributes, "%qE attribute ignored", name);
5403 if (TREE_CODE (id) != STRING_CST)
5405 error ("visibility argument not a string");
5409 /* If this is a type, set the visibility on the type decl. */
5412 decl = TYPE_NAME (decl);
5415 if (TREE_CODE (decl) == IDENTIFIER_NODE)
5417 warning (OPT_Wattributes, "%qE attribute ignored on types",
5423 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5424 vis = VISIBILITY_DEFAULT;
5425 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5426 vis = VISIBILITY_INTERNAL;
5427 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5428 vis = VISIBILITY_HIDDEN;
5429 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5430 vis = VISIBILITY_PROTECTED;
5433 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5434 vis = VISIBILITY_DEFAULT;
5437 if (DECL_VISIBILITY_SPECIFIED (decl)
5438 && vis != DECL_VISIBILITY (decl))
5440 tree attributes = (TYPE_P (*node)
5441 ? TYPE_ATTRIBUTES (*node)
5442 : DECL_ATTRIBUTES (decl));
5443 if (lookup_attribute ("visibility", attributes))
5444 error ("%qD redeclared with different visibility", decl);
5445 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5446 && lookup_attribute ("dllimport", attributes))
5447 error ("%qD was declared %qs which implies default visibility",
5449 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5450 && lookup_attribute ("dllexport", attributes))
5451 error ("%qD was declared %qs which implies default visibility",
5455 DECL_VISIBILITY (decl) = vis;
5456 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5458 /* Go ahead and attach the attribute to the node as well. This is needed
5459 so we can determine whether we have VISIBILITY_DEFAULT because the
5460 visibility was not specified, or because it was explicitly overridden
5461 from the containing scope. */
5466 /* Determine the ELF symbol visibility for DECL, which is either a
5467 variable or a function. It is an error to use this function if a
5468 definition of DECL is not available in this translation unit.
5469 Returns true if the final visibility has been determined by this
5470 function; false if the caller is free to make additional
5474 c_determine_visibility (tree decl)
5476 gcc_assert (TREE_CODE (decl) == VAR_DECL
5477 || TREE_CODE (decl) == FUNCTION_DECL);
5479 /* If the user explicitly specified the visibility with an
5480 attribute, honor that. DECL_VISIBILITY will have been set during
5481 the processing of the attribute. We check for an explicit
5482 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5483 to distinguish the use of an attribute from the use of a "#pragma
5484 GCC visibility push(...)"; in the latter case we still want other
5485 considerations to be able to overrule the #pragma. */
5486 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
5487 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5488 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
5489 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
5492 /* Set default visibility to whatever the user supplied with
5493 visibility_specified depending on #pragma GCC visibility. */
5494 if (!DECL_VISIBILITY_SPECIFIED (decl))
5496 DECL_VISIBILITY (decl) = default_visibility;
5497 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5502 /* Handle an "tls_model" attribute; arguments as in
5503 struct attribute_spec.handler. */
5506 handle_tls_model_attribute (tree *node, tree name, tree args,
5507 int ARG_UNUSED (flags), bool *no_add_attrs)
5511 enum tls_model kind;
5513 *no_add_attrs = true;
5515 if (!DECL_THREAD_LOCAL_P (decl))
5517 warning (OPT_Wattributes, "%qE attribute ignored", name);
5521 kind = DECL_TLS_MODEL (decl);
5522 id = TREE_VALUE (args);
5523 if (TREE_CODE (id) != STRING_CST)
5525 error ("tls_model argument not a string");
5529 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5530 kind = TLS_MODEL_LOCAL_EXEC;
5531 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5532 kind = TLS_MODEL_INITIAL_EXEC;
5533 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5534 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5535 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5536 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5538 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5540 DECL_TLS_MODEL (decl) = kind;
5544 /* Handle a "no_instrument_function" attribute; arguments as in
5545 struct attribute_spec.handler. */
5548 handle_no_instrument_function_attribute (tree *node, tree name,
5549 tree ARG_UNUSED (args),
5550 int ARG_UNUSED (flags),
5555 if (TREE_CODE (decl) != FUNCTION_DECL)
5557 error ("%J%qE attribute applies only to functions", decl, name);
5558 *no_add_attrs = true;
5560 else if (DECL_INITIAL (decl))
5562 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5563 *no_add_attrs = true;
5566 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5571 /* Handle a "malloc" attribute; arguments as in
5572 struct attribute_spec.handler. */
5575 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5576 int ARG_UNUSED (flags), bool *no_add_attrs)
5578 if (TREE_CODE (*node) == FUNCTION_DECL
5579 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5580 DECL_IS_MALLOC (*node) = 1;
5583 warning (OPT_Wattributes, "%qE attribute ignored", name);
5584 *no_add_attrs = true;
5590 /* Handle a "alloc_size" attribute; arguments as in
5591 struct attribute_spec.handler. */
5594 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5595 int ARG_UNUSED (flags), bool *no_add_attrs)
5597 tree params = TYPE_ARG_TYPES (*node);
5598 unsigned arg_count = 0;
5600 for (; TREE_CHAIN (params); params = TREE_CHAIN (params))
5603 for (; args; args = TREE_CHAIN (args))
5605 tree position = TREE_VALUE (args);
5607 if (TREE_CODE (position) != INTEGER_CST
5608 || TREE_INT_CST_HIGH (position)
5609 || TREE_INT_CST_LOW (position) < 1
5610 || TREE_INT_CST_LOW (position) > arg_count )
5612 warning (OPT_Wattributes,
5613 "alloc_size parameter outside range");
5614 *no_add_attrs = true;
5621 /* Handle a "returns_twice" attribute; arguments as in
5622 struct attribute_spec.handler. */
5625 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5626 int ARG_UNUSED (flags), bool *no_add_attrs)
5628 if (TREE_CODE (*node) == FUNCTION_DECL)
5629 DECL_IS_RETURNS_TWICE (*node) = 1;
5632 warning (OPT_Wattributes, "%qE attribute ignored", name);
5633 *no_add_attrs = true;
5639 /* Handle a "no_limit_stack" attribute; arguments as in
5640 struct attribute_spec.handler. */
5643 handle_no_limit_stack_attribute (tree *node, tree name,
5644 tree ARG_UNUSED (args),
5645 int ARG_UNUSED (flags),
5650 if (TREE_CODE (decl) != FUNCTION_DECL)
5652 error ("%J%qE attribute applies only to functions", decl, name);
5653 *no_add_attrs = true;
5655 else if (DECL_INITIAL (decl))
5657 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5658 *no_add_attrs = true;
5661 DECL_NO_LIMIT_STACK (decl) = 1;
5666 /* Handle a "pure" attribute; arguments as in
5667 struct attribute_spec.handler. */
5670 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5671 int ARG_UNUSED (flags), bool *no_add_attrs)
5673 if (TREE_CODE (*node) == FUNCTION_DECL)
5674 DECL_IS_PURE (*node) = 1;
5675 /* ??? TODO: Support types. */
5678 warning (OPT_Wattributes, "%qE attribute ignored", name);
5679 *no_add_attrs = true;
5685 /* Handle a "no vops" attribute; arguments as in
5686 struct attribute_spec.handler. */
5689 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5690 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5691 bool *ARG_UNUSED (no_add_attrs))
5693 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5694 DECL_IS_NOVOPS (*node) = 1;
5698 /* Handle a "deprecated" attribute; arguments as in
5699 struct attribute_spec.handler. */
5702 handle_deprecated_attribute (tree *node, tree name,
5703 tree ARG_UNUSED (args), int flags,
5706 tree type = NULL_TREE;
5708 tree what = NULL_TREE;
5713 type = TREE_TYPE (decl);
5715 if (TREE_CODE (decl) == TYPE_DECL
5716 || TREE_CODE (decl) == PARM_DECL
5717 || TREE_CODE (decl) == VAR_DECL
5718 || TREE_CODE (decl) == FUNCTION_DECL
5719 || TREE_CODE (decl) == FIELD_DECL)
5720 TREE_DEPRECATED (decl) = 1;
5724 else if (TYPE_P (*node))
5726 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5727 *node = build_variant_type_copy (*node);
5728 TREE_DEPRECATED (*node) = 1;
5736 *no_add_attrs = true;
5737 if (type && TYPE_NAME (type))
5739 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5740 what = TYPE_NAME (*node);
5741 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5742 && DECL_NAME (TYPE_NAME (type)))
5743 what = DECL_NAME (TYPE_NAME (type));
5746 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5748 warning (OPT_Wattributes, "%qE attribute ignored", name);
5754 /* Handle a "vector_size" attribute; arguments as in
5755 struct attribute_spec.handler. */
5758 handle_vector_size_attribute (tree *node, tree name, tree args,
5759 int ARG_UNUSED (flags),
5762 unsigned HOST_WIDE_INT vecsize, nunits;
5763 enum machine_mode orig_mode;
5764 tree type = *node, new_type, size;
5766 *no_add_attrs = true;
5768 size = TREE_VALUE (args);
5770 if (!host_integerp (size, 1))
5772 warning (OPT_Wattributes, "%qE attribute ignored", name);
5776 /* Get the vector size (in bytes). */
5777 vecsize = tree_low_cst (size, 1);
5779 /* We need to provide for vector pointers, vector arrays, and
5780 functions returning vectors. For example:
5782 __attribute__((vector_size(16))) short *foo;
5784 In this case, the mode is SI, but the type being modified is
5785 HI, so we need to look further. */
5787 while (POINTER_TYPE_P (type)
5788 || TREE_CODE (type) == FUNCTION_TYPE
5789 || TREE_CODE (type) == METHOD_TYPE
5790 || TREE_CODE (type) == ARRAY_TYPE)
5791 type = TREE_TYPE (type);
5793 /* Get the mode of the type being modified. */
5794 orig_mode = TYPE_MODE (type);
5796 if (TREE_CODE (type) == RECORD_TYPE
5797 || TREE_CODE (type) == UNION_TYPE
5798 || TREE_CODE (type) == VECTOR_TYPE
5799 || (!SCALAR_FLOAT_MODE_P (orig_mode)
5800 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5801 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5803 error ("invalid vector type for attribute %qE", name);
5807 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5809 error ("vector size not an integral multiple of component size");
5815 error ("zero vector size");
5819 /* Calculate how many units fit in the vector. */
5820 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5821 if (nunits & (nunits - 1))
5823 error ("number of components of the vector not a power of two");
5827 new_type = build_vector_type (type, nunits);
5829 /* Build back pointers if needed. */
5830 *node = reconstruct_complex_type (*node, new_type);
5835 /* Handle the "nonnull" attribute. */
5837 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5838 tree args, int ARG_UNUSED (flags),
5842 unsigned HOST_WIDE_INT attr_arg_num;
5844 /* If no arguments are specified, all pointer arguments should be
5845 non-null. Verify a full prototype is given so that the arguments
5846 will have the correct types when we actually check them later. */
5849 if (!TYPE_ARG_TYPES (type))
5851 error ("nonnull attribute without arguments on a non-prototype");
5852 *no_add_attrs = true;
5857 /* Argument list specified. Verify that each argument number references
5858 a pointer argument. */
5859 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5862 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5864 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5866 error ("nonnull argument has invalid operand number (argument %lu)",
5867 (unsigned long) attr_arg_num);
5868 *no_add_attrs = true;
5872 argument = TYPE_ARG_TYPES (type);
5875 for (ck_num = 1; ; ck_num++)
5877 if (!argument || ck_num == arg_num)
5879 argument = TREE_CHAIN (argument);
5883 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5885 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5886 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5887 *no_add_attrs = true;
5891 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5893 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5894 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5895 *no_add_attrs = true;
5904 /* Check the argument list of a function call for null in argument slots
5905 that are marked as requiring a non-null pointer argument. The NARGS
5906 arguments are passed in the array ARGARRAY.
5910 check_function_nonnull (tree attrs, int nargs, tree *argarray)
5915 for (a = attrs; a; a = TREE_CHAIN (a))
5917 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5919 args = TREE_VALUE (a);
5921 /* Walk the argument list. If we encounter an argument number we
5922 should check for non-null, do it. If the attribute has no args,
5923 then every pointer argument is checked (in which case the check
5924 for pointer type is done in check_nonnull_arg). */
5925 for (i = 0; i < nargs; i++)
5927 if (!args || nonnull_check_p (args, i + 1))
5928 check_function_arguments_recurse (check_nonnull_arg, NULL,
5936 /* Check that the Nth argument of a function call (counting backwards
5937 from the end) is a (pointer)0. The NARGS arguments are passed in the
5941 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
5943 tree attr = lookup_attribute ("sentinel", attrs);
5951 /* Skip over the named arguments. */
5952 while (typelist && len < nargs)
5954 typelist = TREE_CHAIN (typelist);
5958 if (TREE_VALUE (attr))
5960 tree p = TREE_VALUE (TREE_VALUE (attr));
5961 pos = TREE_INT_CST_LOW (p);
5964 /* The sentinel must be one of the varargs, i.e.
5965 in position >= the number of fixed arguments. */
5966 if ((nargs - 1 - pos) < len)
5968 warning (OPT_Wformat,
5969 "not enough variable arguments to fit a sentinel");
5973 /* Validate the sentinel. */
5974 sentinel = argarray[nargs - 1 - pos];
5975 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
5976 || !integer_zerop (sentinel))
5977 /* Although __null (in C++) is only an integer we allow it
5978 nevertheless, as we are guaranteed that it's exactly
5979 as wide as a pointer, and we don't want to force
5980 users to cast the NULL they have written there.
5981 We warn with -Wstrict-null-sentinel, though. */
5982 && (warn_strict_null_sentinel || null_node != sentinel))
5983 warning (OPT_Wformat, "missing sentinel in function call");
5987 /* Helper for check_function_nonnull; given a list of operands which
5988 must be non-null in ARGS, determine if operand PARAM_NUM should be
5992 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5994 unsigned HOST_WIDE_INT arg_num = 0;
5996 for (; args; args = TREE_CHAIN (args))
5998 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6002 if (arg_num == param_num)
6008 /* Check that the function argument PARAM (which is operand number
6009 PARAM_NUM) is non-null. This is called by check_function_nonnull
6010 via check_function_arguments_recurse. */
6013 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6014 unsigned HOST_WIDE_INT param_num)
6016 /* Just skip checking the argument if it's not a pointer. This can
6017 happen if the "nonnull" attribute was given without an operand
6018 list (which means to check every pointer argument). */
6020 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6023 if (integer_zerop (param))
6024 warning (OPT_Wnonnull, "null argument where non-null required "
6025 "(argument %lu)", (unsigned long) param_num);
6028 /* Helper for nonnull attribute handling; fetch the operand number
6029 from the attribute argument list. */
6032 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6034 /* Verify the arg number is a constant. */
6035 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6036 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6039 *valp = TREE_INT_CST_LOW (arg_num_expr);
6043 /* Handle a "nothrow" attribute; arguments as in
6044 struct attribute_spec.handler. */
6047 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6048 int ARG_UNUSED (flags), bool *no_add_attrs)
6050 if (TREE_CODE (*node) == FUNCTION_DECL)
6051 TREE_NOTHROW (*node) = 1;
6052 /* ??? TODO: Support types. */
6055 warning (OPT_Wattributes, "%qE attribute ignored", name);
6056 *no_add_attrs = true;
6062 /* Handle a "cleanup" attribute; arguments as in
6063 struct attribute_spec.handler. */
6066 handle_cleanup_attribute (tree *node, tree name, tree args,
6067 int ARG_UNUSED (flags), bool *no_add_attrs)
6070 tree cleanup_id, cleanup_decl;
6072 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6073 for global destructors in C++. This requires infrastructure that
6074 we don't have generically at the moment. It's also not a feature
6075 we'd be missing too much, since we do have attribute constructor. */
6076 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6078 warning (OPT_Wattributes, "%qE attribute ignored", name);
6079 *no_add_attrs = true;
6083 /* Verify that the argument is a function in scope. */
6084 /* ??? We could support pointers to functions here as well, if
6085 that was considered desirable. */
6086 cleanup_id = TREE_VALUE (args);
6087 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6089 error ("cleanup argument not an identifier");
6090 *no_add_attrs = true;
6093 cleanup_decl = lookup_name (cleanup_id);
6094 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6096 error ("cleanup argument not a function");
6097 *no_add_attrs = true;
6101 /* That the function has proper type is checked with the
6102 eventual call to build_function_call. */
6107 /* Handle a "warn_unused_result" attribute. No special handling. */
6110 handle_warn_unused_result_attribute (tree *node, tree name,
6111 tree ARG_UNUSED (args),
6112 int ARG_UNUSED (flags), bool *no_add_attrs)
6114 /* Ignore the attribute for functions not returning any value. */
6115 if (VOID_TYPE_P (TREE_TYPE (*node)))
6117 warning (OPT_Wattributes, "%qE attribute ignored", name);
6118 *no_add_attrs = true;
6124 /* Handle a "sentinel" attribute. */
6127 handle_sentinel_attribute (tree *node, tree name, tree args,
6128 int ARG_UNUSED (flags), bool *no_add_attrs)
6130 tree params = TYPE_ARG_TYPES (*node);
6134 warning (OPT_Wattributes,
6135 "%qE attribute requires prototypes with named arguments", name);
6136 *no_add_attrs = true;
6140 while (TREE_CHAIN (params))
6141 params = TREE_CHAIN (params);
6143 if (VOID_TYPE_P (TREE_VALUE (params)))
6145 warning (OPT_Wattributes,
6146 "%qE attribute only applies to variadic functions", name);
6147 *no_add_attrs = true;
6153 tree position = TREE_VALUE (args);
6155 if (TREE_CODE (position) != INTEGER_CST)
6157 warning (OPT_Wattributes,
6158 "requested position is not an integer constant");
6159 *no_add_attrs = true;
6163 if (tree_int_cst_lt (position, integer_zero_node))
6165 warning (OPT_Wattributes,
6166 "requested position is less than zero");
6167 *no_add_attrs = true;
6175 /* Handle a "type_generic" attribute. */
6178 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6179 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6180 bool * ARG_UNUSED (no_add_attrs))
6182 /* Ensure we have a function type, with no arguments. */
6183 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE && ! TYPE_ARG_TYPES (*node));
6188 /* Check for valid arguments being passed to a function.
6189 ATTRS is a list of attributes. There are NARGS arguments in the array
6190 ARGARRAY. TYPELIST is the list of argument types for the function.
6193 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
6195 /* Check for null being passed in a pointer argument that must be
6196 non-null. We also need to do this if format checking is enabled. */
6199 check_function_nonnull (attrs, nargs, argarray);
6201 /* Check for errors in format strings. */
6203 if (warn_format || warn_missing_format_attribute)
6204 check_function_format (attrs, nargs, argarray);
6207 check_function_sentinel (attrs, nargs, argarray, typelist);
6210 /* Generic argument checking recursion routine. PARAM is the argument to
6211 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6212 once the argument is resolved. CTX is context for the callback. */
6214 check_function_arguments_recurse (void (*callback)
6215 (void *, tree, unsigned HOST_WIDE_INT),
6216 void *ctx, tree param,
6217 unsigned HOST_WIDE_INT param_num)
6219 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
6220 && (TYPE_PRECISION (TREE_TYPE (param))
6221 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
6223 /* Strip coercion. */
6224 check_function_arguments_recurse (callback, ctx,
6225 TREE_OPERAND (param, 0), param_num);
6229 if (TREE_CODE (param) == CALL_EXPR)
6231 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
6233 bool found_format_arg = false;
6235 /* See if this is a call to a known internationalization function
6236 that modifies a format arg. Such a function may have multiple
6237 format_arg attributes (for example, ngettext). */
6239 for (attrs = TYPE_ATTRIBUTES (type);
6241 attrs = TREE_CHAIN (attrs))
6242 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6245 tree format_num_expr;
6248 call_expr_arg_iterator iter;
6250 /* Extract the argument number, which was previously checked
6252 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6254 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
6255 && !TREE_INT_CST_HIGH (format_num_expr));
6257 format_num = TREE_INT_CST_LOW (format_num_expr);
6259 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
6261 inner_arg = next_call_expr_arg (&iter), i++)
6262 if (i == format_num)
6264 check_function_arguments_recurse (callback, ctx,
6265 inner_arg, param_num);
6266 found_format_arg = true;
6271 /* If we found a format_arg attribute and did a recursive check,
6272 we are done with checking this argument. Otherwise, we continue
6273 and this will be considered a non-literal. */
6274 if (found_format_arg)
6278 if (TREE_CODE (param) == COND_EXPR)
6280 /* Check both halves of the conditional expression. */
6281 check_function_arguments_recurse (callback, ctx,
6282 TREE_OPERAND (param, 1), param_num);
6283 check_function_arguments_recurse (callback, ctx,
6284 TREE_OPERAND (param, 2), param_num);
6288 (*callback) (ctx, param, param_num);
6291 /* Function to help qsort sort FIELD_DECLs by name order. */
6294 field_decl_cmp (const void *x_p, const void *y_p)
6296 const tree *const x = (const tree *const) x_p;
6297 const tree *const y = (const tree *const) y_p;
6299 if (DECL_NAME (*x) == DECL_NAME (*y))
6300 /* A nontype is "greater" than a type. */
6301 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6302 if (DECL_NAME (*x) == NULL_TREE)
6304 if (DECL_NAME (*y) == NULL_TREE)
6306 if (DECL_NAME (*x) < DECL_NAME (*y))
6312 gt_pointer_operator new_value;
6316 /* This routine compares two fields like field_decl_cmp but using the
6317 pointer operator in resort_data. */
6320 resort_field_decl_cmp (const void *x_p, const void *y_p)
6322 const tree *const x = (const tree *const) x_p;
6323 const tree *const y = (const tree *const) y_p;
6325 if (DECL_NAME (*x) == DECL_NAME (*y))
6326 /* A nontype is "greater" than a type. */
6327 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6328 if (DECL_NAME (*x) == NULL_TREE)
6330 if (DECL_NAME (*y) == NULL_TREE)
6333 tree d1 = DECL_NAME (*x);
6334 tree d2 = DECL_NAME (*y);
6335 resort_data.new_value (&d1, resort_data.cookie);
6336 resort_data.new_value (&d2, resort_data.cookie);
6343 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
6346 resort_sorted_fields (void *obj,
6347 void * ARG_UNUSED (orig_obj),
6348 gt_pointer_operator new_value,
6351 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6352 resort_data.new_value = new_value;
6353 resort_data.cookie = cookie;
6354 qsort (&sf->elts[0], sf->len, sizeof (tree),
6355 resort_field_decl_cmp);
6358 /* Subroutine of c_parse_error.
6359 Return the result of concatenating LHS and RHS. RHS is really
6360 a string literal, its first character is indicated by RHS_START and
6361 RHS_SIZE is its length (including the terminating NUL character).
6363 The caller is responsible for deleting the returned pointer. */
6366 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6368 const int lhs_size = strlen (lhs);
6369 char *result = XNEWVEC (char, lhs_size + rhs_size);
6370 strncpy (result, lhs, lhs_size);
6371 strncpy (result + lhs_size, rhs_start, rhs_size);
6375 /* Issue the error given by GMSGID, indicating that it occurred before
6376 TOKEN, which had the associated VALUE. */
6379 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6381 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6383 char *message = NULL;
6385 if (token == CPP_EOF)
6386 message = catenate_messages (gmsgid, " at end of input");
6387 else if (token == CPP_CHAR || token == CPP_WCHAR)
6389 unsigned int val = TREE_INT_CST_LOW (value);
6390 const char *const ell = (token == CPP_CHAR) ? "" : "L";
6391 if (val <= UCHAR_MAX && ISGRAPH (val))
6392 message = catenate_messages (gmsgid, " before %s'%c'");
6394 message = catenate_messages (gmsgid, " before %s'\\x%x'");
6396 error (message, ell, val);
6400 else if (token == CPP_STRING || token == CPP_WSTRING)
6401 message = catenate_messages (gmsgid, " before string constant");
6402 else if (token == CPP_NUMBER)
6403 message = catenate_messages (gmsgid, " before numeric constant");
6404 else if (token == CPP_NAME)
6406 message = catenate_messages (gmsgid, " before %qE");
6407 error (message, value);
6411 else if (token == CPP_PRAGMA)
6412 message = catenate_messages (gmsgid, " before %<#pragma%>");
6413 else if (token == CPP_PRAGMA_EOL)
6414 message = catenate_messages (gmsgid, " before end of line");
6415 else if (token < N_TTYPES)
6417 message = catenate_messages (gmsgid, " before %qs token");
6418 error (message, cpp_type2name (token));
6430 #undef catenate_messages
6433 /* Walk a gimplified function and warn for functions whose return value is
6434 ignored and attribute((warn_unused_result)) is set. This is done before
6435 inlining, so we don't have to worry about that. */
6438 c_warn_unused_result (tree *top_p)
6441 tree_stmt_iterator i;
6444 switch (TREE_CODE (t))
6446 case STATEMENT_LIST:
6447 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6448 c_warn_unused_result (tsi_stmt_ptr (i));
6452 c_warn_unused_result (&COND_EXPR_THEN (t));
6453 c_warn_unused_result (&COND_EXPR_ELSE (t));
6456 c_warn_unused_result (&BIND_EXPR_BODY (t));
6458 case TRY_FINALLY_EXPR:
6459 case TRY_CATCH_EXPR:
6460 c_warn_unused_result (&TREE_OPERAND (t, 0));
6461 c_warn_unused_result (&TREE_OPERAND (t, 1));
6464 c_warn_unused_result (&CATCH_BODY (t));
6466 case EH_FILTER_EXPR:
6467 c_warn_unused_result (&EH_FILTER_FAILURE (t));
6474 /* This is a naked call, as opposed to a CALL_EXPR nested inside
6475 a MODIFY_EXPR. All calls whose value is ignored should be
6476 represented like this. Look for the attribute. */
6477 fdecl = get_callee_fndecl (t);
6479 ftype = TREE_TYPE (fdecl);
6482 ftype = TREE_TYPE (CALL_EXPR_FN (t));
6483 /* Look past pointer-to-function to the function type itself. */
6484 ftype = TREE_TYPE (ftype);
6487 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
6490 warning (0, "%Hignoring return value of %qD, "
6491 "declared with attribute warn_unused_result",
6492 EXPR_LOCUS (t), fdecl);
6494 warning (0, "%Hignoring return value of function "
6495 "declared with attribute warn_unused_result",
6501 /* Not a container, not a call, or a call whose value is used. */
6506 /* Convert a character from the host to the target execution character
6507 set. cpplib handles this, mostly. */
6510 c_common_to_target_charset (HOST_WIDE_INT c)
6512 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6513 zero-extended under -fno-signed-char. cpplib insists that characters
6514 and character constants are always unsigned. Hence we must convert
6516 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6518 uc = cpp_host_to_exec_charset (parse_in, uc);
6520 if (flag_signed_char)
6521 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6522 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6527 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6528 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6529 NULL, at the bottom; much like the traditional rendering of offsetof as a
6530 macro. Returns the folded and properly cast result. */
6533 fold_offsetof_1 (tree expr, tree stop_ref)
6535 enum tree_code code = PLUS_EXPR;
6538 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6539 return size_zero_node;
6541 switch (TREE_CODE (expr))
6547 error ("cannot apply %<offsetof%> to static data member %qD", expr);
6548 return error_mark_node;
6551 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6552 return error_mark_node;
6555 gcc_assert (integer_zerop (expr));
6556 return size_zero_node;
6560 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6561 gcc_assert (base == error_mark_node || base == size_zero_node);
6565 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6566 if (base == error_mark_node)
6569 t = TREE_OPERAND (expr, 1);
6570 if (DECL_C_BIT_FIELD (t))
6572 error ("attempt to take address of bit-field structure "
6574 return error_mark_node;
6576 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6577 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6582 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6583 if (base == error_mark_node)
6586 t = TREE_OPERAND (expr, 1);
6587 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6590 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6592 t = convert (sizetype, t);
6593 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6597 /* Handle static members of volatile structs. */
6598 t = TREE_OPERAND (expr, 1);
6599 gcc_assert (TREE_CODE (t) == VAR_DECL);
6600 return fold_offsetof_1 (t, stop_ref);
6606 return size_binop (code, base, off);
6610 fold_offsetof (tree expr, tree stop_ref)
6612 /* Convert back from the internal sizetype to size_t. */
6613 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6616 /* Print an error message for an invalid lvalue. USE says
6617 how the lvalue is being used and so selects the error message. */
6620 lvalue_error (enum lvalue_use use)
6625 error ("lvalue required as left operand of assignment");
6628 error ("lvalue required as increment operand");
6631 error ("lvalue required as decrement operand");
6634 error ("lvalue required as unary %<&%> operand");
6637 error ("lvalue required in asm statement");
6644 /* *PTYPE is an incomplete array. Complete it with a domain based on
6645 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6646 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6647 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6650 complete_array_type (tree *ptype, tree initial_value, bool do_default)
6652 tree maxindex, type, main_type, elt, unqual_elt;
6653 int failure = 0, quals;
6654 hashval_t hashcode = 0;
6656 maxindex = size_zero_node;
6659 if (TREE_CODE (initial_value) == STRING_CST)
6662 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6663 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6665 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6667 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6669 if (VEC_empty (constructor_elt, v))
6673 maxindex = integer_minus_one_node;
6678 unsigned HOST_WIDE_INT cnt;
6679 constructor_elt *ce;
6681 if (VEC_index (constructor_elt, v, 0)->index)
6682 maxindex = fold_convert (sizetype,
6683 VEC_index (constructor_elt,
6685 curindex = maxindex;
6688 VEC_iterate (constructor_elt, v, cnt, ce);
6692 curindex = fold_convert (sizetype, ce->index);
6694 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6696 if (tree_int_cst_lt (maxindex, curindex))
6697 maxindex = curindex;
6703 /* Make an error message unless that happened already. */
6704 if (initial_value != error_mark_node)
6716 elt = TREE_TYPE (type);
6717 quals = TYPE_QUALS (strip_array_types (elt));
6721 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6723 /* Using build_distinct_type_copy and modifying things afterward instead
6724 of using build_array_type to create a new type preserves all of the
6725 TYPE_LANG_FLAG_? bits that the front end may have set. */
6726 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6727 TREE_TYPE (main_type) = unqual_elt;
6728 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6729 layout_type (main_type);
6731 /* Make sure we have the canonical MAIN_TYPE. */
6732 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
6733 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
6735 main_type = type_hash_canon (hashcode, main_type);
6740 type = c_build_qualified_type (main_type, quals);
6747 /* Used to help initialize the builtin-types.def table. When a type of
6748 the correct size doesn't exist, use error_mark_node instead of NULL.
6749 The later results in segfaults even when a decl using the type doesn't
6753 builtin_type_for_size (int size, bool unsignedp)
6755 tree type = lang_hooks.types.type_for_size (size, unsignedp);
6756 return type ? type : error_mark_node;
6759 /* A helper function for resolve_overloaded_builtin in resolving the
6760 overloaded __sync_ builtins. Returns a positive power of 2 if the
6761 first operand of PARAMS is a pointer to a supported data type.
6762 Returns 0 if an error is encountered. */
6765 sync_resolve_size (tree function, tree params)
6772 error ("too few arguments to function %qE", function);
6776 type = TREE_TYPE (TREE_VALUE (params));
6777 if (TREE_CODE (type) != POINTER_TYPE)
6780 type = TREE_TYPE (type);
6781 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6784 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6785 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6789 error ("incompatible type for argument %d of %qE", 1, function);
6793 /* A helper function for resolve_overloaded_builtin. Adds casts to
6794 PARAMS to make arguments match up with those of FUNCTION. Drops
6795 the variadic arguments at the end. Returns false if some error
6796 was encountered; true on success. */
6799 sync_resolve_params (tree orig_function, tree function, tree params)
6801 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6805 /* We've declared the implementation functions to use "volatile void *"
6806 as the pointer parameter, so we shouldn't get any complaints from the
6807 call to check_function_arguments what ever type the user used. */
6808 arg_types = TREE_CHAIN (arg_types);
6809 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6812 /* For the rest of the values, we need to cast these to FTYPE, so that we
6813 don't get warnings for passing pointer types, etc. */
6814 while (arg_types != void_list_node)
6818 params = TREE_CHAIN (params);
6821 error ("too few arguments to function %qE", orig_function);
6825 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6826 so that we get warnings for anything that doesn't match the pointer
6827 type. This isn't portable across the C and C++ front ends atm. */
6828 val = TREE_VALUE (params);
6829 val = convert (ptype, val);
6830 val = convert (TREE_VALUE (arg_types), val);
6831 TREE_VALUE (params) = val;
6833 arg_types = TREE_CHAIN (arg_types);
6837 /* The definition of these primitives is variadic, with the remaining
6838 being "an optional list of variables protected by the memory barrier".
6839 No clue what that's supposed to mean, precisely, but we consider all
6840 call-clobbered variables to be protected so we're safe. */
6841 TREE_CHAIN (params) = NULL;
6846 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6847 RESULT to make it match the type of the first pointer argument in
6851 sync_resolve_return (tree params, tree result)
6853 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6854 ptype = TYPE_MAIN_VARIANT (ptype);
6855 return convert (ptype, result);
6858 /* Some builtin functions are placeholders for other expressions. This
6859 function should be called immediately after parsing the call expression
6860 before surrounding code has committed to the type of the expression.
6862 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6863 PARAMS is the argument list for the call. The return value is non-null
6864 when expansion is complete, and null if normal processing should
6868 resolve_overloaded_builtin (tree function, tree params)
6870 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6871 switch (DECL_BUILT_IN_CLASS (function))
6873 case BUILT_IN_NORMAL:
6876 if (targetm.resolve_overloaded_builtin)
6877 return targetm.resolve_overloaded_builtin (function, params);
6884 /* Handle BUILT_IN_NORMAL here. */
6887 case BUILT_IN_FETCH_AND_ADD_N:
6888 case BUILT_IN_FETCH_AND_SUB_N:
6889 case BUILT_IN_FETCH_AND_OR_N:
6890 case BUILT_IN_FETCH_AND_AND_N:
6891 case BUILT_IN_FETCH_AND_XOR_N:
6892 case BUILT_IN_FETCH_AND_NAND_N:
6893 case BUILT_IN_ADD_AND_FETCH_N:
6894 case BUILT_IN_SUB_AND_FETCH_N:
6895 case BUILT_IN_OR_AND_FETCH_N:
6896 case BUILT_IN_AND_AND_FETCH_N:
6897 case BUILT_IN_XOR_AND_FETCH_N:
6898 case BUILT_IN_NAND_AND_FETCH_N:
6899 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6900 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6901 case BUILT_IN_LOCK_TEST_AND_SET_N:
6902 case BUILT_IN_LOCK_RELEASE_N:
6904 int n = sync_resolve_size (function, params);
6905 tree new_function, result;
6908 return error_mark_node;
6910 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6911 if (!sync_resolve_params (function, new_function, params))
6912 return error_mark_node;
6914 result = build_function_call (new_function, params);
6915 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6916 && orig_code != BUILT_IN_LOCK_RELEASE_N)
6917 result = sync_resolve_return (params, result);
6927 /* Ignoring their sign, return true if two scalar types are the same. */
6929 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6931 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6933 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6934 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6936 /* Equality works here because c_common_signed_type uses
6937 TYPE_MAIN_VARIANT. */
6938 return c_common_signed_type (t1)
6939 == c_common_signed_type (t2);
6942 /* Check for missing format attributes on function pointers. LTYPE is
6943 the new type or left-hand side type. RTYPE is the old type or
6944 right-hand side type. Returns TRUE if LTYPE is missing the desired
6948 check_missing_format_attribute (tree ltype, tree rtype)
6950 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6953 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6954 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6959 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6960 if (is_attribute_p ("format", TREE_PURPOSE (la)))
6968 /* Subscripting with type char is likely to lose on a machine where
6969 chars are signed. So warn on any machine, but optionally. Don't
6970 warn for unsigned char since that type is safe. Don't warn for
6971 signed char because anyone who uses that must have done so
6972 deliberately. Furthermore, we reduce the false positive load by
6973 warning only for non-constant value of type char. */
6976 warn_array_subscript_with_type_char (tree index)
6978 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6979 && TREE_CODE (index) != INTEGER_CST)
6980 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6983 /* Implement -Wparentheses for the unexpected C precedence rules, to
6984 cover cases like x + y << z which readers are likely to
6985 misinterpret. We have seen an expression in which CODE is a binary
6986 operator used to combine expressions headed by CODE_LEFT and
6987 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
6988 means that that side of the expression was not formed using a
6989 binary operator, or it was enclosed in parentheses. */
6992 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
6993 enum tree_code code_right)
6995 if (!warn_parentheses)
6998 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
7000 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7001 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7002 warning (OPT_Wparentheses,
7003 "suggest parentheses around + or - inside shift");
7006 if (code == TRUTH_ORIF_EXPR)
7008 if (code_left == TRUTH_ANDIF_EXPR
7009 || code_right == TRUTH_ANDIF_EXPR)
7010 warning (OPT_Wparentheses,
7011 "suggest parentheses around && within ||");
7014 if (code == BIT_IOR_EXPR)
7016 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
7017 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7018 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
7019 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7020 warning (OPT_Wparentheses,
7021 "suggest parentheses around arithmetic in operand of |");
7022 /* Check cases like x|y==z */
7023 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7024 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7025 warning (OPT_Wparentheses,
7026 "suggest parentheses around comparison in operand of |");
7029 if (code == BIT_XOR_EXPR)
7031 if (code_left == BIT_AND_EXPR
7032 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7033 || code_right == BIT_AND_EXPR
7034 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7035 warning (OPT_Wparentheses,
7036 "suggest parentheses around arithmetic in operand of ^");
7037 /* Check cases like x^y==z */
7038 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7039 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7040 warning (OPT_Wparentheses,
7041 "suggest parentheses around comparison in operand of ^");
7044 if (code == BIT_AND_EXPR)
7046 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7047 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7048 warning (OPT_Wparentheses,
7049 "suggest parentheses around + or - in operand of &");
7050 /* Check cases like x&y==z */
7051 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7052 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7053 warning (OPT_Wparentheses,
7054 "suggest parentheses around comparison in operand of &");
7057 if (code == EQ_EXPR || code == NE_EXPR)
7059 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7060 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7061 warning (OPT_Wparentheses,
7062 "suggest parentheses around comparison in operand of %s",
7063 code == EQ_EXPR ? "==" : "!=");
7065 else if (TREE_CODE_CLASS (code) == tcc_comparison)
7067 if ((TREE_CODE_CLASS (code_left) == tcc_comparison
7068 && code_left != NE_EXPR && code_left != EQ_EXPR)
7069 || (TREE_CODE_CLASS (code_right) == tcc_comparison
7070 && code_right != NE_EXPR && code_right != EQ_EXPR))
7071 warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
7072 "have their mathematical meaning");
7076 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
7079 warn_for_unused_label (tree label)
7081 if (!TREE_USED (label))
7083 if (DECL_INITIAL (label))
7084 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
7086 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
7090 #ifndef TARGET_HAS_TARGETCM
7091 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
7094 /* Warn for division by zero according to the value of DIVISOR. */
7097 warn_for_div_by_zero (tree divisor)
7099 /* If DIVISOR is zero, and has integral type, issue a warning about
7100 division by zero. Do not issue a warning if DIVISOR has a
7101 floating-point type, since we consider 0.0/0.0 a valid way of
7102 generating a NaN. */
7103 if (skip_evaluation == 0 && integer_zerop (divisor))
7104 warning (OPT_Wdiv_by_zero, "division by zero");
7107 #include "gt-c-common.h"