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 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
35 #include "diagnostic.h"
40 #include "langhooks.h"
41 #include "tree-inline.h"
44 #include "tree-iterator.h"
46 #include "tree-mudflap.h"
50 #include "target-def.h"
52 cpp_reader *parse_in; /* Declared in c-pragma.h. */
54 /* We let tm.h override the types used here, to handle trivial differences
55 such as the choice of unsigned int or long unsigned int for size_t.
56 When machines start needing nontrivial differences in the size type,
57 it would be best to do something here to figure out automatically
58 from other information what type to use. */
61 #define SIZE_TYPE "long unsigned int"
65 #define PID_TYPE "int"
69 #define WCHAR_TYPE "int"
72 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
73 #define MODIFIED_WCHAR_TYPE \
74 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
77 #define PTRDIFF_TYPE "long int"
81 #define WINT_TYPE "unsigned int"
85 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
87 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
93 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
95 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
96 ? "long unsigned int" \
97 : "long long unsigned int"))
100 /* The following symbols are subsumed in the c_global_trees array, and
101 listed here individually for documentation purposes.
103 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
105 tree short_integer_type_node;
106 tree long_integer_type_node;
107 tree long_long_integer_type_node;
109 tree short_unsigned_type_node;
110 tree long_unsigned_type_node;
111 tree long_long_unsigned_type_node;
113 tree truthvalue_type_node;
114 tree truthvalue_false_node;
115 tree truthvalue_true_node;
117 tree ptrdiff_type_node;
119 tree unsigned_char_type_node;
120 tree signed_char_type_node;
121 tree wchar_type_node;
122 tree signed_wchar_type_node;
123 tree unsigned_wchar_type_node;
125 tree float_type_node;
126 tree double_type_node;
127 tree long_double_type_node;
129 tree complex_integer_type_node;
130 tree complex_float_type_node;
131 tree complex_double_type_node;
132 tree complex_long_double_type_node;
134 tree dfloat32_type_node;
135 tree dfloat64_type_node;
136 tree_dfloat128_type_node;
138 tree intQI_type_node;
139 tree intHI_type_node;
140 tree intSI_type_node;
141 tree intDI_type_node;
142 tree intTI_type_node;
144 tree unsigned_intQI_type_node;
145 tree unsigned_intHI_type_node;
146 tree unsigned_intSI_type_node;
147 tree unsigned_intDI_type_node;
148 tree unsigned_intTI_type_node;
150 tree widest_integer_literal_type_node;
151 tree widest_unsigned_literal_type_node;
153 Nodes for types `void *' and `const void *'.
155 tree ptr_type_node, const_ptr_type_node;
157 Nodes for types `char *' and `const char *'.
159 tree string_type_node, const_string_type_node;
161 Type `char[SOMENUMBER]'.
162 Used when an array of char is needed and the size is irrelevant.
164 tree char_array_type_node;
166 Type `int[SOMENUMBER]' or something like it.
167 Used when an array of int needed and the size is irrelevant.
169 tree int_array_type_node;
171 Type `wchar_t[SOMENUMBER]' or something like it.
172 Used when a wide string literal is created.
174 tree wchar_array_type_node;
176 Type `int ()' -- used for implicit declaration of functions.
178 tree default_function_type;
180 A VOID_TYPE node, packaged in a TREE_LIST.
184 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
185 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
186 VAR_DECLS, but C++ does.)
188 tree function_name_decl_node;
189 tree pretty_function_name_decl_node;
190 tree c99_function_name_decl_node;
192 Stack of nested function name VAR_DECLs.
194 tree saved_function_name_decls;
198 tree c_global_trees[CTI_MAX];
200 /* Switches common to the C front ends. */
202 /* Nonzero if prepreprocessing only. */
204 int flag_preprocess_only;
206 /* Nonzero means don't output line number information. */
208 char flag_no_line_commands;
210 /* Nonzero causes -E output not to be done, but directives such as
211 #define that have side effects are still obeyed. */
215 /* Nonzero means dump macros in some fashion. */
217 char flag_dump_macros;
219 /* Nonzero means pass #include lines through to the output. */
221 char flag_dump_includes;
223 /* Nonzero means process PCH files while preprocessing. */
225 bool flag_pch_preprocess;
227 /* The file name to which we should write a precompiled header, or
228 NULL if no header will be written in this compile. */
230 const char *pch_file;
232 /* Nonzero if an ISO standard was selected. It rejects macros in the
236 /* Nonzero if -undef was given. It suppresses target built-in macros
240 /* Nonzero means don't recognize the non-ANSI builtin functions. */
244 /* Nonzero means don't recognize the non-ANSI builtin functions.
247 int flag_no_nonansi_builtin;
249 /* Nonzero means give `double' the same size as `float'. */
251 int flag_short_double;
253 /* Nonzero means give `wchar_t' the same size as `short'. */
255 int flag_short_wchar;
257 /* Nonzero means allow implicit conversions between vectors with
258 differing numbers of subparts and/or differing element types. */
259 int flag_lax_vector_conversions;
261 /* Nonzero means allow Microsoft extensions without warnings or errors. */
262 int flag_ms_extensions;
264 /* Nonzero means don't recognize the keyword `asm'. */
268 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
270 int flag_signed_bitfields = 1;
272 /* Warn about #pragma directives that are not recognized. */
274 int warn_unknown_pragmas; /* Tri state variable. */
276 /* Warn about format/argument anomalies in calls to formatted I/O functions
277 (*printf, *scanf, strftime, strfmon, etc.). */
281 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
282 with GCC this doesn't matter as __null is guaranteed to have the right
285 int warn_strict_null_sentinel;
287 /* Zero means that faster, ...NonNil variants of objc_msgSend...
288 calls will be used in ObjC; passing nil receivers to such calls
289 will most likely result in crashes. */
290 int flag_nil_receivers = 1;
292 /* Nonzero means that code generation will be altered to support
293 "zero-link" execution. This currently affects ObjC only, but may
294 affect other languages in the future. */
295 int flag_zero_link = 0;
297 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
298 unit. It will inform the ObjC runtime that class definition(s) herein
299 contained are to replace one(s) previously loaded. */
300 int flag_replace_objc_classes = 0;
302 /* C/ObjC language option variables. */
305 /* Nonzero means allow type mismatches in conditional expressions;
306 just make their values `void'. */
308 int flag_cond_mismatch;
310 /* Nonzero means enable C89 Amendment 1 features. */
314 /* Nonzero means use the ISO C99 dialect of C. */
318 /* Nonzero means that we have builtin functions, and main is an int. */
322 /* Warn if main is suspicious. */
327 /* ObjC language option variables. */
330 /* Open and close the file for outputting class declarations, if
333 int flag_gen_declaration;
335 /* Tells the compiler that this is a special run. Do not perform any
336 compiling, instead we are to test some platform dependent features
337 and output a C header file with appropriate definitions. */
339 int print_struct_values;
341 /* Tells the compiler what is the constant string class for Objc. */
343 const char *constant_string_class_name;
346 /* C++ language option variables. */
349 /* Nonzero means don't recognize any extension keywords. */
351 int flag_no_gnu_keywords;
353 /* Nonzero means do emit exported implementations of functions even if
354 they can be inlined. */
356 int flag_implement_inlines = 1;
358 /* Nonzero means that implicit instantiations will be emitted if needed. */
360 int flag_implicit_templates = 1;
362 /* Nonzero means that implicit instantiations of inline templates will be
363 emitted if needed, even if instantiations of non-inline templates
366 int flag_implicit_inline_templates = 1;
368 /* Nonzero means generate separate instantiation control files and
369 juggle them at link time. */
371 int flag_use_repository;
373 /* Nonzero if we want to issue diagnostics that the standard says are not
376 int flag_optional_diags = 1;
378 /* Nonzero means we should attempt to elide constructors when possible. */
380 int flag_elide_constructors = 1;
382 /* Nonzero means that member functions defined in class scope are
383 inline by default. */
385 int flag_default_inline = 1;
387 /* Controls whether compiler generates 'type descriptor' that give
388 run-time type information. */
392 /* Nonzero if we want to conserve space in the .o files. We do this
393 by putting uninitialized data and runtime initialized data into
394 .common instead of .data at the expense of not flagging multiple
397 int flag_conserve_space;
399 /* Nonzero if we want to obey access control semantics. */
401 int flag_access_control = 1;
403 /* Nonzero if we want to check the return value of new and avoid calling
404 constructors if it is a null pointer. */
408 /* The C++ dialect being used. C++98 is the default. */
410 enum cxx_dialect cxx_dialect = cxx98;
412 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
413 initialization variables.
414 0: Old rules, set by -fno-for-scope.
415 2: New ISO rules, set by -ffor-scope.
416 1: Try to implement new ISO rules, but with backup compatibility
417 (and warnings). This is the default, for now. */
419 int flag_new_for_scope = 1;
421 /* Nonzero if we want to emit defined symbols with common-like linkage as
422 weak symbols where possible, in order to conform to C++ semantics.
423 Otherwise, emit them as local symbols. */
427 /* 0 means we want the preprocessor to not emit line directives for
428 the current working directory. 1 means we want it to do it. -1
429 means we should decide depending on whether debugging information
430 is being emitted or not. */
432 int flag_working_directory = -1;
434 /* Nonzero to use __cxa_atexit, rather than atexit, to register
435 destructors for local statics and global objects. '2' means it has been
436 set nonzero as a default, not by a command-line flag. */
438 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
440 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
441 code. '2' means it has not been set explicitly on the command line. */
443 int flag_use_cxa_get_exception_ptr = 2;
445 /* Nonzero means make the default pedwarns warnings instead of errors.
446 The value of this flag is ignored if -pedantic is specified. */
450 /* Nonzero means to implement standard semantics for exception
451 specifications, calling unexpected if an exception is thrown that
452 doesn't match the specification. Zero means to treat them as
453 assertions and optimize accordingly, but not check them. */
455 int flag_enforce_eh_specs = 1;
457 /* Nonzero means to generate thread-safe code for initializing local
460 int flag_threadsafe_statics = 1;
462 /* Nonzero means warn about implicit declarations. */
464 int warn_implicit = 1;
466 /* Maximum template instantiation depth. This limit is rather
467 arbitrary, but it exists to limit the time it takes to notice
468 infinite template instantiations. */
470 int max_tinst_depth = 500;
474 /* The elements of `ridpointers' are identifier nodes for the reserved
475 type names and storage classes. It is indexed by a RID_... value. */
478 tree (*make_fname_decl) (tree, int);
480 /* Nonzero means the expression being parsed will never be evaluated.
481 This is a count, since unevaluated expressions can nest. */
484 /* Information about how a function name is generated. */
487 tree *const decl; /* pointer to the VAR_DECL. */
488 const unsigned rid; /* RID number for the identifier. */
489 const int pretty; /* How pretty is it? */
492 /* The three ways of getting then name of the current function. */
494 const struct fname_var_t fname_vars[] =
496 /* C99 compliant __func__, must be first. */
497 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
498 /* GCC __FUNCTION__ compliant. */
499 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
500 /* GCC __PRETTY_FUNCTION__ compliant. */
501 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
505 static tree check_case_value (tree);
506 static bool check_case_bounds (tree, tree, tree *, tree *);
508 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
509 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
510 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
511 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
512 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
513 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
514 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
515 static tree handle_always_inline_attribute (tree *, tree, tree, int,
517 static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
519 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
520 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
521 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
522 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
524 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
525 static tree handle_transparent_union_attribute (tree *, tree, tree,
527 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
528 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
532 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
533 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
534 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
535 static tree handle_visibility_attribute (tree *, tree, tree, int,
537 static tree handle_tls_model_attribute (tree *, tree, tree, int,
539 static tree handle_no_instrument_function_attribute (tree *, tree,
541 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
543 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
545 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
546 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
547 static tree handle_deprecated_attribute (tree *, tree, tree, int,
549 static tree handle_vector_size_attribute (tree *, tree, tree, int,
551 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
552 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
553 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
554 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
556 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
557 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
558 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
560 static void check_function_nonnull (tree, int, tree *);
561 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
562 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
563 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
564 static int resort_field_decl_cmp (const void *, const void *);
566 /* Table of machine-independent attributes common to all C-like languages. */
567 const struct attribute_spec c_common_attribute_table[] =
569 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
570 { "packed", 0, 0, false, false, false,
571 handle_packed_attribute },
572 { "nocommon", 0, 0, true, false, false,
573 handle_nocommon_attribute },
574 { "common", 0, 0, true, false, false,
575 handle_common_attribute },
576 /* FIXME: logically, noreturn attributes should be listed as
577 "false, true, true" and apply to function types. But implementing this
578 would require all the places in the compiler that use TREE_THIS_VOLATILE
579 on a decl to identify non-returning functions to be located and fixed
580 to check the function type instead. */
581 { "noreturn", 0, 0, true, false, false,
582 handle_noreturn_attribute },
583 { "volatile", 0, 0, true, false, false,
584 handle_noreturn_attribute },
585 { "noinline", 0, 0, true, false, false,
586 handle_noinline_attribute },
587 { "always_inline", 0, 0, true, false, false,
588 handle_always_inline_attribute },
589 { "gnu_inline", 0, 0, true, false, false,
590 handle_gnu_inline_attribute },
591 { "flatten", 0, 0, true, false, false,
592 handle_flatten_attribute },
593 { "used", 0, 0, true, false, false,
594 handle_used_attribute },
595 { "unused", 0, 0, false, false, false,
596 handle_unused_attribute },
597 { "externally_visible", 0, 0, true, false, false,
598 handle_externally_visible_attribute },
599 /* The same comments as for noreturn attributes apply to const ones. */
600 { "const", 0, 0, true, false, false,
601 handle_const_attribute },
602 { "transparent_union", 0, 0, false, false, false,
603 handle_transparent_union_attribute },
604 { "constructor", 0, 1, true, false, false,
605 handle_constructor_attribute },
606 { "destructor", 0, 1, true, false, false,
607 handle_destructor_attribute },
608 { "mode", 1, 1, false, true, false,
609 handle_mode_attribute },
610 { "section", 1, 1, true, false, false,
611 handle_section_attribute },
612 { "aligned", 0, 1, false, false, false,
613 handle_aligned_attribute },
614 { "weak", 0, 0, true, false, false,
615 handle_weak_attribute },
616 { "alias", 1, 1, true, false, false,
617 handle_alias_attribute },
618 { "weakref", 0, 1, true, false, false,
619 handle_weakref_attribute },
620 { "no_instrument_function", 0, 0, true, false, false,
621 handle_no_instrument_function_attribute },
622 { "malloc", 0, 0, true, false, false,
623 handle_malloc_attribute },
624 { "returns_twice", 0, 0, true, false, false,
625 handle_returns_twice_attribute },
626 { "no_stack_limit", 0, 0, true, false, false,
627 handle_no_limit_stack_attribute },
628 { "pure", 0, 0, true, false, false,
629 handle_pure_attribute },
630 /* For internal use (marking of builtins) only. The name contains space
631 to prevent its usage in source code. */
632 { "no vops", 0, 0, true, false, false,
633 handle_novops_attribute },
634 { "deprecated", 0, 0, false, false, false,
635 handle_deprecated_attribute },
636 { "vector_size", 1, 1, false, true, false,
637 handle_vector_size_attribute },
638 { "visibility", 1, 1, false, false, false,
639 handle_visibility_attribute },
640 { "tls_model", 1, 1, true, false, false,
641 handle_tls_model_attribute },
642 { "nonnull", 0, -1, false, true, true,
643 handle_nonnull_attribute },
644 { "nothrow", 0, 0, true, false, false,
645 handle_nothrow_attribute },
646 { "may_alias", 0, 0, false, true, false, NULL },
647 { "cleanup", 1, 1, true, false, false,
648 handle_cleanup_attribute },
649 { "warn_unused_result", 0, 0, false, true, true,
650 handle_warn_unused_result_attribute },
651 { "sentinel", 0, 1, false, true, true,
652 handle_sentinel_attribute },
653 /* For internal use (marking of builtins) only. The name contains space
654 to prevent its usage in source code. */
655 { "type generic", 0, 0, false, true, true,
656 handle_type_generic_attribute },
657 { "alloc_size", 1, 2, false, true, true,
658 handle_alloc_size_attribute },
659 { "cold", 0, 0, true, false, false,
660 handle_cold_attribute },
661 { "hot", 0, 0, true, false, false,
662 handle_hot_attribute },
663 { NULL, 0, 0, false, false, false, NULL }
666 /* Give the specifications for the format attributes, used by C and all
669 const struct attribute_spec c_common_format_attribute_table[] =
671 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
672 { "format", 3, 3, false, true, true,
673 handle_format_attribute },
674 { "format_arg", 1, 1, false, true, true,
675 handle_format_arg_attribute },
676 { NULL, 0, 0, false, false, false, NULL }
679 /* Push current bindings for the function name VAR_DECLS. */
682 start_fname_decls (void)
685 tree saved = NULL_TREE;
687 for (ix = 0; fname_vars[ix].decl; ix++)
689 tree decl = *fname_vars[ix].decl;
693 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
694 *fname_vars[ix].decl = NULL_TREE;
697 if (saved || saved_function_name_decls)
698 /* Normally they'll have been NULL, so only push if we've got a
699 stack, or they are non-NULL. */
700 saved_function_name_decls = tree_cons (saved, NULL_TREE,
701 saved_function_name_decls);
704 /* Finish up the current bindings, adding them into the current function's
705 statement tree. This must be done _before_ finish_stmt_tree is called.
706 If there is no current function, we must be at file scope and no statements
707 are involved. Pop the previous bindings. */
710 finish_fname_decls (void)
713 tree stmts = NULL_TREE;
714 tree stack = saved_function_name_decls;
716 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
717 append_to_statement_list (TREE_VALUE (stack), &stmts);
721 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
723 if (TREE_CODE (*bodyp) == BIND_EXPR)
724 bodyp = &BIND_EXPR_BODY (*bodyp);
726 append_to_statement_list_force (*bodyp, &stmts);
730 for (ix = 0; fname_vars[ix].decl; ix++)
731 *fname_vars[ix].decl = NULL_TREE;
735 /* We had saved values, restore them. */
738 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
740 tree decl = TREE_PURPOSE (saved);
741 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
743 *fname_vars[ix].decl = decl;
745 stack = TREE_CHAIN (stack);
747 saved_function_name_decls = stack;
750 /* Return the text name of the current function, suitably prettified
751 by PRETTY_P. Return string must be freed by caller. */
754 fname_as_string (int pretty_p)
756 const char *name = "top level";
766 if (current_function_decl)
767 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
769 if (c_lex_string_translate)
771 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
772 cpp_string cstr = { 0, 0 }, strname;
774 namep = XNEWVEC (char, len);
775 snprintf (namep, len, "\"%s\"", name);
776 strname.text = (unsigned char *) namep;
777 strname.len = len - 1;
779 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
782 return (const char *) cstr.text;
786 namep = xstrdup (name);
791 /* Expand DECL if it declares an entity not handled by the
795 c_expand_decl (tree decl)
797 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
799 /* Let the back-end know about this variable. */
800 if (!anon_aggr_type_p (TREE_TYPE (decl)))
801 emit_local_var (decl);
803 expand_anon_union_decl (decl, NULL_TREE,
804 DECL_ANON_UNION_ELEMS (decl));
813 /* Return the VAR_DECL for a const char array naming the current
814 function. If the VAR_DECL has not yet been created, create it
815 now. RID indicates how it should be formatted and IDENTIFIER_NODE
816 ID is its name (unfortunately C and C++ hold the RID values of
817 keywords in different places, so we can't derive RID from ID in
818 this language independent code. */
821 fname_decl (unsigned int rid, tree id)
824 tree decl = NULL_TREE;
826 for (ix = 0; fname_vars[ix].decl; ix++)
827 if (fname_vars[ix].rid == rid)
830 decl = *fname_vars[ix].decl;
833 /* If a tree is built here, it would normally have the lineno of
834 the current statement. Later this tree will be moved to the
835 beginning of the function and this line number will be wrong.
836 To avoid this problem set the lineno to 0 here; that prevents
837 it from appearing in the RTL. */
839 location_t saved_location = input_location;
840 #ifdef USE_MAPPED_LOCATION
841 input_location = UNKNOWN_LOCATION;
846 stmts = push_stmt_list ();
847 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
848 stmts = pop_stmt_list (stmts);
849 if (!IS_EMPTY_STMT (stmts))
850 saved_function_name_decls
851 = tree_cons (decl, stmts, saved_function_name_decls);
852 *fname_vars[ix].decl = decl;
853 input_location = saved_location;
855 if (!ix && !current_function_decl)
856 pedwarn ("%qD is not defined outside of function scope", decl);
861 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
864 fix_string_type (tree value)
866 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
867 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
868 int length = TREE_STRING_LENGTH (value);
870 tree e_type, i_type, a_type;
872 /* Compute the number of elements, for the array type. */
873 nchars = wide_flag ? length / wchar_bytes : length;
875 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
876 limit in C++98 Annex B is very large (65536) and is not normative,
877 so we do not diagnose it (warn_overlength_strings is forced off
878 in c_common_post_options). */
879 if (warn_overlength_strings)
881 const int nchars_max = flag_isoc99 ? 4095 : 509;
882 const int relevant_std = flag_isoc99 ? 99 : 90;
883 if (nchars - 1 > nchars_max)
884 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
885 separate the %d from the 'C'. 'ISO' should not be
886 translated, but it may be moved after 'C%d' in languages
887 where modifiers follow nouns. */
888 pedwarn ("string length %qd is greater than the length %qd "
889 "ISO C%d compilers are required to support",
890 nchars - 1, nchars_max, relevant_std);
893 /* Create the array type for the string constant. The ISO C++
894 standard says that a string literal has type `const char[N]' or
895 `const wchar_t[N]'. We use the same logic when invoked as a C
896 front-end with -Wwrite-strings.
897 ??? We should change the type of an expression depending on the
898 state of a warning flag. We should just be warning -- see how
899 this is handled in the C++ front-end for the deprecated implicit
900 conversion from string literals to `char*' or `wchar_t*'.
902 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
903 array type being the unqualified version of that type.
904 Therefore, if we are constructing an array of const char, we must
905 construct the matching unqualified array type first. The C front
906 end does not require this, but it does no harm, so we do it
908 e_type = wide_flag ? wchar_type_node : char_type_node;
909 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
910 a_type = build_array_type (e_type, i_type);
911 if (c_dialect_cxx() || warn_write_strings)
912 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
914 TREE_TYPE (value) = a_type;
915 TREE_CONSTANT (value) = 1;
916 TREE_INVARIANT (value) = 1;
917 TREE_READONLY (value) = 1;
918 TREE_STATIC (value) = 1;
922 /* Print a warning if a constant expression had overflow in folding.
923 Invoke this function on every expression that the language
924 requires to be a constant expression.
925 Note the ANSI C standard says it is erroneous for a
926 constant expression to overflow. */
929 constant_expression_warning (tree value)
931 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
932 || TREE_CODE (value) == VECTOR_CST
933 || TREE_CODE (value) == COMPLEX_CST)
934 && TREE_OVERFLOW (value)
937 pedwarn ("overflow in constant expression");
940 /* Print a warning if an expression had overflow in folding and its
943 Invoke this function on every expression that
944 (1) appears in the source code, and
945 (2) is a constant expression that overflowed, and
946 (3) is not already checked by convert_and_check;
947 however, do not invoke this function on operands of explicit casts
948 or when the expression is the result of an operator and any operand
949 already overflowed. */
952 overflow_warning (tree value)
954 if (skip_evaluation) return;
956 switch (TREE_CODE (value))
959 warning (OPT_Woverflow, "integer overflow in expression");
963 warning (OPT_Woverflow, "floating point overflow in expression");
967 warning (OPT_Woverflow, "vector overflow in expression");
971 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
972 warning (OPT_Woverflow, "complex integer overflow in expression");
973 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
974 warning (OPT_Woverflow, "complex floating point overflow in expression");
983 /* Warn about use of a logical || / && operator being used in a
984 context where it is likely that the bitwise equivalent was intended
985 by the programmer. CODE is the TREE_CODE of the operator, ARG1
986 and ARG2 the arguments. */
989 warn_logical_operator (enum tree_code code, tree arg1, tree
994 case TRUTH_ANDIF_EXPR:
995 case TRUTH_ORIF_EXPR:
998 if (!TREE_NO_WARNING (arg1)
999 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
1000 && !CONSTANT_CLASS_P (arg1)
1001 && TREE_CODE (arg2) == INTEGER_CST
1002 && !integer_zerop (arg2))
1004 warning (OPT_Wlogical_op,
1005 "logical %<%s%> with non-zero constant "
1006 "will always evaluate as true",
1007 ((code == TRUTH_ANDIF_EXPR)
1008 || (code == TRUTH_AND_EXPR)) ? "&&" : "||");
1009 TREE_NO_WARNING (arg1) = true;
1018 /* Print a warning about casts that might indicate violation
1019 of strict aliasing rules if -Wstrict-aliasing is used and
1020 strict aliasing mode is in effect. OTYPE is the original
1021 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1024 strict_aliasing_warning (tree otype, tree type, tree expr)
1026 if (!(flag_strict_aliasing && POINTER_TYPE_P (type)
1027 && POINTER_TYPE_P (otype) && !VOID_TYPE_P (TREE_TYPE (type))))
1030 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1031 && (DECL_P (TREE_OPERAND (expr, 0))
1032 || handled_component_p (TREE_OPERAND (expr, 0))))
1034 /* Casting the address of an object to non void pointer. Warn
1035 if the cast breaks type based aliasing. */
1036 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1038 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1039 "might break strict-aliasing rules");
1044 /* warn_strict_aliasing >= 3. This includes the default (3).
1045 Only warn if the cast is dereferenced immediately. */
1046 alias_set_type set1 =
1047 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1048 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1050 if (!alias_sets_conflict_p (set1, set2))
1052 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1053 "pointer will break strict-aliasing rules");
1056 else if (warn_strict_aliasing == 2
1057 && !alias_sets_must_conflict_p (set1, set2))
1059 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1060 "pointer might break strict-aliasing rules");
1066 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1068 /* At this level, warn for any conversions, even if an address is
1069 not taken in the same statement. This will likely produce many
1070 false positives, but could be useful to pinpoint problems that
1071 are not revealed at higher levels. */
1072 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1073 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1074 if (!COMPLETE_TYPE_P (type)
1075 || !alias_sets_must_conflict_p (set1, set2))
1077 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1078 "pointer might break strict-aliasing rules");
1086 /* Print a warning about if (); or if () .. else; constructs
1087 via the special empty statement node that we create. INNER_THEN
1088 and INNER_ELSE are the statement lists of the if and the else
1092 empty_if_body_warning (tree inner_then, tree inner_else)
1094 if (TREE_CODE (inner_then) == STATEMENT_LIST
1095 && STATEMENT_LIST_TAIL (inner_then))
1096 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1098 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1099 && STATEMENT_LIST_TAIL (inner_else))
1100 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1102 if (IS_EMPTY_STMT (inner_then) && !inner_else)
1103 warning (OPT_Wempty_body, "%Hsuggest braces around empty body "
1104 "in an %<if%> statement", EXPR_LOCUS (inner_then));
1106 else if (inner_else && IS_EMPTY_STMT (inner_else))
1107 warning (OPT_Wempty_body, "%Hsuggest braces around empty body "
1108 "in an %<else%> statement", EXPR_LOCUS (inner_else));
1111 /* Warn for unlikely, improbable, or stupid DECL declarations
1115 check_main_parameter_types (tree decl)
1120 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1121 args = TREE_CHAIN (args))
1123 tree type = args ? TREE_VALUE (args) : 0;
1125 if (type == void_type_node || type == error_mark_node )
1132 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1133 pedwarn ("first argument of %q+D should be %<int%>", decl);
1137 if (TREE_CODE (type) != POINTER_TYPE
1138 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1139 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1141 pedwarn ("second argument of %q+D should be %<char **%>",
1146 if (TREE_CODE (type) != POINTER_TYPE
1147 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1148 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1150 pedwarn ("third argument of %q+D should probably be "
1151 "%<char **%>", decl);
1156 /* It is intentional that this message does not mention the third
1157 argument because it's only mentioned in an appendix of the
1159 if (argct > 0 && (argct < 2 || argct > 3))
1160 pedwarn ("%q+D takes only zero or two arguments", decl);
1163 /* True if vector types T1 and T2 can be converted to each other
1164 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1165 can only be converted with -flax-vector-conversions yet that is not
1166 in effect, emit a note telling the user about that option if such
1167 a note has not previously been emitted. */
1169 vector_types_convertible_p (tree t1, tree t2, bool emit_lax_note)
1171 static bool emitted_lax_note = false;
1172 bool convertible_lax;
1174 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1175 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1179 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1180 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1181 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1182 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1183 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1185 if (!convertible_lax || flag_lax_vector_conversions)
1186 return convertible_lax;
1188 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1189 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
1192 if (emit_lax_note && !emitted_lax_note)
1194 emitted_lax_note = true;
1195 inform ("use -flax-vector-conversions to permit "
1196 "conversions between vectors with differing "
1197 "element types or numbers of subparts");
1203 /* Warns if the conversion of EXPR to TYPE may alter a value.
1204 This is a helper function for warnings_for_convert_and_check. */
1207 conversion_warning (tree type, tree expr)
1209 bool give_warning = false;
1211 unsigned int formal_prec = TYPE_PRECISION (type);
1213 if (!warn_conversion && !warn_sign_conversion)
1216 if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST)
1218 /* Warn for real constant that is not an exact integer converted
1220 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1221 && TREE_CODE (type) == INTEGER_TYPE)
1223 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (TREE_TYPE (expr))))
1224 give_warning = true;
1226 /* Warn for an integer constant that does not fit into integer type. */
1227 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1228 && TREE_CODE (type) == INTEGER_TYPE
1229 && !int_fits_type_p (expr, type))
1231 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr)))
1232 warning (OPT_Wsign_conversion,
1233 "negative integer implicitly converted to unsigned type");
1234 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (TREE_TYPE (expr)))
1235 warning (OPT_Wsign_conversion,
1236 "conversion of unsigned constant value to negative integer");
1238 give_warning = true;
1240 else if (TREE_CODE (type) == REAL_TYPE)
1242 /* Warn for an integer constant that does not fit into real type. */
1243 if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE)
1245 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1246 if (!exact_real_truncate (TYPE_MODE (type), &a))
1247 give_warning = true;
1249 /* Warn for a real constant that does not fit into a smaller
1251 else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1252 && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1254 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1255 if (!exact_real_truncate (TYPE_MODE (type), &a))
1256 give_warning = true;
1261 warning (OPT_Wconversion,
1262 "conversion to %qT alters %qT constant value",
1263 type, TREE_TYPE (expr));
1265 else /* 'expr' is not a constant. */
1267 /* Warn for real types converted to integer types. */
1268 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1269 && TREE_CODE (type) == INTEGER_TYPE)
1270 give_warning = true;
1272 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1273 && TREE_CODE (type) == INTEGER_TYPE)
1275 /* Warn for integer types converted to smaller integer types. */
1276 if (formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1277 give_warning = true;
1279 /* When they are the same width but different signedness,
1280 then the value may change. */
1281 else if ((formal_prec == TYPE_PRECISION (TREE_TYPE (expr))
1282 && TYPE_UNSIGNED (TREE_TYPE (expr)) != TYPE_UNSIGNED (type))
1283 /* Even when converted to a bigger type, if the type is
1284 unsigned but expr is signed, then negative values
1286 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr))))
1287 warning (OPT_Wsign_conversion,
1288 "conversion to %qT from %qT may change the sign of the result",
1289 type, TREE_TYPE (expr));
1292 /* Warn for integer types converted to real types if and only if
1293 all the range of values of the integer type cannot be
1294 represented by the real type. */
1295 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1296 && TREE_CODE (type) == REAL_TYPE)
1298 tree type_low_bound = TYPE_MIN_VALUE (TREE_TYPE (expr));
1299 tree type_high_bound = TYPE_MAX_VALUE (TREE_TYPE (expr));
1300 REAL_VALUE_TYPE real_low_bound = real_value_from_int_cst (0, type_low_bound);
1301 REAL_VALUE_TYPE real_high_bound = real_value_from_int_cst (0, type_high_bound);
1303 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1304 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1305 give_warning = true;
1308 /* Warn for real types converted to smaller real types. */
1309 else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1310 && TREE_CODE (type) == REAL_TYPE
1311 && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1312 give_warning = true;
1316 warning (OPT_Wconversion,
1317 "conversion to %qT from %qT may alter its value",
1318 type, TREE_TYPE (expr));
1322 /* Produce warnings after a conversion. RESULT is the result of
1323 converting EXPR to TYPE. This is a helper function for
1324 convert_and_check and cp_convert_and_check. */
1327 warnings_for_convert_and_check (tree type, tree expr, tree result)
1329 if (TREE_CODE (expr) == INTEGER_CST
1330 && (TREE_CODE (type) == INTEGER_TYPE
1331 || TREE_CODE (type) == ENUMERAL_TYPE)
1332 && !int_fits_type_p (expr, type))
1334 /* Do not diagnose overflow in a constant expression merely
1335 because a conversion overflowed. */
1336 if (TREE_OVERFLOW (result))
1337 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1339 if (TYPE_UNSIGNED (type))
1341 /* This detects cases like converting -129 or 256 to
1343 if (!int_fits_type_p (expr, c_common_signed_type (type)))
1344 warning (OPT_Woverflow,
1345 "large integer implicitly truncated to unsigned type");
1347 conversion_warning (type, expr);
1349 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
1350 warning (OPT_Woverflow,
1351 "overflow in implicit constant conversion");
1352 /* No warning for converting 0x80000000 to int. */
1354 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1355 || TYPE_PRECISION (TREE_TYPE (expr))
1356 != TYPE_PRECISION (type)))
1357 warning (OPT_Woverflow,
1358 "overflow in implicit constant conversion");
1361 conversion_warning (type, expr);
1363 else if (TREE_CODE (result) == INTEGER_CST && TREE_OVERFLOW (result))
1364 warning (OPT_Woverflow,
1365 "overflow in implicit constant conversion");
1367 conversion_warning (type, expr);
1371 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1372 Invoke this function on every expression that is converted implicitly,
1373 i.e. because of language rules and not because of an explicit cast. */
1376 convert_and_check (tree type, tree expr)
1380 if (TREE_TYPE (expr) == type)
1383 result = convert (type, expr);
1385 if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
1386 warnings_for_convert_and_check (type, expr, result);
1391 /* A node in a list that describes references to variables (EXPR), which are
1392 either read accesses if WRITER is zero, or write accesses, in which case
1393 WRITER is the parent of EXPR. */
1400 /* Used to implement a cache the results of a call to verify_tree. We only
1401 use this for SAVE_EXPRs. */
1404 struct tlist_cache *next;
1405 struct tlist *cache_before_sp;
1406 struct tlist *cache_after_sp;
1410 /* Obstack to use when allocating tlist structures, and corresponding
1412 static struct obstack tlist_obstack;
1413 static char *tlist_firstobj = 0;
1415 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1417 static struct tlist *warned_ids;
1418 /* SAVE_EXPRs need special treatment. We process them only once and then
1419 cache the results. */
1420 static struct tlist_cache *save_expr_cache;
1422 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1423 static void merge_tlist (struct tlist **, struct tlist *, int);
1424 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1425 static int warning_candidate_p (tree);
1426 static void warn_for_collisions (struct tlist *);
1427 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1428 static struct tlist *new_tlist (struct tlist *, tree, tree);
1430 /* Create a new struct tlist and fill in its fields. */
1431 static struct tlist *
1432 new_tlist (struct tlist *next, tree t, tree writer)
1435 l = XOBNEW (&tlist_obstack, struct tlist);
1442 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1443 is nonnull, we ignore any node we find which has a writer equal to it. */
1446 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1450 struct tlist *next = add->next;
1453 if (!exclude_writer || add->writer != exclude_writer)
1454 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1459 /* Merge the nodes of ADD into TO. This merging process is done so that for
1460 each variable that already exists in TO, no new node is added; however if
1461 there is a write access recorded in ADD, and an occurrence on TO is only
1462 a read access, then the occurrence in TO will be modified to record the
1466 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1468 struct tlist **end = to;
1471 end = &(*end)->next;
1477 struct tlist *next = add->next;
1479 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1480 if (tmp2->expr == add->expr)
1484 tmp2->writer = add->writer;
1488 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1489 end = &(*end)->next;
1496 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1497 references in list LIST conflict with it, excluding reads if ONLY writers
1501 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1506 /* Avoid duplicate warnings. */
1507 for (tmp = warned_ids; tmp; tmp = tmp->next)
1508 if (tmp->expr == written)
1513 if (list->expr == written
1514 && list->writer != writer
1515 && (!only_writes || list->writer)
1516 && DECL_NAME (list->expr))
1518 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1519 warning (0, "operation on %qE may be undefined", list->expr);
1525 /* Given a list LIST of references to variables, find whether any of these
1526 can cause conflicts due to missing sequence points. */
1529 warn_for_collisions (struct tlist *list)
1533 for (tmp = list; tmp; tmp = tmp->next)
1536 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1540 /* Return nonzero if X is a tree that can be verified by the sequence point
1543 warning_candidate_p (tree x)
1545 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1548 /* Walk the tree X, and record accesses to variables. If X is written by the
1549 parent tree, WRITER is the parent.
1550 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1551 expression or its only operand forces a sequence point, then everything up
1552 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1554 Once we return, we will have emitted warnings if any subexpression before
1555 such a sequence point could be undefined. On a higher level, however, the
1556 sequence point may not be relevant, and we'll merge the two lists.
1558 Example: (b++, a) + b;
1559 The call that processes the COMPOUND_EXPR will store the increment of B
1560 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1561 processes the PLUS_EXPR will need to merge the two lists so that
1562 eventually, all accesses end up on the same list (and we'll warn about the
1563 unordered subexpressions b++ and b.
1565 A note on merging. If we modify the former example so that our expression
1568 care must be taken not simply to add all three expressions into the final
1569 PNO_SP list. The function merge_tlist takes care of that by merging the
1570 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1571 way, so that no more than one access to B is recorded. */
1574 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1577 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1578 enum tree_code code;
1579 enum tree_code_class cl;
1581 /* X may be NULL if it is the operand of an empty statement expression
1587 code = TREE_CODE (x);
1588 cl = TREE_CODE_CLASS (code);
1590 if (warning_candidate_p (x))
1592 *pno_sp = new_tlist (*pno_sp, x, writer);
1602 case TRUTH_ANDIF_EXPR:
1603 case TRUTH_ORIF_EXPR:
1604 tmp_before = tmp_nosp = tmp_list3 = 0;
1605 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1606 warn_for_collisions (tmp_nosp);
1607 merge_tlist (pbefore_sp, tmp_before, 0);
1608 merge_tlist (pbefore_sp, tmp_nosp, 0);
1609 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1610 merge_tlist (pbefore_sp, tmp_list3, 0);
1614 tmp_before = tmp_list2 = 0;
1615 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1616 warn_for_collisions (tmp_list2);
1617 merge_tlist (pbefore_sp, tmp_before, 0);
1618 merge_tlist (pbefore_sp, tmp_list2, 1);
1620 tmp_list3 = tmp_nosp = 0;
1621 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1622 warn_for_collisions (tmp_nosp);
1623 merge_tlist (pbefore_sp, tmp_list3, 0);
1625 tmp_list3 = tmp_list2 = 0;
1626 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1627 warn_for_collisions (tmp_list2);
1628 merge_tlist (pbefore_sp, tmp_list3, 0);
1629 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1630 two first, to avoid warning for (a ? b++ : b++). */
1631 merge_tlist (&tmp_nosp, tmp_list2, 0);
1632 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1635 case PREDECREMENT_EXPR:
1636 case PREINCREMENT_EXPR:
1637 case POSTDECREMENT_EXPR:
1638 case POSTINCREMENT_EXPR:
1639 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1643 tmp_before = tmp_nosp = tmp_list3 = 0;
1644 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1645 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1646 /* Expressions inside the LHS are not ordered wrt. the sequence points
1647 in the RHS. Example:
1649 Despite the fact that the modification of "a" is in the before_sp
1650 list (tmp_before), it conflicts with the use of "a" in the LHS.
1651 We can handle this by adding the contents of tmp_list3
1652 to those of tmp_before, and redoing the collision warnings for that
1654 add_tlist (&tmp_before, tmp_list3, x, 1);
1655 warn_for_collisions (tmp_before);
1656 /* Exclude the LHS itself here; we first have to merge it into the
1657 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1658 didn't exclude the LHS, we'd get it twice, once as a read and once
1660 add_tlist (pno_sp, tmp_list3, x, 0);
1661 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1663 merge_tlist (pbefore_sp, tmp_before, 0);
1664 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1665 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1666 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1670 /* We need to warn about conflicts among arguments and conflicts between
1671 args and the function address. Side effects of the function address,
1672 however, are not ordered by the sequence point of the call. */
1674 call_expr_arg_iterator iter;
1676 tmp_before = tmp_nosp = 0;
1677 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
1678 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
1680 tmp_list2 = tmp_list3 = 0;
1681 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
1682 merge_tlist (&tmp_list3, tmp_list2, 0);
1683 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1685 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1686 warn_for_collisions (tmp_before);
1687 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1692 /* Scan all the list, e.g. indices of multi dimensional array. */
1695 tmp_before = tmp_nosp = 0;
1696 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1697 merge_tlist (&tmp_nosp, tmp_before, 0);
1698 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1705 struct tlist_cache *t;
1706 for (t = save_expr_cache; t; t = t->next)
1712 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1713 t->next = save_expr_cache;
1715 save_expr_cache = t;
1717 tmp_before = tmp_nosp = 0;
1718 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1719 warn_for_collisions (tmp_nosp);
1724 struct tlist *t = tmp_nosp;
1726 merge_tlist (&tmp_list3, t, 0);
1728 t->cache_before_sp = tmp_before;
1729 t->cache_after_sp = tmp_list3;
1731 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1732 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1737 /* For other expressions, simply recurse on their operands.
1738 Manual tail recursion for unary expressions.
1739 Other non-expressions need not be processed. */
1740 if (cl == tcc_unary)
1742 x = TREE_OPERAND (x, 0);
1746 else if (IS_EXPR_CODE_CLASS (cl))
1749 int max = TREE_OPERAND_LENGTH (x);
1750 for (lp = 0; lp < max; lp++)
1752 tmp_before = tmp_nosp = 0;
1753 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1754 merge_tlist (&tmp_nosp, tmp_before, 0);
1755 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1762 /* Try to warn for undefined behavior in EXPR due to missing sequence
1766 verify_sequence_points (tree expr)
1768 struct tlist *before_sp = 0, *after_sp = 0;
1771 save_expr_cache = 0;
1772 if (tlist_firstobj == 0)
1774 gcc_obstack_init (&tlist_obstack);
1775 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1778 verify_tree (expr, &before_sp, &after_sp, 0);
1779 warn_for_collisions (after_sp);
1780 obstack_free (&tlist_obstack, tlist_firstobj);
1783 /* Validate the expression after `case' and apply default promotions. */
1786 check_case_value (tree value)
1788 if (value == NULL_TREE)
1791 /* ??? Can we ever get nops here for a valid case value? We
1793 STRIP_TYPE_NOPS (value);
1794 /* In C++, the following is allowed:
1797 switch (...) { case i: ... }
1799 So, we try to reduce the VALUE to a constant that way. */
1800 if (c_dialect_cxx ())
1802 value = decl_constant_value (value);
1803 STRIP_TYPE_NOPS (value);
1804 value = fold (value);
1807 if (TREE_CODE (value) == INTEGER_CST)
1808 /* Promote char or short to int. */
1809 value = perform_integral_promotions (value);
1810 else if (value != error_mark_node)
1812 error ("case label does not reduce to an integer constant");
1813 value = error_mark_node;
1816 constant_expression_warning (value);
1821 /* See if the case values LOW and HIGH are in the range of the original
1822 type (i.e. before the default conversion to int) of the switch testing
1824 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1825 the type before promoting it. CASE_LOW_P is a pointer to the lower
1826 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1827 if the case is not a case range.
1828 The caller has to make sure that we are not called with NULL for
1829 CASE_LOW_P (i.e. the default case).
1830 Returns true if the case label is in range of ORIG_TYPE (saturated or
1831 untouched) or false if the label is out of range. */
1834 check_case_bounds (tree type, tree orig_type,
1835 tree *case_low_p, tree *case_high_p)
1837 tree min_value, max_value;
1838 tree case_low = *case_low_p;
1839 tree case_high = case_high_p ? *case_high_p : case_low;
1841 /* If there was a problem with the original type, do nothing. */
1842 if (orig_type == error_mark_node)
1845 min_value = TYPE_MIN_VALUE (orig_type);
1846 max_value = TYPE_MAX_VALUE (orig_type);
1848 /* Case label is less than minimum for type. */
1849 if (tree_int_cst_compare (case_low, min_value) < 0
1850 && tree_int_cst_compare (case_high, min_value) < 0)
1852 warning (0, "case label value is less than minimum value for type");
1856 /* Case value is greater than maximum for type. */
1857 if (tree_int_cst_compare (case_low, max_value) > 0
1858 && tree_int_cst_compare (case_high, max_value) > 0)
1860 warning (0, "case label value exceeds maximum value for type");
1864 /* Saturate lower case label value to minimum. */
1865 if (tree_int_cst_compare (case_high, min_value) >= 0
1866 && tree_int_cst_compare (case_low, min_value) < 0)
1868 warning (0, "lower value in case label range"
1869 " less than minimum value for type");
1870 case_low = min_value;
1873 /* Saturate upper case label value to maximum. */
1874 if (tree_int_cst_compare (case_low, max_value) <= 0
1875 && tree_int_cst_compare (case_high, max_value) > 0)
1877 warning (0, "upper value in case label range"
1878 " exceeds maximum value for type");
1879 case_high = max_value;
1882 if (*case_low_p != case_low)
1883 *case_low_p = convert (type, case_low);
1884 if (case_high_p && *case_high_p != case_high)
1885 *case_high_p = convert (type, case_high);
1890 /* Return an integer type with BITS bits of precision,
1891 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1894 c_common_type_for_size (unsigned int bits, int unsignedp)
1896 if (bits == TYPE_PRECISION (integer_type_node))
1897 return unsignedp ? unsigned_type_node : integer_type_node;
1899 if (bits == TYPE_PRECISION (signed_char_type_node))
1900 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1902 if (bits == TYPE_PRECISION (short_integer_type_node))
1903 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1905 if (bits == TYPE_PRECISION (long_integer_type_node))
1906 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1908 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1909 return (unsignedp ? long_long_unsigned_type_node
1910 : long_long_integer_type_node);
1912 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1913 return (unsignedp ? widest_unsigned_literal_type_node
1914 : widest_integer_literal_type_node);
1916 if (bits <= TYPE_PRECISION (intQI_type_node))
1917 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1919 if (bits <= TYPE_PRECISION (intHI_type_node))
1920 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1922 if (bits <= TYPE_PRECISION (intSI_type_node))
1923 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1925 if (bits <= TYPE_PRECISION (intDI_type_node))
1926 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1931 /* Used for communication between c_common_type_for_mode and
1932 c_register_builtin_type. */
1933 static GTY(()) tree registered_builtin_types;
1935 /* Return a data type that has machine mode MODE.
1936 If the mode is an integer,
1937 then UNSIGNEDP selects between signed and unsigned types. */
1940 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1944 if (mode == TYPE_MODE (integer_type_node))
1945 return unsignedp ? unsigned_type_node : integer_type_node;
1947 if (mode == TYPE_MODE (signed_char_type_node))
1948 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1950 if (mode == TYPE_MODE (short_integer_type_node))
1951 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1953 if (mode == TYPE_MODE (long_integer_type_node))
1954 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1956 if (mode == TYPE_MODE (long_long_integer_type_node))
1957 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1959 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1960 return unsignedp ? widest_unsigned_literal_type_node
1961 : widest_integer_literal_type_node;
1964 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1967 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1970 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1973 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1975 #if HOST_BITS_PER_WIDE_INT >= 64
1976 if (mode == TYPE_MODE (intTI_type_node))
1977 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1980 if (mode == TYPE_MODE (float_type_node))
1981 return float_type_node;
1983 if (mode == TYPE_MODE (double_type_node))
1984 return double_type_node;
1986 if (mode == TYPE_MODE (long_double_type_node))
1987 return long_double_type_node;
1989 if (mode == TYPE_MODE (void_type_node))
1990 return void_type_node;
1992 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1994 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1995 : make_signed_type (GET_MODE_PRECISION (mode)));
1997 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1999 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2000 : make_signed_type (GET_MODE_PRECISION (mode)));
2002 if (COMPLEX_MODE_P (mode))
2004 enum machine_mode inner_mode;
2007 if (mode == TYPE_MODE (complex_float_type_node))
2008 return complex_float_type_node;
2009 if (mode == TYPE_MODE (complex_double_type_node))
2010 return complex_double_type_node;
2011 if (mode == TYPE_MODE (complex_long_double_type_node))
2012 return complex_long_double_type_node;
2014 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2015 return complex_integer_type_node;
2017 inner_mode = GET_MODE_INNER (mode);
2018 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2019 if (inner_type != NULL_TREE)
2020 return build_complex_type (inner_type);
2022 else if (VECTOR_MODE_P (mode))
2024 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2025 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2026 if (inner_type != NULL_TREE)
2027 return build_vector_type_for_mode (inner_type, mode);
2030 if (mode == TYPE_MODE (dfloat32_type_node))
2031 return dfloat32_type_node;
2032 if (mode == TYPE_MODE (dfloat64_type_node))
2033 return dfloat64_type_node;
2034 if (mode == TYPE_MODE (dfloat128_type_node))
2035 return dfloat128_type_node;
2037 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2038 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2039 return TREE_VALUE (t);
2045 c_common_unsigned_type (tree type)
2047 return c_common_signed_or_unsigned_type (1, type);
2050 /* Return a signed type the same as TYPE in other respects. */
2053 c_common_signed_type (tree type)
2055 return c_common_signed_or_unsigned_type (0, type);
2058 /* Return a type the same as TYPE except unsigned or
2059 signed according to UNSIGNEDP. */
2062 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2066 /* This block of code emulates the behavior of the old
2067 c_common_unsigned_type. In particular, it returns
2068 long_unsigned_type_node if passed a long, even when a int would
2069 have the same size. This is necessary for warnings to work
2070 correctly in archs where sizeof(int) == sizeof(long) */
2072 type1 = TYPE_MAIN_VARIANT (type);
2073 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2074 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2075 if (type1 == integer_type_node || type1 == unsigned_type_node)
2076 return unsignedp ? unsigned_type_node : integer_type_node;
2077 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2078 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2079 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2080 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2081 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
2082 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2083 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
2084 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
2085 #if HOST_BITS_PER_WIDE_INT >= 64
2086 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2087 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2089 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2090 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2091 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2092 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2093 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2094 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2095 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2096 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2098 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2099 the precision; they have precision set to match their range, but
2100 may use a wider mode to match an ABI. If we change modes, we may
2101 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2102 the precision as well, so as to yield correct results for
2103 bit-field types. C++ does not have these separate bit-field
2104 types, and producing a signed or unsigned variant of an
2105 ENUMERAL_TYPE may cause other problems as well. */
2107 if (!INTEGRAL_TYPE_P (type)
2108 || TYPE_UNSIGNED (type) == unsignedp)
2111 #define TYPE_OK(node) \
2112 (TYPE_MODE (type) == TYPE_MODE (node) \
2113 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
2114 if (TYPE_OK (signed_char_type_node))
2115 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2116 if (TYPE_OK (integer_type_node))
2117 return unsignedp ? unsigned_type_node : integer_type_node;
2118 if (TYPE_OK (short_integer_type_node))
2119 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2120 if (TYPE_OK (long_integer_type_node))
2121 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2122 if (TYPE_OK (long_long_integer_type_node))
2123 return (unsignedp ? long_long_unsigned_type_node
2124 : long_long_integer_type_node);
2125 if (TYPE_OK (widest_integer_literal_type_node))
2126 return (unsignedp ? widest_unsigned_literal_type_node
2127 : widest_integer_literal_type_node);
2129 #if HOST_BITS_PER_WIDE_INT >= 64
2130 if (TYPE_OK (intTI_type_node))
2131 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2133 if (TYPE_OK (intDI_type_node))
2134 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2135 if (TYPE_OK (intSI_type_node))
2136 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2137 if (TYPE_OK (intHI_type_node))
2138 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2139 if (TYPE_OK (intQI_type_node))
2140 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2143 if (c_dialect_cxx ())
2146 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2149 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2152 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2154 /* Extended integer types of the same width as a standard type have
2155 lesser rank, so those of the same width as int promote to int or
2156 unsigned int and are valid for printf formats expecting int or
2157 unsigned int. To avoid such special cases, avoid creating
2158 extended integer types for bit-fields if a standard integer type
2160 if (width == TYPE_PRECISION (integer_type_node))
2161 return unsignedp ? unsigned_type_node : integer_type_node;
2162 if (width == TYPE_PRECISION (signed_char_type_node))
2163 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2164 if (width == TYPE_PRECISION (short_integer_type_node))
2165 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2166 if (width == TYPE_PRECISION (long_integer_type_node))
2167 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2168 if (width == TYPE_PRECISION (long_long_integer_type_node))
2169 return (unsignedp ? long_long_unsigned_type_node
2170 : long_long_integer_type_node);
2171 return build_nonstandard_integer_type (width, unsignedp);
2174 /* The C version of the register_builtin_type langhook. */
2177 c_register_builtin_type (tree type, const char* name)
2181 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2182 DECL_ARTIFICIAL (decl) = 1;
2183 if (!TYPE_NAME (type))
2184 TYPE_NAME (type) = decl;
2187 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2191 /* Return the minimum number of bits needed to represent VALUE in a
2192 signed or unsigned type, UNSIGNEDP says which. */
2195 min_precision (tree value, int unsignedp)
2199 /* If the value is negative, compute its negative minus 1. The latter
2200 adjustment is because the absolute value of the largest negative value
2201 is one larger than the largest positive value. This is equivalent to
2202 a bit-wise negation, so use that operation instead. */
2204 if (tree_int_cst_sgn (value) < 0)
2205 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2207 /* Return the number of bits needed, taking into account the fact
2208 that we need one more bit for a signed than unsigned type. */
2210 if (integer_zerop (value))
2213 log = tree_floor_log2 (value);
2215 return log + 1 + !unsignedp;
2218 /* Print an error message for invalid operands to arith operation
2219 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */
2222 binary_op_error (enum tree_code code, tree type0, tree type1)
2229 opname = "+"; break;
2231 opname = "-"; break;
2233 opname = "*"; break;
2235 opname = "max"; break;
2237 opname = "min"; break;
2239 opname = "=="; break;
2241 opname = "!="; break;
2243 opname = "<="; break;
2245 opname = ">="; break;
2247 opname = "<"; break;
2249 opname = ">"; break;
2251 opname = "<<"; break;
2253 opname = ">>"; break;
2254 case TRUNC_MOD_EXPR:
2255 case FLOOR_MOD_EXPR:
2256 opname = "%"; break;
2257 case TRUNC_DIV_EXPR:
2258 case FLOOR_DIV_EXPR:
2259 opname = "/"; break;
2261 opname = "&"; break;
2263 opname = "|"; break;
2264 case TRUTH_ANDIF_EXPR:
2265 opname = "&&"; break;
2266 case TRUTH_ORIF_EXPR:
2267 opname = "||"; break;
2269 opname = "^"; break;
2273 error ("invalid operands to binary %s (have %qT and %qT)", opname,
2277 /* Subroutine of build_binary_op, used for comparison operations.
2278 See if the operands have both been converted from subword integer types
2279 and, if so, perhaps change them both back to their original type.
2280 This function is also responsible for converting the two operands
2281 to the proper common type for comparison.
2283 The arguments of this function are all pointers to local variables
2284 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2285 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2287 If this function returns nonzero, it means that the comparison has
2288 a constant value. What this function returns is an expression for
2292 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2293 enum tree_code *rescode_ptr)
2296 tree op0 = *op0_ptr;
2297 tree op1 = *op1_ptr;
2298 int unsignedp0, unsignedp1;
2300 tree primop0, primop1;
2301 enum tree_code code = *rescode_ptr;
2303 /* Throw away any conversions to wider types
2304 already present in the operands. */
2306 primop0 = get_narrower (op0, &unsignedp0);
2307 primop1 = get_narrower (op1, &unsignedp1);
2309 /* Handle the case that OP0 does not *contain* a conversion
2310 but it *requires* conversion to FINAL_TYPE. */
2312 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2313 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2314 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2315 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2317 /* If one of the operands must be floated, we cannot optimize. */
2318 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2319 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2321 /* If first arg is constant, swap the args (changing operation
2322 so value is preserved), for canonicalization. Don't do this if
2323 the second arg is 0. */
2325 if (TREE_CONSTANT (primop0)
2326 && !integer_zerop (primop1) && !real_zerop (primop1))
2329 int temi = unsignedp0;
2337 unsignedp0 = unsignedp1;
2360 *rescode_ptr = code;
2363 /* If comparing an integer against a constant more bits wide,
2364 maybe we can deduce a value of 1 or 0 independent of the data.
2365 Or else truncate the constant now
2366 rather than extend the variable at run time.
2368 This is only interesting if the constant is the wider arg.
2369 Also, it is not safe if the constant is unsigned and the
2370 variable arg is signed, since in this case the variable
2371 would be sign-extended and then regarded as unsigned.
2372 Our technique fails in this case because the lowest/highest
2373 possible unsigned results don't follow naturally from the
2374 lowest/highest possible values of the variable operand.
2375 For just EQ_EXPR and NE_EXPR there is another technique that
2376 could be used: see if the constant can be faithfully represented
2377 in the other operand's type, by truncating it and reextending it
2378 and see if that preserves the constant's value. */
2380 if (!real1 && !real2
2381 && TREE_CODE (primop1) == INTEGER_CST
2382 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2384 int min_gt, max_gt, min_lt, max_lt;
2385 tree maxval, minval;
2386 /* 1 if comparison is nominally unsigned. */
2387 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2390 type = c_common_signed_or_unsigned_type (unsignedp0,
2391 TREE_TYPE (primop0));
2393 maxval = TYPE_MAX_VALUE (type);
2394 minval = TYPE_MIN_VALUE (type);
2396 if (unsignedp && !unsignedp0)
2397 *restype_ptr = c_common_signed_type (*restype_ptr);
2399 if (TREE_TYPE (primop1) != *restype_ptr)
2401 /* Convert primop1 to target type, but do not introduce
2402 additional overflow. We know primop1 is an int_cst. */
2403 primop1 = force_fit_type_double (*restype_ptr,
2404 TREE_INT_CST_LOW (primop1),
2405 TREE_INT_CST_HIGH (primop1), 0,
2406 TREE_OVERFLOW (primop1));
2408 if (type != *restype_ptr)
2410 minval = convert (*restype_ptr, minval);
2411 maxval = convert (*restype_ptr, maxval);
2414 if (unsignedp && unsignedp0)
2416 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2417 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2418 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2419 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2423 min_gt = INT_CST_LT (primop1, minval);
2424 max_gt = INT_CST_LT (primop1, maxval);
2425 min_lt = INT_CST_LT (minval, primop1);
2426 max_lt = INT_CST_LT (maxval, primop1);
2430 /* This used to be a switch, but Genix compiler can't handle that. */
2431 if (code == NE_EXPR)
2433 if (max_lt || min_gt)
2434 val = truthvalue_true_node;
2436 else if (code == EQ_EXPR)
2438 if (max_lt || min_gt)
2439 val = truthvalue_false_node;
2441 else if (code == LT_EXPR)
2444 val = truthvalue_true_node;
2446 val = truthvalue_false_node;
2448 else if (code == GT_EXPR)
2451 val = truthvalue_true_node;
2453 val = truthvalue_false_node;
2455 else if (code == LE_EXPR)
2458 val = truthvalue_true_node;
2460 val = truthvalue_false_node;
2462 else if (code == GE_EXPR)
2465 val = truthvalue_true_node;
2467 val = truthvalue_false_node;
2470 /* If primop0 was sign-extended and unsigned comparison specd,
2471 we did a signed comparison above using the signed type bounds.
2472 But the comparison we output must be unsigned.
2474 Also, for inequalities, VAL is no good; but if the signed
2475 comparison had *any* fixed result, it follows that the
2476 unsigned comparison just tests the sign in reverse
2477 (positive values are LE, negative ones GE).
2478 So we can generate an unsigned comparison
2479 against an extreme value of the signed type. */
2481 if (unsignedp && !unsignedp0)
2488 primop1 = TYPE_MIN_VALUE (type);
2494 primop1 = TYPE_MAX_VALUE (type);
2501 type = c_common_unsigned_type (type);
2504 if (TREE_CODE (primop0) != INTEGER_CST)
2506 if (val == truthvalue_false_node)
2507 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
2508 if (val == truthvalue_true_node)
2509 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
2514 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2515 if (TREE_SIDE_EFFECTS (primop0))
2516 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2520 /* Value is not predetermined, but do the comparison
2521 in the type of the operand that is not constant.
2522 TYPE is already properly set. */
2525 /* If either arg is decimal float and the other is float, find the
2526 proper common type to use for comparison. */
2527 else if (real1 && real2
2528 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2529 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2530 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2532 else if (real1 && real2
2533 && (TYPE_PRECISION (TREE_TYPE (primop0))
2534 == TYPE_PRECISION (TREE_TYPE (primop1))))
2535 type = TREE_TYPE (primop0);
2537 /* If args' natural types are both narrower than nominal type
2538 and both extend in the same manner, compare them
2539 in the type of the wider arg.
2540 Otherwise must actually extend both to the nominal
2541 common type lest different ways of extending
2543 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2545 else if (unsignedp0 == unsignedp1 && real1 == real2
2546 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2547 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2549 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2550 type = c_common_signed_or_unsigned_type (unsignedp0
2551 || TYPE_UNSIGNED (*restype_ptr),
2553 /* Make sure shorter operand is extended the right way
2554 to match the longer operand. */
2556 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2557 TREE_TYPE (primop0)),
2560 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2561 TREE_TYPE (primop1)),
2566 /* Here we must do the comparison on the nominal type
2567 using the args exactly as we received them. */
2568 type = *restype_ptr;
2572 if (!real1 && !real2 && integer_zerop (primop1)
2573 && TYPE_UNSIGNED (*restype_ptr))
2579 /* All unsigned values are >= 0, so we warn. However,
2580 if OP0 is a constant that is >= 0, the signedness of
2581 the comparison isn't an issue, so suppress the
2583 if (warn_type_limits && !in_system_header
2584 && !(TREE_CODE (primop0) == INTEGER_CST
2585 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2587 warning (OPT_Wtype_limits,
2588 "comparison of unsigned expression >= 0 is always true");
2589 value = truthvalue_true_node;
2593 if (warn_type_limits && !in_system_header
2594 && !(TREE_CODE (primop0) == INTEGER_CST
2595 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2597 warning (OPT_Wtype_limits,
2598 "comparison of unsigned expression < 0 is always false");
2599 value = truthvalue_false_node;
2608 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2609 if (TREE_SIDE_EFFECTS (primop0))
2610 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2617 *op0_ptr = convert (type, primop0);
2618 *op1_ptr = convert (type, primop1);
2620 *restype_ptr = truthvalue_type_node;
2625 /* Return a tree for the sum or difference (RESULTCODE says which)
2626 of pointer PTROP and integer INTOP. */
2629 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2633 /* The result is a pointer of the same type that is being added. */
2634 tree result_type = TREE_TYPE (ptrop);
2636 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2638 if (pedantic || warn_pointer_arith)
2639 pedwarn ("pointer of type %<void *%> used in arithmetic");
2640 size_exp = integer_one_node;
2642 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2644 if (pedantic || warn_pointer_arith)
2645 pedwarn ("pointer to a function used in arithmetic");
2646 size_exp = integer_one_node;
2648 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2650 if (pedantic || warn_pointer_arith)
2651 pedwarn ("pointer to member function used in arithmetic");
2652 size_exp = integer_one_node;
2655 size_exp = size_in_bytes (TREE_TYPE (result_type));
2657 /* We are manipulating pointer values, so we don't need to warn
2658 about relying on undefined signed overflow. We disable the
2659 warning here because we use integer types so fold won't know that
2660 they are really pointers. */
2661 fold_defer_overflow_warnings ();
2663 /* If what we are about to multiply by the size of the elements
2664 contains a constant term, apply distributive law
2665 and multiply that constant term separately.
2666 This helps produce common subexpressions. */
2667 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2668 && !TREE_CONSTANT (intop)
2669 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2670 && TREE_CONSTANT (size_exp)
2671 /* If the constant comes from pointer subtraction,
2672 skip this optimization--it would cause an error. */
2673 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2674 /* If the constant is unsigned, and smaller than the pointer size,
2675 then we must skip this optimization. This is because it could cause
2676 an overflow error if the constant is negative but INTOP is not. */
2677 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2678 || (TYPE_PRECISION (TREE_TYPE (intop))
2679 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2681 enum tree_code subcode = resultcode;
2682 tree int_type = TREE_TYPE (intop);
2683 if (TREE_CODE (intop) == MINUS_EXPR)
2684 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2685 /* Convert both subexpression types to the type of intop,
2686 because weird cases involving pointer arithmetic
2687 can result in a sum or difference with different type args. */
2688 ptrop = build_binary_op (subcode, ptrop,
2689 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2690 intop = convert (int_type, TREE_OPERAND (intop, 0));
2693 /* Convert the integer argument to a type the same size as sizetype
2694 so the multiply won't overflow spuriously. */
2695 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2696 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2697 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2698 TYPE_UNSIGNED (sizetype)), intop);
2700 /* Replace the integer argument with a suitable product by the object size.
2701 Do this multiplication as signed, then convert to the appropriate
2702 type for the pointer operation. */
2703 intop = convert (sizetype,
2704 build_binary_op (MULT_EXPR, intop,
2705 convert (TREE_TYPE (intop), size_exp), 1));
2707 /* Create the sum or difference. */
2708 if (resultcode == MINUS_EXPR)
2709 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
2711 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
2713 fold_undefer_and_ignore_overflow_warnings ();
2718 /* Return whether EXPR is a declaration whose address can never be
2722 decl_with_nonnull_addr_p (tree expr)
2724 return (DECL_P (expr)
2725 && (TREE_CODE (expr) == PARM_DECL
2726 || TREE_CODE (expr) == LABEL_DECL
2727 || !DECL_WEAK (expr)));
2730 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2731 or for an `if' or `while' statement or ?..: exp. It should already
2732 have been validated to be of suitable type; otherwise, a bad
2733 diagnostic may result.
2735 This preparation consists of taking the ordinary
2736 representation of an expression expr and producing a valid tree
2737 boolean expression describing whether expr is nonzero. We could
2738 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2739 but we optimize comparisons, &&, ||, and !.
2741 The resulting type should always be `truthvalue_type_node'. */
2744 c_common_truthvalue_conversion (tree expr)
2746 switch (TREE_CODE (expr))
2748 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2749 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2750 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2751 case ORDERED_EXPR: case UNORDERED_EXPR:
2752 if (TREE_TYPE (expr) == truthvalue_type_node)
2754 return build2 (TREE_CODE (expr), truthvalue_type_node,
2755 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2757 case TRUTH_ANDIF_EXPR:
2758 case TRUTH_ORIF_EXPR:
2759 case TRUTH_AND_EXPR:
2761 case TRUTH_XOR_EXPR:
2762 if (TREE_TYPE (expr) == truthvalue_type_node)
2764 return build2 (TREE_CODE (expr), truthvalue_type_node,
2765 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2766 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2768 case TRUTH_NOT_EXPR:
2769 if (TREE_TYPE (expr) == truthvalue_type_node)
2771 return build1 (TREE_CODE (expr), truthvalue_type_node,
2772 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2778 return integer_zerop (expr) ? truthvalue_false_node
2779 : truthvalue_true_node;
2782 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2783 ? truthvalue_true_node
2784 : truthvalue_false_node;
2787 expr = build_unary_op (ADDR_EXPR, expr, 0);
2792 tree inner = TREE_OPERAND (expr, 0);
2793 if (decl_with_nonnull_addr_p (inner))
2795 /* Common Ada/Pascal programmer's mistake. */
2796 warning (OPT_Waddress,
2797 "the address of %qD will always evaluate as %<true%>",
2799 return truthvalue_true_node;
2802 /* If we still have a decl, it is possible for its address to
2803 be NULL, so we cannot optimize. */
2806 gcc_assert (DECL_WEAK (inner));
2810 if (TREE_SIDE_EFFECTS (inner))
2811 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2812 inner, truthvalue_true_node);
2814 return truthvalue_true_node;
2818 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2819 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2820 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2821 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2827 /* These don't change whether an object is nonzero or zero. */
2828 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2832 /* These don't change whether an object is zero or nonzero, but
2833 we can't ignore them if their second arg has side-effects. */
2834 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2835 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2836 TREE_OPERAND (expr, 1),
2837 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2839 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2842 /* Distribute the conversion into the arms of a COND_EXPR. */
2843 return fold_build3 (COND_EXPR, truthvalue_type_node,
2844 TREE_OPERAND (expr, 0),
2845 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2846 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2850 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2851 since that affects how `default_conversion' will behave. */
2852 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2853 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2855 /* If this is widening the argument, we can ignore it. */
2856 if (TYPE_PRECISION (TREE_TYPE (expr))
2857 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2858 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2862 if (!TREE_NO_WARNING (expr)
2863 && warn_parentheses)
2865 warning (OPT_Wparentheses,
2866 "suggest parentheses around assignment used as truth value");
2867 TREE_NO_WARNING (expr) = 1;
2875 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2877 tree t = save_expr (expr);
2878 return (build_binary_op
2879 ((TREE_SIDE_EFFECTS (expr)
2880 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2881 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2882 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2886 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2889 static void def_builtin_1 (enum built_in_function fncode,
2891 enum built_in_class fnclass,
2892 tree fntype, tree libtype,
2893 bool both_p, bool fallback_p, bool nonansi_p,
2894 tree fnattrs, bool implicit_p);
2896 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2897 down to the element type of an array. */
2900 c_build_qualified_type (tree type, int type_quals)
2902 if (type == error_mark_node)
2905 if (TREE_CODE (type) == ARRAY_TYPE)
2908 tree element_type = c_build_qualified_type (TREE_TYPE (type),
2911 /* See if we already have an identically qualified type. */
2912 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2914 if (TYPE_QUALS (strip_array_types (t)) == type_quals
2915 && TYPE_NAME (t) == TYPE_NAME (type)
2916 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2917 && attribute_list_equal (TYPE_ATTRIBUTES (t),
2918 TYPE_ATTRIBUTES (type)))
2923 tree domain = TYPE_DOMAIN (type);
2925 t = build_variant_type_copy (type);
2926 TREE_TYPE (t) = element_type;
2928 if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
2929 || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
2930 SET_TYPE_STRUCTURAL_EQUALITY (t);
2931 else if (TYPE_CANONICAL (element_type) != element_type
2932 || (domain && TYPE_CANONICAL (domain) != domain))
2934 tree unqualified_canon
2935 = build_array_type (TYPE_CANONICAL (element_type),
2936 domain? TYPE_CANONICAL (domain)
2939 = c_build_qualified_type (unqualified_canon, type_quals);
2942 TYPE_CANONICAL (t) = t;
2947 /* A restrict-qualified pointer type must be a pointer to object or
2948 incomplete type. Note that the use of POINTER_TYPE_P also allows
2949 REFERENCE_TYPEs, which is appropriate for C++. */
2950 if ((type_quals & TYPE_QUAL_RESTRICT)
2951 && (!POINTER_TYPE_P (type)
2952 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2954 error ("invalid use of %<restrict%>");
2955 type_quals &= ~TYPE_QUAL_RESTRICT;
2958 return build_qualified_type (type, type_quals);
2961 /* Apply the TYPE_QUALS to the new DECL. */
2964 c_apply_type_quals_to_decl (int type_quals, tree decl)
2966 tree type = TREE_TYPE (decl);
2968 if (type == error_mark_node)
2971 if (((type_quals & TYPE_QUAL_CONST)
2972 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2973 /* An object declared 'const' is only readonly after it is
2974 initialized. We don't have any way of expressing this currently,
2975 so we need to be conservative and unset TREE_READONLY for types
2976 with constructors. Otherwise aliasing code will ignore stores in
2977 an inline constructor. */
2978 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2979 TREE_READONLY (decl) = 1;
2980 if (type_quals & TYPE_QUAL_VOLATILE)
2982 TREE_SIDE_EFFECTS (decl) = 1;
2983 TREE_THIS_VOLATILE (decl) = 1;
2985 if (type_quals & TYPE_QUAL_RESTRICT)
2987 while (type && TREE_CODE (type) == ARRAY_TYPE)
2988 /* Allow 'restrict' on arrays of pointers.
2989 FIXME currently we just ignore it. */
2990 type = TREE_TYPE (type);
2992 || !POINTER_TYPE_P (type)
2993 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2994 error ("invalid use of %<restrict%>");
2995 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2996 /* Indicate we need to make a unique alias set for this pointer.
2997 We can't do it here because it might be pointing to an
2999 DECL_POINTER_ALIAS_SET (decl) = -2;
3003 /* Hash function for the problem of multiple type definitions in
3004 different files. This must hash all types that will compare
3005 equal via comptypes to the same value. In practice it hashes
3006 on some of the simple stuff and leaves the details to comptypes. */
3009 c_type_hash (const void *p)
3013 const_tree const t = (const_tree) p;
3015 switch (TREE_CODE (t))
3017 /* For pointers, hash on pointee type plus some swizzling. */
3019 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3020 /* Hash on number of elements and total size. */
3023 t2 = TYPE_VALUES (t);
3027 t2 = TYPE_FIELDS (t);
3029 case QUAL_UNION_TYPE:
3031 t2 = TYPE_FIELDS (t);
3035 t2 = TYPE_FIELDS (t);
3040 for (; t2; t2 = TREE_CHAIN (t2))
3042 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3043 return ((size << 24) | (i << shift));
3046 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3048 /* Return the typed-based alias set for T, which may be an expression
3049 or a type. Return -1 if we don't do anything special. */
3052 c_common_get_alias_set (tree t)
3057 /* Permit type-punning when accessing a union, provided the access
3058 is directly through the union. For example, this code does not
3059 permit taking the address of a union member and then storing
3060 through it. Even the type-punning allowed here is a GCC
3061 extension, albeit a common and useful one; the C standard says
3062 that such accesses have implementation-defined behavior. */
3064 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3065 u = TREE_OPERAND (u, 0))
3066 if (TREE_CODE (u) == COMPONENT_REF
3067 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3070 /* That's all the expressions we handle specially. */
3074 /* The C standard guarantees that any object may be accessed via an
3075 lvalue that has character type. */
3076 if (t == char_type_node
3077 || t == signed_char_type_node
3078 || t == unsigned_char_type_node)
3081 /* If it has the may_alias attribute, it can alias anything. */
3082 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
3085 /* The C standard specifically allows aliasing between signed and
3086 unsigned variants of the same type. We treat the signed
3087 variant as canonical. */
3088 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3090 tree t1 = c_common_signed_type (t);
3092 /* t1 == t can happen for boolean nodes which are always unsigned. */
3094 return get_alias_set (t1);
3096 else if (POINTER_TYPE_P (t))
3100 /* Unfortunately, there is no canonical form of a pointer type.
3101 In particular, if we have `typedef int I', then `int *', and
3102 `I *' are different types. So, we have to pick a canonical
3103 representative. We do this below.
3105 Technically, this approach is actually more conservative that
3106 it needs to be. In particular, `const int *' and `int *'
3107 should be in different alias sets, according to the C and C++
3108 standard, since their types are not the same, and so,
3109 technically, an `int **' and `const int **' cannot point at
3112 But, the standard is wrong. In particular, this code is
3117 const int* const* cipp = ipp;
3119 And, it doesn't make sense for that to be legal unless you
3120 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3121 the pointed-to types. This issue has been reported to the
3123 t1 = build_type_no_quals (t);
3125 return get_alias_set (t1);
3128 /* Handle the case of multiple type nodes referring to "the same" type,
3129 which occurs with IMA. These share an alias set. FIXME: Currently only
3130 C90 is handled. (In C99 type compatibility is not transitive, which
3131 complicates things mightily. The alias set splay trees can theoretically
3132 represent this, but insertion is tricky when you consider all the
3133 different orders things might arrive in.) */
3135 if (c_language != clk_c || flag_isoc99)
3138 /* Save time if there's only one input file. */
3139 if (num_in_fnames == 1)
3142 /* Pointers need special handling if they point to any type that
3143 needs special handling (below). */
3144 if (TREE_CODE (t) == POINTER_TYPE)
3147 /* Find bottom type under any nested POINTERs. */
3148 for (t2 = TREE_TYPE (t);
3149 TREE_CODE (t2) == POINTER_TYPE;
3150 t2 = TREE_TYPE (t2))
3152 if (TREE_CODE (t2) != RECORD_TYPE
3153 && TREE_CODE (t2) != ENUMERAL_TYPE
3154 && TREE_CODE (t2) != QUAL_UNION_TYPE
3155 && TREE_CODE (t2) != UNION_TYPE)
3157 if (TYPE_SIZE (t2) == 0)
3160 /* These are the only cases that need special handling. */
3161 if (TREE_CODE (t) != RECORD_TYPE
3162 && TREE_CODE (t) != ENUMERAL_TYPE
3163 && TREE_CODE (t) != QUAL_UNION_TYPE
3164 && TREE_CODE (t) != UNION_TYPE
3165 && TREE_CODE (t) != POINTER_TYPE)
3168 if (TYPE_SIZE (t) == 0)
3171 /* Look up t in hash table. Only one of the compatible types within each
3172 alias set is recorded in the table. */
3173 if (!type_hash_table)
3174 type_hash_table = htab_create_ggc (1021, c_type_hash,
3175 (htab_eq) lang_hooks.types_compatible_p,
3177 slot = htab_find_slot (type_hash_table, t, INSERT);
3180 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3181 return TYPE_ALIAS_SET ((tree)*slot);
3184 /* Our caller will assign and record (in t) a new alias set; all we need
3185 to do is remember t in the hash table. */
3191 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3192 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3193 flag controls whether we should diagnose possibly ill-formed
3194 constructs or not. */
3197 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3199 const char *op_name;
3201 enum tree_code type_code = TREE_CODE (type);
3203 op_name = is_sizeof ? "sizeof" : "__alignof__";
3205 if (type_code == FUNCTION_TYPE)
3209 if (complain && (pedantic || warn_pointer_arith))
3210 pedwarn ("invalid application of %<sizeof%> to a function type");
3211 value = size_one_node;
3214 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3216 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3218 if (type_code == VOID_TYPE
3219 && complain && (pedantic || warn_pointer_arith))
3220 pedwarn ("invalid application of %qs to a void type", op_name);
3221 value = size_one_node;
3223 else if (!COMPLETE_TYPE_P (type))
3226 error ("invalid application of %qs to incomplete type %qT ",
3228 value = size_zero_node;
3233 /* Convert in case a char is more than one unit. */
3234 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3235 size_int (TYPE_PRECISION (char_type_node)
3238 value = size_int (TYPE_ALIGN_UNIT (type));
3241 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3242 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3243 never happen. However, this node should really have type
3244 `size_t', which is just a typedef for an ordinary integer type. */
3245 value = fold_convert (size_type_node, value);
3246 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3251 /* Implement the __alignof keyword: Return the minimum required
3252 alignment of EXPR, measured in bytes. For VAR_DECLs,
3253 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3254 from an "aligned" __attribute__ specification). */
3257 c_alignof_expr (tree expr)
3261 if (VAR_OR_FUNCTION_DECL_P (expr))
3262 t = size_int (DECL_ALIGN_UNIT (expr));
3264 else if (TREE_CODE (expr) == COMPONENT_REF
3265 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3267 error ("%<__alignof%> applied to a bit-field");
3270 else if (TREE_CODE (expr) == COMPONENT_REF
3271 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3272 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3274 else if (TREE_CODE (expr) == INDIRECT_REF)
3276 tree t = TREE_OPERAND (expr, 0);
3278 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3280 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3281 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3285 t = TREE_OPERAND (t, 0);
3286 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3287 if (thisalign > bestalign)
3288 best = t, bestalign = thisalign;
3290 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3293 return c_alignof (TREE_TYPE (expr));
3295 return fold_convert (size_type_node, t);
3298 /* Handle C and C++ default attributes. */
3300 enum built_in_attribute
3302 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3303 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3304 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3305 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3306 #include "builtin-attrs.def"
3307 #undef DEF_ATTR_NULL_TREE
3309 #undef DEF_ATTR_IDENT
3310 #undef DEF_ATTR_TREE_LIST
3314 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3316 static void c_init_attributes (void);
3320 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3321 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3322 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3323 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3324 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3325 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3326 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3327 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3328 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3329 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3330 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3331 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3332 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3333 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3334 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3336 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3337 #include "builtin-types.def"
3338 #undef DEF_PRIMITIVE_TYPE
3339 #undef DEF_FUNCTION_TYPE_0
3340 #undef DEF_FUNCTION_TYPE_1
3341 #undef DEF_FUNCTION_TYPE_2
3342 #undef DEF_FUNCTION_TYPE_3
3343 #undef DEF_FUNCTION_TYPE_4
3344 #undef DEF_FUNCTION_TYPE_5
3345 #undef DEF_FUNCTION_TYPE_6
3346 #undef DEF_FUNCTION_TYPE_7
3347 #undef DEF_FUNCTION_TYPE_VAR_0
3348 #undef DEF_FUNCTION_TYPE_VAR_1
3349 #undef DEF_FUNCTION_TYPE_VAR_2
3350 #undef DEF_FUNCTION_TYPE_VAR_3
3351 #undef DEF_FUNCTION_TYPE_VAR_4
3352 #undef DEF_FUNCTION_TYPE_VAR_5
3353 #undef DEF_POINTER_TYPE
3357 typedef enum c_builtin_type builtin_type;
3359 /* A temporary array for c_common_nodes_and_builtins. Used in
3360 communication with def_fn_type. */
3361 static tree builtin_types[(int) BT_LAST + 1];
3363 /* A helper function for c_common_nodes_and_builtins. Build function type
3364 for DEF with return type RET and N arguments. If VAR is true, then the
3365 function should be variadic after those N arguments.
3367 Takes special care not to ICE if any of the types involved are
3368 error_mark_node, which indicates that said type is not in fact available
3369 (see builtin_type_for_size). In which case the function type as a whole
3370 should be error_mark_node. */
3373 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3375 tree args = NULL, t;
3380 for (i = 0; i < n; ++i)
3382 builtin_type a = va_arg (list, builtin_type);
3383 t = builtin_types[a];
3384 if (t == error_mark_node)
3386 args = tree_cons (NULL_TREE, t, args);
3390 args = nreverse (args);
3392 args = chainon (args, void_list_node);
3394 t = builtin_types[ret];
3395 if (t == error_mark_node)
3397 t = build_function_type (t, args);
3400 builtin_types[def] = t;
3403 /* Build builtin functions common to both C and C++ language
3407 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3409 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3410 builtin_types[ENUM] = VALUE;
3411 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3412 def_fn_type (ENUM, RETURN, 0, 0);
3413 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3414 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3415 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3416 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3417 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3418 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3419 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3420 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3421 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3422 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3423 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3425 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3426 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3428 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3429 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3430 def_fn_type (ENUM, RETURN, 1, 0);
3431 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3432 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3433 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3434 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3435 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3436 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3437 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3438 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3439 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3440 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3441 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3442 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3444 #include "builtin-types.def"
3446 #undef DEF_PRIMITIVE_TYPE
3447 #undef DEF_FUNCTION_TYPE_1
3448 #undef DEF_FUNCTION_TYPE_2
3449 #undef DEF_FUNCTION_TYPE_3
3450 #undef DEF_FUNCTION_TYPE_4
3451 #undef DEF_FUNCTION_TYPE_5
3452 #undef DEF_FUNCTION_TYPE_6
3453 #undef DEF_FUNCTION_TYPE_VAR_0
3454 #undef DEF_FUNCTION_TYPE_VAR_1
3455 #undef DEF_FUNCTION_TYPE_VAR_2
3456 #undef DEF_FUNCTION_TYPE_VAR_3
3457 #undef DEF_FUNCTION_TYPE_VAR_4
3458 #undef DEF_FUNCTION_TYPE_VAR_5
3459 #undef DEF_POINTER_TYPE
3460 builtin_types[(int) BT_LAST] = NULL_TREE;
3462 c_init_attributes ();
3464 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3465 NONANSI_P, ATTRS, IMPLICIT, COND) \
3467 def_builtin_1 (ENUM, NAME, CLASS, \
3468 builtin_types[(int) TYPE], \
3469 builtin_types[(int) LIBTYPE], \
3470 BOTH_P, FALLBACK_P, NONANSI_P, \
3471 built_in_attributes[(int) ATTRS], IMPLICIT);
3472 #include "builtins.def"
3475 targetm.init_builtins ();
3477 build_common_builtin_nodes ();
3483 /* Build tree nodes and builtin functions common to both C and C++ language
3487 c_common_nodes_and_builtins (void)
3489 int wchar_type_size;
3490 tree array_domain_type;
3491 tree va_list_ref_type_node;
3492 tree va_list_arg_type_node;
3494 /* Define `int' and `char' first so that dbx will output them first. */
3495 record_builtin_type (RID_INT, NULL, integer_type_node);
3496 record_builtin_type (RID_CHAR, "char", char_type_node);
3498 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3499 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3500 but not C. Are the conditionals here needed? */
3501 if (c_dialect_cxx ())
3502 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3503 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3504 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3505 record_builtin_type (RID_MAX, "long unsigned int",
3506 long_unsigned_type_node);
3507 if (c_dialect_cxx ())
3508 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3509 record_builtin_type (RID_MAX, "long long int",
3510 long_long_integer_type_node);
3511 record_builtin_type (RID_MAX, "long long unsigned int",
3512 long_long_unsigned_type_node);
3513 if (c_dialect_cxx ())
3514 record_builtin_type (RID_MAX, "long long unsigned",
3515 long_long_unsigned_type_node);
3516 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3517 record_builtin_type (RID_MAX, "short unsigned int",
3518 short_unsigned_type_node);
3519 if (c_dialect_cxx ())
3520 record_builtin_type (RID_MAX, "unsigned short",
3521 short_unsigned_type_node);
3523 /* Define both `signed char' and `unsigned char'. */
3524 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3525 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3527 /* These are types that c_common_type_for_size and
3528 c_common_type_for_mode use. */
3529 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3531 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3533 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3535 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3537 #if HOST_BITS_PER_WIDE_INT >= 64
3538 if (targetm.scalar_mode_supported_p (TImode))
3539 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3540 get_identifier ("__int128_t"),
3543 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3544 unsigned_intQI_type_node));
3545 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3546 unsigned_intHI_type_node));
3547 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3548 unsigned_intSI_type_node));
3549 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3550 unsigned_intDI_type_node));
3551 #if HOST_BITS_PER_WIDE_INT >= 64
3552 if (targetm.scalar_mode_supported_p (TImode))
3553 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3554 get_identifier ("__uint128_t"),
3555 unsigned_intTI_type_node));
3558 /* Create the widest literal types. */
3559 widest_integer_literal_type_node
3560 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3561 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3562 widest_integer_literal_type_node));
3564 widest_unsigned_literal_type_node
3565 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3566 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3567 widest_unsigned_literal_type_node));
3569 /* `unsigned long' is the standard type for sizeof.
3570 Note that stddef.h uses `unsigned long',
3571 and this must agree, even if long and int are the same size. */
3573 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3574 signed_size_type_node = c_common_signed_type (size_type_node);
3575 set_sizetype (size_type_node);
3578 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3580 build_common_tree_nodes_2 (flag_short_double);
3582 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3583 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3584 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3586 /* Only supported decimal floating point extension if the target
3587 actually supports underlying modes. */
3588 if (targetm.scalar_mode_supported_p (SDmode)
3589 && targetm.scalar_mode_supported_p (DDmode)
3590 && targetm.scalar_mode_supported_p (TDmode))
3592 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3593 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3594 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3597 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3598 get_identifier ("complex int"),
3599 complex_integer_type_node));
3600 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3601 get_identifier ("complex float"),
3602 complex_float_type_node));
3603 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3604 get_identifier ("complex double"),
3605 complex_double_type_node));
3606 lang_hooks.decls.pushdecl
3607 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3608 complex_long_double_type_node));
3610 if (c_dialect_cxx ())
3611 /* For C++, make fileptr_type_node a distinct void * type until
3612 FILE type is defined. */
3613 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3615 record_builtin_type (RID_VOID, NULL, void_type_node);
3617 /* Set the TYPE_NAME for any variants that were built before
3618 record_builtin_type gave names to the built-in types. */
3620 tree void_name = TYPE_NAME (void_type_node);
3621 TYPE_NAME (void_type_node) = NULL_TREE;
3622 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
3624 TYPE_NAME (void_type_node) = void_name;
3627 /* This node must not be shared. */
3628 void_zero_node = make_node (INTEGER_CST);
3629 TREE_TYPE (void_zero_node) = void_type_node;
3631 void_list_node = build_void_list_node ();
3633 /* Make a type to be the domain of a few array types
3634 whose domains don't really matter.
3635 200 is small enough that it always fits in size_t
3636 and large enough that it can hold most function names for the
3637 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3638 array_domain_type = build_index_type (size_int (200));
3640 /* Make a type for arrays of characters.
3641 With luck nothing will ever really depend on the length of this
3643 char_array_type_node
3644 = build_array_type (char_type_node, array_domain_type);
3646 /* Likewise for arrays of ints. */
3648 = build_array_type (integer_type_node, array_domain_type);
3650 string_type_node = build_pointer_type (char_type_node);
3651 const_string_type_node
3652 = build_pointer_type (build_qualified_type
3653 (char_type_node, TYPE_QUAL_CONST));
3655 /* This is special for C++ so functions can be overloaded. */
3656 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3657 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3658 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3659 if (c_dialect_cxx ())
3661 if (TYPE_UNSIGNED (wchar_type_node))
3662 wchar_type_node = make_unsigned_type (wchar_type_size);
3664 wchar_type_node = make_signed_type (wchar_type_size);
3665 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3669 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3670 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3673 /* This is for wide string constants. */
3674 wchar_array_type_node
3675 = build_array_type (wchar_type_node, array_domain_type);
3678 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3681 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3683 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3685 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3687 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3688 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3690 lang_hooks.decls.pushdecl
3691 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3692 va_list_type_node));
3694 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3696 va_list_arg_type_node = va_list_ref_type_node =
3697 build_pointer_type (TREE_TYPE (va_list_type_node));
3701 va_list_arg_type_node = va_list_type_node;
3702 va_list_ref_type_node = build_reference_type (va_list_type_node);
3705 if (!flag_preprocess_only)
3706 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
3708 main_identifier_node = get_identifier ("main");
3710 /* Create the built-in __null node. It is important that this is
3712 null_node = make_node (INTEGER_CST);
3713 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3715 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3716 memset (builtin_types, 0, sizeof (builtin_types));
3719 /* Look up the function in built_in_decls that corresponds to DECL
3720 and set ASMSPEC as its user assembler name. DECL must be a
3721 function decl that declares a builtin. */
3724 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3727 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3728 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3731 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3732 set_user_assembler_name (builtin, asmspec);
3733 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3734 init_block_move_fn (asmspec);
3735 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3736 init_block_clear_fn (asmspec);
3739 /* The number of named compound-literals generated thus far. */
3740 static GTY(()) int compound_literal_number;
3742 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3745 set_compound_literal_name (tree decl)
3748 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3749 compound_literal_number);
3750 compound_literal_number++;
3751 DECL_NAME (decl) = get_identifier (name);
3755 build_va_arg (tree expr, tree type)
3757 return build1 (VA_ARG_EXPR, type, expr);
3761 /* Linked list of disabled built-in functions. */
3763 typedef struct disabled_builtin
3766 struct disabled_builtin *next;
3768 static disabled_builtin *disabled_builtins = NULL;
3770 static bool builtin_function_disabled_p (const char *);
3772 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3773 begins with "__builtin_", give an error. */
3776 disable_builtin_function (const char *name)
3778 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3779 error ("cannot disable built-in function %qs", name);
3782 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3783 new_disabled_builtin->name = name;
3784 new_disabled_builtin->next = disabled_builtins;
3785 disabled_builtins = new_disabled_builtin;
3790 /* Return true if the built-in function NAME has been disabled, false
3794 builtin_function_disabled_p (const char *name)
3796 disabled_builtin *p;
3797 for (p = disabled_builtins; p != NULL; p = p->next)
3799 if (strcmp (name, p->name) == 0)
3806 /* Worker for DEF_BUILTIN.
3807 Possibly define a builtin function with one or two names.
3808 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3809 nonansi_p and flag_no_nonansi_builtin. */
3812 def_builtin_1 (enum built_in_function fncode,
3814 enum built_in_class fnclass,
3815 tree fntype, tree libtype,
3816 bool both_p, bool fallback_p, bool nonansi_p,
3817 tree fnattrs, bool implicit_p)
3820 const char *libname;
3822 if (fntype == error_mark_node)
3825 gcc_assert ((!both_p && !fallback_p)
3826 || !strncmp (name, "__builtin_",
3827 strlen ("__builtin_")));
3829 libname = name + strlen ("__builtin_");
3830 decl = add_builtin_function (name, fntype, fncode, fnclass,
3831 (fallback_p ? libname : NULL),
3834 && !flag_no_builtin && !builtin_function_disabled_p (libname)
3835 && !(nonansi_p && flag_no_nonansi_builtin))
3836 add_builtin_function (libname, libtype, fncode, fnclass,
3839 built_in_decls[(int) fncode] = decl;
3841 implicit_built_in_decls[(int) fncode] = decl;
3844 /* Nonzero if the type T promotes to int. This is (nearly) the
3845 integral promotions defined in ISO C99 6.3.1.1/2. */
3848 c_promoting_integer_type_p (tree t)
3850 switch (TREE_CODE (t))
3853 return (TYPE_MAIN_VARIANT (t) == char_type_node
3854 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3855 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3856 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3857 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3858 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3861 /* ??? Technically all enumerations not larger than an int
3862 promote to an int. But this is used along code paths
3863 that only want to notice a size change. */
3864 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3874 /* Return 1 if PARMS specifies a fixed number of parameters
3875 and none of their types is affected by default promotions. */
3878 self_promoting_args_p (tree parms)
3881 for (t = parms; t; t = TREE_CHAIN (t))
3883 tree type = TREE_VALUE (t);
3885 if (type == error_mark_node)
3888 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3894 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3897 if (c_promoting_integer_type_p (type))
3903 /* Recursively examines the array elements of TYPE, until a non-array
3904 element type is found. */
3907 strip_array_types (tree type)
3909 while (TREE_CODE (type) == ARRAY_TYPE)
3910 type = TREE_TYPE (type);
3916 const_strip_array_types (const_tree type)
3918 while (TREE_CODE (type) == ARRAY_TYPE)
3919 type = TREE_TYPE (type);
3924 /* Recursively remove any '*' or '&' operator from TYPE. */
3926 strip_pointer_operator (tree t)
3928 while (POINTER_TYPE_P (t))
3933 /* Recursively remove pointer or array type from TYPE. */
3935 strip_pointer_or_array_types (tree t)
3937 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
3942 /* Used to compare case labels. K1 and K2 are actually tree nodes
3943 representing case labels, or NULL_TREE for a `default' label.
3944 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3945 K2, and 0 if K1 and K2 are equal. */
3948 case_compare (splay_tree_key k1, splay_tree_key k2)
3950 /* Consider a NULL key (such as arises with a `default' label) to be
3951 smaller than anything else. */
3957 return tree_int_cst_compare ((tree) k1, (tree) k2);
3960 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3961 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3962 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3963 case label was declared using the usual C/C++ syntax, rather than
3964 the GNU case range extension. CASES is a tree containing all the
3965 case ranges processed so far; COND is the condition for the
3966 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3967 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3970 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3971 tree low_value, tree high_value)
3976 splay_tree_node node;
3978 /* Create the LABEL_DECL itself. */
3979 label = create_artificial_label ();
3981 /* If there was an error processing the switch condition, bail now
3982 before we get more confused. */
3983 if (!cond || cond == error_mark_node)
3986 if ((low_value && TREE_TYPE (low_value)
3987 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3988 || (high_value && TREE_TYPE (high_value)
3989 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3991 error ("pointers are not permitted as case values");
3995 /* Case ranges are a GNU extension. */
3996 if (high_value && pedantic)
3997 pedwarn ("range expressions in switch statements are non-standard");
3999 type = TREE_TYPE (cond);
4002 low_value = check_case_value (low_value);
4003 low_value = convert_and_check (type, low_value);
4004 if (low_value == error_mark_node)
4009 high_value = check_case_value (high_value);
4010 high_value = convert_and_check (type, high_value);
4011 if (high_value == error_mark_node)
4015 if (low_value && high_value)
4017 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4018 really a case range, even though it was written that way.
4019 Remove the HIGH_VALUE to simplify later processing. */
4020 if (tree_int_cst_equal (low_value, high_value))
4021 high_value = NULL_TREE;
4022 else if (!tree_int_cst_lt (low_value, high_value))
4023 warning (0, "empty range specified");
4026 /* See if the case is in range of the type of the original testing
4027 expression. If both low_value and high_value are out of range,
4028 don't insert the case label and return NULL_TREE. */
4030 && !check_case_bounds (type, orig_type,
4031 &low_value, high_value ? &high_value : NULL))
4034 /* Look up the LOW_VALUE in the table of case labels we already
4036 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4037 /* If there was not an exact match, check for overlapping ranges.
4038 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4039 that's a `default' label and the only overlap is an exact match. */
4040 if (!node && (low_value || high_value))
4042 splay_tree_node low_bound;
4043 splay_tree_node high_bound;
4045 /* Even though there wasn't an exact match, there might be an
4046 overlap between this case range and another case range.
4047 Since we've (inductively) not allowed any overlapping case
4048 ranges, we simply need to find the greatest low case label
4049 that is smaller that LOW_VALUE, and the smallest low case
4050 label that is greater than LOW_VALUE. If there is an overlap
4051 it will occur in one of these two ranges. */
4052 low_bound = splay_tree_predecessor (cases,
4053 (splay_tree_key) low_value);
4054 high_bound = splay_tree_successor (cases,
4055 (splay_tree_key) low_value);
4057 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4058 the LOW_VALUE, so there is no need to check unless the
4059 LOW_BOUND is in fact itself a case range. */
4061 && CASE_HIGH ((tree) low_bound->value)
4062 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4065 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4066 range is bigger than the low end of the current range, so we
4067 are only interested if the current range is a real range, and
4068 not an ordinary case label. */
4071 && (tree_int_cst_compare ((tree) high_bound->key,
4076 /* If there was an overlap, issue an error. */
4079 tree duplicate = CASE_LABEL ((tree) node->value);
4083 error ("duplicate (or overlapping) case value");
4084 error ("%Jthis is the first entry overlapping that value", duplicate);
4088 error ("duplicate case value") ;
4089 error ("%Jpreviously used here", duplicate);
4093 error ("multiple default labels in one switch");
4094 error ("%Jthis is the first default label", duplicate);
4099 /* Add a CASE_LABEL to the statement-tree. */
4100 case_label = add_stmt (build_case_label (low_value, high_value, label));
4101 /* Register this case label in the splay tree. */
4102 splay_tree_insert (cases,
4103 (splay_tree_key) low_value,
4104 (splay_tree_value) case_label);
4109 /* Add a label so that the back-end doesn't think that the beginning of
4110 the switch is unreachable. Note that we do not add a case label, as
4111 that just leads to duplicates and thence to failure later on. */
4114 tree t = create_artificial_label ();
4115 add_stmt (build_stmt (LABEL_EXPR, t));
4117 return error_mark_node;
4120 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4121 Used to verify that case values match up with enumerator values. */
4124 match_case_to_enum_1 (tree key, tree type, tree label)
4126 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4128 /* ??? Not working too hard to print the double-word value.
4129 Should perhaps be done with %lwd in the diagnostic routines? */
4130 if (TREE_INT_CST_HIGH (key) == 0)
4131 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4132 TREE_INT_CST_LOW (key));
4133 else if (!TYPE_UNSIGNED (type)
4134 && TREE_INT_CST_HIGH (key) == -1
4135 && TREE_INT_CST_LOW (key) != 0)
4136 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4137 -TREE_INT_CST_LOW (key));
4139 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4140 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
4142 if (TYPE_NAME (type) == 0)
4143 warning (0, "%Jcase value %qs not in enumerated type",
4144 CASE_LABEL (label), buf);
4146 warning (0, "%Jcase value %qs not in enumerated type %qT",
4147 CASE_LABEL (label), buf, type);
4150 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4151 Used to verify that case values match up with enumerator values. */
4154 match_case_to_enum (splay_tree_node node, void *data)
4156 tree label = (tree) node->value;
4157 tree type = (tree) data;
4159 /* Skip default case. */
4160 if (!CASE_LOW (label))
4163 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4164 when we did our enum->case scan. Reset our scratch bit after. */
4165 if (!CASE_LOW_SEEN (label))
4166 match_case_to_enum_1 (CASE_LOW (label), type, label);
4168 CASE_LOW_SEEN (label) = 0;
4170 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4171 not set, that means that CASE_HIGH did not appear when we did our
4172 enum->case scan. Reset our scratch bit after. */
4173 if (CASE_HIGH (label))
4175 if (!CASE_HIGH_SEEN (label))
4176 match_case_to_enum_1 (CASE_HIGH (label), type, label);
4178 CASE_HIGH_SEEN (label) = 0;
4184 /* Handle -Wswitch*. Called from the front end after parsing the
4185 switch construct. */
4186 /* ??? Should probably be somewhere generic, since other languages
4187 besides C and C++ would want this. At the moment, however, C/C++
4188 are the only tree-ssa languages that support enumerations at all,
4189 so the point is moot. */
4192 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4193 tree type, tree cond)
4195 splay_tree_node default_node;
4196 splay_tree_node node;
4199 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4202 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4204 warning (OPT_Wswitch_default, "%Hswitch missing default case",
4207 /* From here on, we only care about about enumerated types. */
4208 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4211 /* If the switch expression was an enumerated type, check that
4212 exactly all enumeration literals are covered by the cases.
4213 The check is made when -Wswitch was specified and there is no
4214 default case, or when -Wswitch-enum was specified. */
4216 if (!warn_switch_enum
4217 && !(warn_switch && !default_node))
4220 /* Clearing COND if it is not an integer constant simplifies
4221 the tests inside the loop below. */
4222 if (TREE_CODE (cond) != INTEGER_CST)
4225 /* The time complexity here is O(N*lg(N)) worst case, but for the
4226 common case of monotonically increasing enumerators, it is
4227 O(N), since the nature of the splay tree will keep the next
4228 element adjacent to the root at all times. */
4230 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4232 tree value = TREE_VALUE (chain);
4233 node = splay_tree_lookup (cases, (splay_tree_key) value);
4236 /* Mark the CASE_LOW part of the case entry as seen. */
4237 tree label = (tree) node->value;
4238 CASE_LOW_SEEN (label) = 1;
4242 /* Even though there wasn't an exact match, there might be a
4243 case range which includes the enumator's value. */
4244 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4245 if (node && CASE_HIGH ((tree) node->value))
4247 tree label = (tree) node->value;
4248 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4251 /* If we match the upper bound exactly, mark the CASE_HIGH
4252 part of the case entry as seen. */
4254 CASE_HIGH_SEEN (label) = 1;
4259 /* We've now determined that this enumerated literal isn't
4260 handled by the case labels of the switch statement. */
4262 /* If the switch expression is a constant, we only really care
4263 about whether that constant is handled by the switch. */
4264 if (cond && tree_int_cst_compare (cond, value))
4267 warning (0, "%Henumeration value %qE not handled in switch",
4268 &switch_location, TREE_PURPOSE (chain));
4271 /* Warn if there are case expressions that don't correspond to
4272 enumerators. This can occur since C and C++ don't enforce
4273 type-checking of assignments to enumeration variables.
4275 The time complexity here is now always O(N) worst case, since
4276 we should have marked both the lower bound and upper bound of
4277 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4278 above. This scan also resets those fields. */
4279 splay_tree_foreach (cases, match_case_to_enum, type);
4282 /* Finish an expression taking the address of LABEL (an
4283 IDENTIFIER_NODE). Returns an expression for the address. */
4286 finish_label_address_expr (tree label)
4291 pedwarn ("taking the address of a label is non-standard");
4293 if (label == error_mark_node)
4294 return error_mark_node;
4296 label = lookup_label (label);
4297 if (label == NULL_TREE)
4298 result = null_pointer_node;
4301 TREE_USED (label) = 1;
4302 result = build1 (ADDR_EXPR, ptr_type_node, label);
4303 /* The current function in not necessarily uninlinable.
4304 Computed gotos are incompatible with inlining, but the value
4305 here could be used only in a diagnostic, for example. */
4311 /* Hook used by expand_expr to expand language-specific tree codes. */
4312 /* The only things that should go here are bits needed to expand
4313 constant initializers. Everything else should be handled by the
4314 gimplification routines. */
4317 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4318 int modifier /* Actually enum_modifier. */,
4321 switch (TREE_CODE (exp))
4323 case COMPOUND_LITERAL_EXPR:
4325 /* Initialize the anonymous variable declared in the compound
4326 literal, then return the variable. */
4327 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4328 emit_local_var (decl);
4329 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4338 /* Generate the RTL for the body of FNDECL. */
4341 c_expand_body (tree fndecl)
4343 tree_rest_of_compilation (fndecl);
4346 /* Hook used by staticp to handle language-specific tree codes. */
4349 c_staticp (tree exp)
4351 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4352 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4357 /* Given a boolean expression ARG, return a tree representing an increment
4358 or decrement (as indicated by CODE) of ARG. The front end must check for
4359 invalid cases (e.g., decrement in C++). */
4361 boolean_increment (enum tree_code code, tree arg)
4364 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
4366 arg = stabilize_reference (arg);
4369 case PREINCREMENT_EXPR:
4370 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4372 case POSTINCREMENT_EXPR:
4373 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4374 arg = save_expr (arg);
4375 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4376 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4378 case PREDECREMENT_EXPR:
4379 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4380 invert_truthvalue (arg));
4382 case POSTDECREMENT_EXPR:
4383 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4384 invert_truthvalue (arg));
4385 arg = save_expr (arg);
4386 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4387 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4392 TREE_SIDE_EFFECTS (val) = 1;
4396 /* Built-in macros for stddef.h, that require macros defined in this
4399 c_stddef_cpp_builtins(void)
4401 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4402 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4403 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4404 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4405 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4406 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4410 c_init_attributes (void)
4412 /* Fill in the built_in_attributes array. */
4413 #define DEF_ATTR_NULL_TREE(ENUM) \
4414 built_in_attributes[(int) ENUM] = NULL_TREE;
4415 #define DEF_ATTR_INT(ENUM, VALUE) \
4416 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4417 #define DEF_ATTR_IDENT(ENUM, STRING) \
4418 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4419 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4420 built_in_attributes[(int) ENUM] \
4421 = tree_cons (built_in_attributes[(int) PURPOSE], \
4422 built_in_attributes[(int) VALUE], \
4423 built_in_attributes[(int) CHAIN]);
4424 #include "builtin-attrs.def"
4425 #undef DEF_ATTR_NULL_TREE
4427 #undef DEF_ATTR_IDENT
4428 #undef DEF_ATTR_TREE_LIST
4431 /* Attribute handlers common to C front ends. */
4433 /* Handle a "packed" attribute; arguments as in
4434 struct attribute_spec.handler. */
4437 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4438 int flags, bool *no_add_attrs)
4442 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4443 *node = build_variant_type_copy (*node);
4444 TYPE_PACKED (*node) = 1;
4446 else if (TREE_CODE (*node) == FIELD_DECL)
4448 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4449 warning (OPT_Wattributes,
4450 "%qE attribute ignored for field of type %qT",
4451 name, TREE_TYPE (*node));
4453 DECL_PACKED (*node) = 1;
4455 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4456 used for DECL_REGISTER. It wouldn't mean anything anyway.
4457 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4458 that changes what the typedef is typing. */
4461 warning (OPT_Wattributes, "%qE attribute ignored", name);
4462 *no_add_attrs = true;
4468 /* Handle a "nocommon" attribute; arguments as in
4469 struct attribute_spec.handler. */
4472 handle_nocommon_attribute (tree *node, tree name,
4473 tree ARG_UNUSED (args),
4474 int ARG_UNUSED (flags), bool *no_add_attrs)
4476 if (TREE_CODE (*node) == VAR_DECL)
4477 DECL_COMMON (*node) = 0;
4480 warning (OPT_Wattributes, "%qE attribute ignored", name);
4481 *no_add_attrs = true;
4487 /* Handle a "common" attribute; arguments as in
4488 struct attribute_spec.handler. */
4491 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4492 int ARG_UNUSED (flags), bool *no_add_attrs)
4494 if (TREE_CODE (*node) == VAR_DECL)
4495 DECL_COMMON (*node) = 1;
4498 warning (OPT_Wattributes, "%qE attribute ignored", name);
4499 *no_add_attrs = true;
4505 /* Handle a "noreturn" attribute; arguments as in
4506 struct attribute_spec.handler. */
4509 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4510 int ARG_UNUSED (flags), bool *no_add_attrs)
4512 tree type = TREE_TYPE (*node);
4514 /* See FIXME comment in c_common_attribute_table. */
4515 if (TREE_CODE (*node) == FUNCTION_DECL)
4516 TREE_THIS_VOLATILE (*node) = 1;
4517 else if (TREE_CODE (type) == POINTER_TYPE
4518 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4520 = build_pointer_type
4521 (build_type_variant (TREE_TYPE (type),
4522 TYPE_READONLY (TREE_TYPE (type)), 1));
4525 warning (OPT_Wattributes, "%qE attribute ignored", name);
4526 *no_add_attrs = true;
4532 /* Handle a "hot" and attribute; arguments as in
4533 struct attribute_spec.handler. */
4536 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4537 int ARG_UNUSED (flags), bool *no_add_attrs)
4539 if (TREE_CODE (*node) == FUNCTION_DECL)
4541 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
4543 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4545 *no_add_attrs = true;
4547 /* Do nothing else, just set the attribute. We'll get at
4548 it later with lookup_attribute. */
4552 warning (OPT_Wattributes, "%qE attribute ignored", name);
4553 *no_add_attrs = true;
4558 /* Handle a "cold" and attribute; arguments as in
4559 struct attribute_spec.handler. */
4562 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4563 int ARG_UNUSED (flags), bool *no_add_attrs)
4565 if (TREE_CODE (*node) == FUNCTION_DECL)
4567 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
4569 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4571 *no_add_attrs = true;
4573 /* Do nothing else, just set the attribute. We'll get at
4574 it later with lookup_attribute. */
4578 warning (OPT_Wattributes, "%qE attribute ignored", name);
4579 *no_add_attrs = true;
4585 /* Handle a "noinline" attribute; arguments as in
4586 struct attribute_spec.handler. */
4589 handle_noinline_attribute (tree *node, tree name,
4590 tree ARG_UNUSED (args),
4591 int ARG_UNUSED (flags), bool *no_add_attrs)
4593 if (TREE_CODE (*node) == FUNCTION_DECL)
4594 DECL_UNINLINABLE (*node) = 1;
4597 warning (OPT_Wattributes, "%qE attribute ignored", name);
4598 *no_add_attrs = true;
4604 /* Handle a "always_inline" attribute; arguments as in
4605 struct attribute_spec.handler. */
4608 handle_always_inline_attribute (tree *node, tree name,
4609 tree ARG_UNUSED (args),
4610 int ARG_UNUSED (flags),
4613 if (TREE_CODE (*node) == FUNCTION_DECL)
4615 /* Do nothing else, just set the attribute. We'll get at
4616 it later with lookup_attribute. */
4620 warning (OPT_Wattributes, "%qE attribute ignored", name);
4621 *no_add_attrs = true;
4627 /* Handle a "gnu_inline" attribute; arguments as in
4628 struct attribute_spec.handler. */
4631 handle_gnu_inline_attribute (tree *node, tree name,
4632 tree ARG_UNUSED (args),
4633 int ARG_UNUSED (flags),
4636 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4638 /* Do nothing else, just set the attribute. We'll get at
4639 it later with lookup_attribute. */
4643 warning (OPT_Wattributes, "%qE attribute ignored", name);
4644 *no_add_attrs = true;
4650 /* Handle a "flatten" attribute; arguments as in
4651 struct attribute_spec.handler. */
4654 handle_flatten_attribute (tree *node, tree name,
4655 tree args ATTRIBUTE_UNUSED,
4656 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4658 if (TREE_CODE (*node) == FUNCTION_DECL)
4659 /* Do nothing else, just set the attribute. We'll get at
4660 it later with lookup_attribute. */
4664 warning (OPT_Wattributes, "%qE attribute ignored", name);
4665 *no_add_attrs = true;
4672 /* Handle a "used" attribute; arguments as in
4673 struct attribute_spec.handler. */
4676 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4677 int ARG_UNUSED (flags), bool *no_add_attrs)
4681 if (TREE_CODE (node) == FUNCTION_DECL
4682 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4684 TREE_USED (node) = 1;
4685 DECL_PRESERVE_P (node) = 1;
4689 warning (OPT_Wattributes, "%qE attribute ignored", name);
4690 *no_add_attrs = true;
4696 /* Handle a "unused" attribute; arguments as in
4697 struct attribute_spec.handler. */
4700 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4701 int flags, bool *no_add_attrs)
4707 if (TREE_CODE (decl) == PARM_DECL
4708 || TREE_CODE (decl) == VAR_DECL
4709 || TREE_CODE (decl) == FUNCTION_DECL
4710 || TREE_CODE (decl) == LABEL_DECL
4711 || TREE_CODE (decl) == TYPE_DECL)
4712 TREE_USED (decl) = 1;
4715 warning (OPT_Wattributes, "%qE attribute ignored", name);
4716 *no_add_attrs = true;
4721 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4722 *node = build_variant_type_copy (*node);
4723 TREE_USED (*node) = 1;
4729 /* Handle a "externally_visible" attribute; arguments as in
4730 struct attribute_spec.handler. */
4733 handle_externally_visible_attribute (tree *pnode, tree name,
4734 tree ARG_UNUSED (args),
4735 int ARG_UNUSED (flags),
4740 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4742 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4743 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4745 warning (OPT_Wattributes,
4746 "%qE attribute have effect only on public objects", name);
4747 *no_add_attrs = true;
4752 warning (OPT_Wattributes, "%qE attribute ignored", name);
4753 *no_add_attrs = true;
4759 /* Handle a "const" attribute; arguments as in
4760 struct attribute_spec.handler. */
4763 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4764 int ARG_UNUSED (flags), bool *no_add_attrs)
4766 tree type = TREE_TYPE (*node);
4768 /* See FIXME comment on noreturn in c_common_attribute_table. */
4769 if (TREE_CODE (*node) == FUNCTION_DECL)
4770 TREE_READONLY (*node) = 1;
4771 else if (TREE_CODE (type) == POINTER_TYPE
4772 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4774 = build_pointer_type
4775 (build_type_variant (TREE_TYPE (type), 1,
4776 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4779 warning (OPT_Wattributes, "%qE attribute ignored", name);
4780 *no_add_attrs = true;
4786 /* Handle a "transparent_union" attribute; arguments as in
4787 struct attribute_spec.handler. */
4790 handle_transparent_union_attribute (tree *node, tree name,
4791 tree ARG_UNUSED (args), int flags,
4796 *no_add_attrs = true;
4800 if (TREE_CODE (*node) != TYPE_DECL)
4802 node = &TREE_TYPE (*node);
4805 else if (TYPE_P (*node))
4810 if (TREE_CODE (type) == UNION_TYPE)
4812 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4813 the code in finish_struct. */
4814 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4816 if (TYPE_FIELDS (type) == NULL_TREE
4817 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4820 /* A type variant isn't good enough, since we don't a cast
4821 to such a type removed as a no-op. */
4822 *node = type = build_duplicate_type (type);
4825 TYPE_TRANSPARENT_UNION (type) = 1;
4830 warning (OPT_Wattributes, "%qE attribute ignored", name);
4834 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
4835 get the requested priority for a constructor or destructor,
4836 possibly issuing diagnostics for invalid or reserved
4839 static priority_type
4840 get_priority (tree args, bool is_destructor)
4846 return DEFAULT_INIT_PRIORITY;
4848 if (!SUPPORTS_INIT_PRIORITY)
4851 error ("destructor priorities are not supported");
4853 error ("constructor priorities are not supported");
4854 return DEFAULT_INIT_PRIORITY;
4857 arg = TREE_VALUE (args);
4858 if (!host_integerp (arg, /*pos=*/0)
4859 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
4862 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
4863 if (pri < 0 || pri > MAX_INIT_PRIORITY)
4866 if (pri <= MAX_RESERVED_INIT_PRIORITY)
4870 "destructor priorities from 0 to %d are reserved "
4871 "for the implementation",
4872 MAX_RESERVED_INIT_PRIORITY);
4875 "constructor priorities from 0 to %d are reserved "
4876 "for the implementation",
4877 MAX_RESERVED_INIT_PRIORITY);
4883 error ("destructor priorities must be integers from 0 to %d inclusive",
4886 error ("constructor priorities must be integers from 0 to %d inclusive",
4888 return DEFAULT_INIT_PRIORITY;
4891 /* Handle a "constructor" attribute; arguments as in
4892 struct attribute_spec.handler. */
4895 handle_constructor_attribute (tree *node, tree name, tree args,
4896 int ARG_UNUSED (flags),
4900 tree type = TREE_TYPE (decl);
4902 if (TREE_CODE (decl) == FUNCTION_DECL
4903 && TREE_CODE (type) == FUNCTION_TYPE
4904 && decl_function_context (decl) == 0)
4906 priority_type priority;
4907 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4908 priority = get_priority (args, /*is_destructor=*/false);
4909 SET_DECL_INIT_PRIORITY (decl, priority);
4910 TREE_USED (decl) = 1;
4914 warning (OPT_Wattributes, "%qE attribute ignored", name);
4915 *no_add_attrs = true;
4921 /* Handle a "destructor" attribute; arguments as in
4922 struct attribute_spec.handler. */
4925 handle_destructor_attribute (tree *node, tree name, tree args,
4926 int ARG_UNUSED (flags),
4930 tree type = TREE_TYPE (decl);
4932 if (TREE_CODE (decl) == FUNCTION_DECL
4933 && TREE_CODE (type) == FUNCTION_TYPE
4934 && decl_function_context (decl) == 0)
4936 priority_type priority;
4937 DECL_STATIC_DESTRUCTOR (decl) = 1;
4938 priority = get_priority (args, /*is_destructor=*/true);
4939 SET_DECL_FINI_PRIORITY (decl, priority);
4940 TREE_USED (decl) = 1;
4944 warning (OPT_Wattributes, "%qE attribute ignored", name);
4945 *no_add_attrs = true;
4951 /* Handle a "mode" attribute; arguments as in
4952 struct attribute_spec.handler. */
4955 handle_mode_attribute (tree *node, tree name, tree args,
4956 int ARG_UNUSED (flags), bool *no_add_attrs)
4960 *no_add_attrs = true;
4962 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4963 warning (OPT_Wattributes, "%qE attribute ignored", name);
4967 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4968 int len = strlen (p);
4969 enum machine_mode mode = VOIDmode;
4973 if (len > 4 && p[0] == '_' && p[1] == '_'
4974 && p[len - 1] == '_' && p[len - 2] == '_')
4976 char *newp = (char *) alloca (len - 1);
4978 strcpy (newp, &p[2]);
4979 newp[len - 4] = '\0';
4983 /* Change this type to have a type with the specified mode.
4984 First check for the special modes. */
4985 if (!strcmp (p, "byte"))
4987 else if (!strcmp (p, "word"))
4989 else if (!strcmp (p, "pointer"))
4991 else if (!strcmp (p, "libgcc_cmp_return"))
4992 mode = targetm.libgcc_cmp_return_mode ();
4993 else if (!strcmp (p, "libgcc_shift_count"))
4994 mode = targetm.libgcc_shift_count_mode ();
4996 for (j = 0; j < NUM_MACHINE_MODES; j++)
4997 if (!strcmp (p, GET_MODE_NAME (j)))
4999 mode = (enum machine_mode) j;
5003 if (mode == VOIDmode)
5005 error ("unknown machine mode %qs", p);
5010 switch (GET_MODE_CLASS (mode))
5013 case MODE_PARTIAL_INT:
5015 case MODE_DECIMAL_FLOAT:
5016 valid_mode = targetm.scalar_mode_supported_p (mode);
5019 case MODE_COMPLEX_INT:
5020 case MODE_COMPLEX_FLOAT:
5021 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5024 case MODE_VECTOR_INT:
5025 case MODE_VECTOR_FLOAT:
5026 warning (OPT_Wattributes, "specifying vector types with "
5027 "__attribute__ ((mode)) is deprecated");
5028 warning (OPT_Wattributes,
5029 "use __attribute__ ((vector_size)) instead");
5030 valid_mode = vector_mode_valid_p (mode);
5038 error ("unable to emulate %qs", p);
5042 if (POINTER_TYPE_P (type))
5044 tree (*fn)(tree, enum machine_mode, bool);
5046 if (!targetm.valid_pointer_mode (mode))
5048 error ("invalid pointer mode %qs", p);
5052 if (TREE_CODE (type) == POINTER_TYPE)
5053 fn = build_pointer_type_for_mode;
5055 fn = build_reference_type_for_mode;
5056 typefm = fn (TREE_TYPE (type), mode, false);
5059 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
5061 if (typefm == NULL_TREE)
5063 error ("no data type for mode %qs", p);
5066 else if (TREE_CODE (type) == ENUMERAL_TYPE)
5068 /* For enumeral types, copy the precision from the integer
5069 type returned above. If not an INTEGER_TYPE, we can't use
5070 this mode for this type. */
5071 if (TREE_CODE (typefm) != INTEGER_TYPE)
5073 error ("cannot use mode %qs for enumeral types", p);
5077 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5079 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5084 /* We cannot build a type variant, as there's code that assumes
5085 that TYPE_MAIN_VARIANT has the same mode. This includes the
5086 debug generators. Instead, create a subrange type. This
5087 results in all of the enumeral values being emitted only once
5088 in the original, and the subtype gets them by reference. */
5089 if (TYPE_UNSIGNED (type))
5090 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5092 typefm = make_signed_type (TYPE_PRECISION (typefm));
5093 TREE_TYPE (typefm) = type;
5096 else if (VECTOR_MODE_P (mode)
5097 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5098 : TREE_CODE (type) != TREE_CODE (typefm))
5100 error ("mode %qs applied to inappropriate type", p);
5110 /* Handle a "section" attribute; arguments as in
5111 struct attribute_spec.handler. */
5114 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5115 int ARG_UNUSED (flags), bool *no_add_attrs)
5119 if (targetm.have_named_sections)
5121 user_defined_section_attribute = true;
5123 if ((TREE_CODE (decl) == FUNCTION_DECL
5124 || TREE_CODE (decl) == VAR_DECL)
5125 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5127 if (TREE_CODE (decl) == VAR_DECL
5128 && current_function_decl != NULL_TREE
5129 && !TREE_STATIC (decl))
5131 error ("%Jsection attribute cannot be specified for "
5132 "local variables", decl);
5133 *no_add_attrs = true;
5136 /* The decl may have already been given a section attribute
5137 from a previous declaration. Ensure they match. */
5138 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5139 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5140 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5142 error ("section of %q+D conflicts with previous declaration",
5144 *no_add_attrs = true;
5147 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5151 error ("section attribute not allowed for %q+D", *node);
5152 *no_add_attrs = true;
5157 error ("%Jsection attributes are not supported for this target", *node);
5158 *no_add_attrs = true;
5164 /* Handle a "aligned" attribute; arguments as in
5165 struct attribute_spec.handler. */
5168 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5169 int flags, bool *no_add_attrs)
5171 tree decl = NULL_TREE;
5174 tree align_expr = (args ? TREE_VALUE (args)
5175 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5181 type = &TREE_TYPE (decl);
5182 is_type = TREE_CODE (*node) == TYPE_DECL;
5184 else if (TYPE_P (*node))
5185 type = node, is_type = 1;
5187 if (TREE_CODE (align_expr) != INTEGER_CST)
5189 error ("requested alignment is not a constant");
5190 *no_add_attrs = true;
5192 else if ((i = tree_log2 (align_expr)) == -1)
5194 error ("requested alignment is not a power of 2");
5195 *no_add_attrs = true;
5197 else if (i > HOST_BITS_PER_INT - 2)
5199 error ("requested alignment is too large");
5200 *no_add_attrs = true;
5204 /* If we have a TYPE_DECL, then copy the type, so that we
5205 don't accidentally modify a builtin type. See pushdecl. */
5206 if (decl && TREE_TYPE (decl) != error_mark_node
5207 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5209 tree tt = TREE_TYPE (decl);
5210 *type = build_variant_type_copy (*type);
5211 DECL_ORIGINAL_TYPE (decl) = tt;
5212 TYPE_NAME (*type) = decl;
5213 TREE_USED (*type) = TREE_USED (decl);
5214 TREE_TYPE (decl) = *type;
5216 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5217 *type = build_variant_type_copy (*type);
5219 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5220 TYPE_USER_ALIGN (*type) = 1;
5222 else if (! VAR_OR_FUNCTION_DECL_P (decl)
5223 && TREE_CODE (decl) != FIELD_DECL)
5225 error ("alignment may not be specified for %q+D", decl);
5226 *no_add_attrs = true;
5228 else if (TREE_CODE (decl) == FUNCTION_DECL
5229 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
5231 if (DECL_USER_ALIGN (decl))
5232 error ("alignment for %q+D was previously specified as %d "
5233 "and may not be decreased", decl,
5234 DECL_ALIGN (decl) / BITS_PER_UNIT);
5236 error ("alignment for %q+D must be at least %d", decl,
5237 DECL_ALIGN (decl) / BITS_PER_UNIT);
5238 *no_add_attrs = true;
5242 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5243 DECL_USER_ALIGN (decl) = 1;
5249 /* Handle a "weak" attribute; arguments as in
5250 struct attribute_spec.handler. */
5253 handle_weak_attribute (tree *node, tree name,
5254 tree ARG_UNUSED (args),
5255 int ARG_UNUSED (flags),
5256 bool * ARG_UNUSED (no_add_attrs))
5258 if (TREE_CODE (*node) == FUNCTION_DECL
5259 || TREE_CODE (*node) == VAR_DECL)
5260 declare_weak (*node);
5262 warning (OPT_Wattributes, "%qE attribute ignored", name);
5268 /* Handle an "alias" attribute; arguments as in
5269 struct attribute_spec.handler. */
5272 handle_alias_attribute (tree *node, tree name, tree args,
5273 int ARG_UNUSED (flags), bool *no_add_attrs)
5277 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5278 || (TREE_CODE (decl) != FUNCTION_DECL
5279 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
5280 /* A static variable declaration is always a tentative definition,
5281 but the alias is a non-tentative definition which overrides. */
5282 || (TREE_CODE (decl) != FUNCTION_DECL
5283 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
5285 error ("%q+D defined both normally and as an alias", decl);
5286 *no_add_attrs = true;
5289 /* Note that the very first time we process a nested declaration,
5290 decl_function_context will not be set. Indeed, *would* never
5291 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
5292 we do below. After such frobbery, pushdecl would set the context.
5293 In any case, this is never what we want. */
5294 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
5298 id = TREE_VALUE (args);
5299 if (TREE_CODE (id) != STRING_CST)
5301 error ("alias argument not a string");
5302 *no_add_attrs = true;
5305 id = get_identifier (TREE_STRING_POINTER (id));
5306 /* This counts as a use of the object pointed to. */
5309 if (TREE_CODE (decl) == FUNCTION_DECL)
5310 DECL_INITIAL (decl) = error_mark_node;
5313 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
5314 DECL_EXTERNAL (decl) = 1;
5316 DECL_EXTERNAL (decl) = 0;
5317 TREE_STATIC (decl) = 1;
5322 warning (OPT_Wattributes, "%qE attribute ignored", name);
5323 *no_add_attrs = true;
5329 /* Handle a "weakref" attribute; arguments as in struct
5330 attribute_spec.handler. */
5333 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5334 int flags, bool *no_add_attrs)
5336 tree attr = NULL_TREE;
5338 /* We must ignore the attribute when it is associated with
5339 local-scoped decls, since attribute alias is ignored and many
5340 such symbols do not even have a DECL_WEAK field. */
5341 if (decl_function_context (*node) || current_function_decl)
5343 warning (OPT_Wattributes, "%qE attribute ignored", name);
5344 *no_add_attrs = true;
5348 /* The idea here is that `weakref("name")' mutates into `weakref,
5349 alias("name")', and weakref without arguments, in turn,
5350 implicitly adds weak. */
5354 attr = tree_cons (get_identifier ("alias"), args, attr);
5355 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
5357 *no_add_attrs = true;
5359 decl_attributes (node, attr, flags);
5363 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
5364 error ("%Jweakref attribute must appear before alias attribute",
5367 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5368 and that isn't supported; and because it wants to add it to
5369 the list of weak decls, which isn't helpful. */
5370 DECL_WEAK (*node) = 1;
5376 /* Handle an "visibility" attribute; arguments as in
5377 struct attribute_spec.handler. */
5380 handle_visibility_attribute (tree *node, tree name, tree args,
5381 int ARG_UNUSED (flags),
5382 bool *ARG_UNUSED (no_add_attrs))
5385 tree id = TREE_VALUE (args);
5386 enum symbol_visibility vis;
5390 if (TREE_CODE (*node) == ENUMERAL_TYPE)
5392 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5394 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5398 else if (TYPE_FIELDS (*node))
5400 error ("%qE attribute ignored because %qT is already defined",
5405 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5407 warning (OPT_Wattributes, "%qE attribute ignored", name);
5411 if (TREE_CODE (id) != STRING_CST)
5413 error ("visibility argument not a string");
5417 /* If this is a type, set the visibility on the type decl. */
5420 decl = TYPE_NAME (decl);
5423 if (TREE_CODE (decl) == IDENTIFIER_NODE)
5425 warning (OPT_Wattributes, "%qE attribute ignored on types",
5431 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5432 vis = VISIBILITY_DEFAULT;
5433 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5434 vis = VISIBILITY_INTERNAL;
5435 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5436 vis = VISIBILITY_HIDDEN;
5437 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5438 vis = VISIBILITY_PROTECTED;
5441 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5442 vis = VISIBILITY_DEFAULT;
5445 if (DECL_VISIBILITY_SPECIFIED (decl)
5446 && vis != DECL_VISIBILITY (decl))
5448 tree attributes = (TYPE_P (*node)
5449 ? TYPE_ATTRIBUTES (*node)
5450 : DECL_ATTRIBUTES (decl));
5451 if (lookup_attribute ("visibility", attributes))
5452 error ("%qD redeclared with different visibility", decl);
5453 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5454 && lookup_attribute ("dllimport", attributes))
5455 error ("%qD was declared %qs which implies default visibility",
5457 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5458 && lookup_attribute ("dllexport", attributes))
5459 error ("%qD was declared %qs which implies default visibility",
5463 DECL_VISIBILITY (decl) = vis;
5464 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5466 /* Go ahead and attach the attribute to the node as well. This is needed
5467 so we can determine whether we have VISIBILITY_DEFAULT because the
5468 visibility was not specified, or because it was explicitly overridden
5469 from the containing scope. */
5474 /* Determine the ELF symbol visibility for DECL, which is either a
5475 variable or a function. It is an error to use this function if a
5476 definition of DECL is not available in this translation unit.
5477 Returns true if the final visibility has been determined by this
5478 function; false if the caller is free to make additional
5482 c_determine_visibility (tree decl)
5484 gcc_assert (TREE_CODE (decl) == VAR_DECL
5485 || TREE_CODE (decl) == FUNCTION_DECL);
5487 /* If the user explicitly specified the visibility with an
5488 attribute, honor that. DECL_VISIBILITY will have been set during
5489 the processing of the attribute. We check for an explicit
5490 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5491 to distinguish the use of an attribute from the use of a "#pragma
5492 GCC visibility push(...)"; in the latter case we still want other
5493 considerations to be able to overrule the #pragma. */
5494 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
5495 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5496 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
5497 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
5500 /* Set default visibility to whatever the user supplied with
5501 visibility_specified depending on #pragma GCC visibility. */
5502 if (!DECL_VISIBILITY_SPECIFIED (decl))
5504 DECL_VISIBILITY (decl) = default_visibility;
5505 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5510 /* Handle an "tls_model" attribute; arguments as in
5511 struct attribute_spec.handler. */
5514 handle_tls_model_attribute (tree *node, tree name, tree args,
5515 int ARG_UNUSED (flags), bool *no_add_attrs)
5519 enum tls_model kind;
5521 *no_add_attrs = true;
5523 if (!DECL_THREAD_LOCAL_P (decl))
5525 warning (OPT_Wattributes, "%qE attribute ignored", name);
5529 kind = DECL_TLS_MODEL (decl);
5530 id = TREE_VALUE (args);
5531 if (TREE_CODE (id) != STRING_CST)
5533 error ("tls_model argument not a string");
5537 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5538 kind = TLS_MODEL_LOCAL_EXEC;
5539 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5540 kind = TLS_MODEL_INITIAL_EXEC;
5541 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5542 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5543 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5544 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5546 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5548 DECL_TLS_MODEL (decl) = kind;
5552 /* Handle a "no_instrument_function" attribute; arguments as in
5553 struct attribute_spec.handler. */
5556 handle_no_instrument_function_attribute (tree *node, tree name,
5557 tree ARG_UNUSED (args),
5558 int ARG_UNUSED (flags),
5563 if (TREE_CODE (decl) != FUNCTION_DECL)
5565 error ("%J%qE attribute applies only to functions", decl, name);
5566 *no_add_attrs = true;
5568 else if (DECL_INITIAL (decl))
5570 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5571 *no_add_attrs = true;
5574 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5579 /* Handle a "malloc" attribute; arguments as in
5580 struct attribute_spec.handler. */
5583 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5584 int ARG_UNUSED (flags), bool *no_add_attrs)
5586 if (TREE_CODE (*node) == FUNCTION_DECL
5587 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5588 DECL_IS_MALLOC (*node) = 1;
5591 warning (OPT_Wattributes, "%qE attribute ignored", name);
5592 *no_add_attrs = true;
5598 /* Handle a "alloc_size" attribute; arguments as in
5599 struct attribute_spec.handler. */
5602 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5603 int ARG_UNUSED (flags), bool *no_add_attrs)
5605 tree params = TYPE_ARG_TYPES (*node);
5606 unsigned arg_count = 0;
5608 for (; TREE_CHAIN (params); params = TREE_CHAIN (params))
5611 for (; args; args = TREE_CHAIN (args))
5613 tree position = TREE_VALUE (args);
5615 if (TREE_CODE (position) != INTEGER_CST
5616 || TREE_INT_CST_HIGH (position)
5617 || TREE_INT_CST_LOW (position) < 1
5618 || TREE_INT_CST_LOW (position) > arg_count )
5620 warning (OPT_Wattributes,
5621 "alloc_size parameter outside range");
5622 *no_add_attrs = true;
5629 /* Handle a "returns_twice" attribute; arguments as in
5630 struct attribute_spec.handler. */
5633 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5634 int ARG_UNUSED (flags), bool *no_add_attrs)
5636 if (TREE_CODE (*node) == FUNCTION_DECL)
5637 DECL_IS_RETURNS_TWICE (*node) = 1;
5640 warning (OPT_Wattributes, "%qE attribute ignored", name);
5641 *no_add_attrs = true;
5647 /* Handle a "no_limit_stack" attribute; arguments as in
5648 struct attribute_spec.handler. */
5651 handle_no_limit_stack_attribute (tree *node, tree name,
5652 tree ARG_UNUSED (args),
5653 int ARG_UNUSED (flags),
5658 if (TREE_CODE (decl) != FUNCTION_DECL)
5660 error ("%J%qE attribute applies only to functions", decl, name);
5661 *no_add_attrs = true;
5663 else if (DECL_INITIAL (decl))
5665 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5666 *no_add_attrs = true;
5669 DECL_NO_LIMIT_STACK (decl) = 1;
5674 /* Handle a "pure" attribute; arguments as in
5675 struct attribute_spec.handler. */
5678 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5679 int ARG_UNUSED (flags), bool *no_add_attrs)
5681 if (TREE_CODE (*node) == FUNCTION_DECL)
5682 DECL_IS_PURE (*node) = 1;
5683 /* ??? TODO: Support types. */
5686 warning (OPT_Wattributes, "%qE attribute ignored", name);
5687 *no_add_attrs = true;
5693 /* Handle a "no vops" attribute; arguments as in
5694 struct attribute_spec.handler. */
5697 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5698 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5699 bool *ARG_UNUSED (no_add_attrs))
5701 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5702 DECL_IS_NOVOPS (*node) = 1;
5706 /* Handle a "deprecated" attribute; arguments as in
5707 struct attribute_spec.handler. */
5710 handle_deprecated_attribute (tree *node, tree name,
5711 tree ARG_UNUSED (args), int flags,
5714 tree type = NULL_TREE;
5716 tree what = NULL_TREE;
5721 type = TREE_TYPE (decl);
5723 if (TREE_CODE (decl) == TYPE_DECL
5724 || TREE_CODE (decl) == PARM_DECL
5725 || TREE_CODE (decl) == VAR_DECL
5726 || TREE_CODE (decl) == FUNCTION_DECL
5727 || TREE_CODE (decl) == FIELD_DECL)
5728 TREE_DEPRECATED (decl) = 1;
5732 else if (TYPE_P (*node))
5734 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5735 *node = build_variant_type_copy (*node);
5736 TREE_DEPRECATED (*node) = 1;
5744 *no_add_attrs = true;
5745 if (type && TYPE_NAME (type))
5747 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5748 what = TYPE_NAME (*node);
5749 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5750 && DECL_NAME (TYPE_NAME (type)))
5751 what = DECL_NAME (TYPE_NAME (type));
5754 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5756 warning (OPT_Wattributes, "%qE attribute ignored", name);
5762 /* Handle a "vector_size" attribute; arguments as in
5763 struct attribute_spec.handler. */
5766 handle_vector_size_attribute (tree *node, tree name, tree args,
5767 int ARG_UNUSED (flags),
5770 unsigned HOST_WIDE_INT vecsize, nunits;
5771 enum machine_mode orig_mode;
5772 tree type = *node, new_type, size;
5774 *no_add_attrs = true;
5776 size = TREE_VALUE (args);
5778 if (!host_integerp (size, 1))
5780 warning (OPT_Wattributes, "%qE attribute ignored", name);
5784 /* Get the vector size (in bytes). */
5785 vecsize = tree_low_cst (size, 1);
5787 /* We need to provide for vector pointers, vector arrays, and
5788 functions returning vectors. For example:
5790 __attribute__((vector_size(16))) short *foo;
5792 In this case, the mode is SI, but the type being modified is
5793 HI, so we need to look further. */
5795 while (POINTER_TYPE_P (type)
5796 || TREE_CODE (type) == FUNCTION_TYPE
5797 || TREE_CODE (type) == METHOD_TYPE
5798 || TREE_CODE (type) == ARRAY_TYPE)
5799 type = TREE_TYPE (type);
5801 /* Get the mode of the type being modified. */
5802 orig_mode = TYPE_MODE (type);
5804 if (TREE_CODE (type) == RECORD_TYPE
5805 || TREE_CODE (type) == UNION_TYPE
5806 || TREE_CODE (type) == VECTOR_TYPE
5807 || (!SCALAR_FLOAT_MODE_P (orig_mode)
5808 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5809 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5811 error ("invalid vector type for attribute %qE", name);
5815 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5817 error ("vector size not an integral multiple of component size");
5823 error ("zero vector size");
5827 /* Calculate how many units fit in the vector. */
5828 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5829 if (nunits & (nunits - 1))
5831 error ("number of components of the vector not a power of two");
5835 new_type = build_vector_type (type, nunits);
5837 /* Build back pointers if needed. */
5838 *node = reconstruct_complex_type (*node, new_type);
5843 /* Handle the "nonnull" attribute. */
5845 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5846 tree args, int ARG_UNUSED (flags),
5850 unsigned HOST_WIDE_INT attr_arg_num;
5852 /* If no arguments are specified, all pointer arguments should be
5853 non-null. Verify a full prototype is given so that the arguments
5854 will have the correct types when we actually check them later. */
5857 if (!TYPE_ARG_TYPES (type))
5859 error ("nonnull attribute without arguments on a non-prototype");
5860 *no_add_attrs = true;
5865 /* Argument list specified. Verify that each argument number references
5866 a pointer argument. */
5867 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5870 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5872 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5874 error ("nonnull argument has invalid operand number (argument %lu)",
5875 (unsigned long) attr_arg_num);
5876 *no_add_attrs = true;
5880 argument = TYPE_ARG_TYPES (type);
5883 for (ck_num = 1; ; ck_num++)
5885 if (!argument || ck_num == arg_num)
5887 argument = TREE_CHAIN (argument);
5891 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5893 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5894 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5895 *no_add_attrs = true;
5899 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5901 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5902 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5903 *no_add_attrs = true;
5912 /* Check the argument list of a function call for null in argument slots
5913 that are marked as requiring a non-null pointer argument. The NARGS
5914 arguments are passed in the array ARGARRAY.
5918 check_function_nonnull (tree attrs, int nargs, tree *argarray)
5923 for (a = attrs; a; a = TREE_CHAIN (a))
5925 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5927 args = TREE_VALUE (a);
5929 /* Walk the argument list. If we encounter an argument number we
5930 should check for non-null, do it. If the attribute has no args,
5931 then every pointer argument is checked (in which case the check
5932 for pointer type is done in check_nonnull_arg). */
5933 for (i = 0; i < nargs; i++)
5935 if (!args || nonnull_check_p (args, i + 1))
5936 check_function_arguments_recurse (check_nonnull_arg, NULL,
5944 /* Check that the Nth argument of a function call (counting backwards
5945 from the end) is a (pointer)0. The NARGS arguments are passed in the
5949 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
5951 tree attr = lookup_attribute ("sentinel", attrs);
5959 /* Skip over the named arguments. */
5960 while (typelist && len < nargs)
5962 typelist = TREE_CHAIN (typelist);
5966 if (TREE_VALUE (attr))
5968 tree p = TREE_VALUE (TREE_VALUE (attr));
5969 pos = TREE_INT_CST_LOW (p);
5972 /* The sentinel must be one of the varargs, i.e.
5973 in position >= the number of fixed arguments. */
5974 if ((nargs - 1 - pos) < len)
5976 warning (OPT_Wformat,
5977 "not enough variable arguments to fit a sentinel");
5981 /* Validate the sentinel. */
5982 sentinel = argarray[nargs - 1 - pos];
5983 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
5984 || !integer_zerop (sentinel))
5985 /* Although __null (in C++) is only an integer we allow it
5986 nevertheless, as we are guaranteed that it's exactly
5987 as wide as a pointer, and we don't want to force
5988 users to cast the NULL they have written there.
5989 We warn with -Wstrict-null-sentinel, though. */
5990 && (warn_strict_null_sentinel || null_node != sentinel))
5991 warning (OPT_Wformat, "missing sentinel in function call");
5995 /* Helper for check_function_nonnull; given a list of operands which
5996 must be non-null in ARGS, determine if operand PARAM_NUM should be
6000 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6002 unsigned HOST_WIDE_INT arg_num = 0;
6004 for (; args; args = TREE_CHAIN (args))
6006 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6010 if (arg_num == param_num)
6016 /* Check that the function argument PARAM (which is operand number
6017 PARAM_NUM) is non-null. This is called by check_function_nonnull
6018 via check_function_arguments_recurse. */
6021 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6022 unsigned HOST_WIDE_INT param_num)
6024 /* Just skip checking the argument if it's not a pointer. This can
6025 happen if the "nonnull" attribute was given without an operand
6026 list (which means to check every pointer argument). */
6028 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6031 if (integer_zerop (param))
6032 warning (OPT_Wnonnull, "null argument where non-null required "
6033 "(argument %lu)", (unsigned long) param_num);
6036 /* Helper for nonnull attribute handling; fetch the operand number
6037 from the attribute argument list. */
6040 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6042 /* Verify the arg number is a constant. */
6043 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6044 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6047 *valp = TREE_INT_CST_LOW (arg_num_expr);
6051 /* Handle a "nothrow" attribute; arguments as in
6052 struct attribute_spec.handler. */
6055 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6056 int ARG_UNUSED (flags), bool *no_add_attrs)
6058 if (TREE_CODE (*node) == FUNCTION_DECL)
6059 TREE_NOTHROW (*node) = 1;
6060 /* ??? TODO: Support types. */
6063 warning (OPT_Wattributes, "%qE attribute ignored", name);
6064 *no_add_attrs = true;
6070 /* Handle a "cleanup" attribute; arguments as in
6071 struct attribute_spec.handler. */
6074 handle_cleanup_attribute (tree *node, tree name, tree args,
6075 int ARG_UNUSED (flags), bool *no_add_attrs)
6078 tree cleanup_id, cleanup_decl;
6080 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6081 for global destructors in C++. This requires infrastructure that
6082 we don't have generically at the moment. It's also not a feature
6083 we'd be missing too much, since we do have attribute constructor. */
6084 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6086 warning (OPT_Wattributes, "%qE attribute ignored", name);
6087 *no_add_attrs = true;
6091 /* Verify that the argument is a function in scope. */
6092 /* ??? We could support pointers to functions here as well, if
6093 that was considered desirable. */
6094 cleanup_id = TREE_VALUE (args);
6095 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6097 error ("cleanup argument not an identifier");
6098 *no_add_attrs = true;
6101 cleanup_decl = lookup_name (cleanup_id);
6102 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6104 error ("cleanup argument not a function");
6105 *no_add_attrs = true;
6109 /* That the function has proper type is checked with the
6110 eventual call to build_function_call. */
6115 /* Handle a "warn_unused_result" attribute. No special handling. */
6118 handle_warn_unused_result_attribute (tree *node, tree name,
6119 tree ARG_UNUSED (args),
6120 int ARG_UNUSED (flags), bool *no_add_attrs)
6122 /* Ignore the attribute for functions not returning any value. */
6123 if (VOID_TYPE_P (TREE_TYPE (*node)))
6125 warning (OPT_Wattributes, "%qE attribute ignored", name);
6126 *no_add_attrs = true;
6132 /* Handle a "sentinel" attribute. */
6135 handle_sentinel_attribute (tree *node, tree name, tree args,
6136 int ARG_UNUSED (flags), bool *no_add_attrs)
6138 tree params = TYPE_ARG_TYPES (*node);
6142 warning (OPT_Wattributes,
6143 "%qE attribute requires prototypes with named arguments", name);
6144 *no_add_attrs = true;
6148 while (TREE_CHAIN (params))
6149 params = TREE_CHAIN (params);
6151 if (VOID_TYPE_P (TREE_VALUE (params)))
6153 warning (OPT_Wattributes,
6154 "%qE attribute only applies to variadic functions", name);
6155 *no_add_attrs = true;
6161 tree position = TREE_VALUE (args);
6163 if (TREE_CODE (position) != INTEGER_CST)
6165 warning (OPT_Wattributes,
6166 "requested position is not an integer constant");
6167 *no_add_attrs = true;
6171 if (tree_int_cst_lt (position, integer_zero_node))
6173 warning (OPT_Wattributes,
6174 "requested position is less than zero");
6175 *no_add_attrs = true;
6183 /* Handle a "type_generic" attribute. */
6186 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6187 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6188 bool * ARG_UNUSED (no_add_attrs))
6190 /* Ensure we have a function type, with no arguments. */
6191 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE && ! TYPE_ARG_TYPES (*node));
6196 /* Check for valid arguments being passed to a function.
6197 ATTRS is a list of attributes. There are NARGS arguments in the array
6198 ARGARRAY. TYPELIST is the list of argument types for the function.
6201 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
6203 /* Check for null being passed in a pointer argument that must be
6204 non-null. We also need to do this if format checking is enabled. */
6207 check_function_nonnull (attrs, nargs, argarray);
6209 /* Check for errors in format strings. */
6211 if (warn_format || warn_missing_format_attribute)
6212 check_function_format (attrs, nargs, argarray);
6215 check_function_sentinel (attrs, nargs, argarray, typelist);
6218 /* Generic argument checking recursion routine. PARAM is the argument to
6219 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6220 once the argument is resolved. CTX is context for the callback. */
6222 check_function_arguments_recurse (void (*callback)
6223 (void *, tree, unsigned HOST_WIDE_INT),
6224 void *ctx, tree param,
6225 unsigned HOST_WIDE_INT param_num)
6227 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
6228 && (TYPE_PRECISION (TREE_TYPE (param))
6229 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
6231 /* Strip coercion. */
6232 check_function_arguments_recurse (callback, ctx,
6233 TREE_OPERAND (param, 0), param_num);
6237 if (TREE_CODE (param) == CALL_EXPR)
6239 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
6241 bool found_format_arg = false;
6243 /* See if this is a call to a known internationalization function
6244 that modifies a format arg. Such a function may have multiple
6245 format_arg attributes (for example, ngettext). */
6247 for (attrs = TYPE_ATTRIBUTES (type);
6249 attrs = TREE_CHAIN (attrs))
6250 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6253 tree format_num_expr;
6256 call_expr_arg_iterator iter;
6258 /* Extract the argument number, which was previously checked
6260 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6262 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
6263 && !TREE_INT_CST_HIGH (format_num_expr));
6265 format_num = TREE_INT_CST_LOW (format_num_expr);
6267 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
6269 inner_arg = next_call_expr_arg (&iter), i++)
6270 if (i == format_num)
6272 check_function_arguments_recurse (callback, ctx,
6273 inner_arg, param_num);
6274 found_format_arg = true;
6279 /* If we found a format_arg attribute and did a recursive check,
6280 we are done with checking this argument. Otherwise, we continue
6281 and this will be considered a non-literal. */
6282 if (found_format_arg)
6286 if (TREE_CODE (param) == COND_EXPR)
6288 /* Check both halves of the conditional expression. */
6289 check_function_arguments_recurse (callback, ctx,
6290 TREE_OPERAND (param, 1), param_num);
6291 check_function_arguments_recurse (callback, ctx,
6292 TREE_OPERAND (param, 2), param_num);
6296 (*callback) (ctx, param, param_num);
6299 /* Function to help qsort sort FIELD_DECLs by name order. */
6302 field_decl_cmp (const void *x_p, const void *y_p)
6304 const tree *const x = (const tree *const) x_p;
6305 const tree *const y = (const tree *const) y_p;
6307 if (DECL_NAME (*x) == DECL_NAME (*y))
6308 /* A nontype is "greater" than a type. */
6309 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6310 if (DECL_NAME (*x) == NULL_TREE)
6312 if (DECL_NAME (*y) == NULL_TREE)
6314 if (DECL_NAME (*x) < DECL_NAME (*y))
6320 gt_pointer_operator new_value;
6324 /* This routine compares two fields like field_decl_cmp but using the
6325 pointer operator in resort_data. */
6328 resort_field_decl_cmp (const void *x_p, const void *y_p)
6330 const tree *const x = (const tree *const) x_p;
6331 const tree *const y = (const tree *const) y_p;
6333 if (DECL_NAME (*x) == DECL_NAME (*y))
6334 /* A nontype is "greater" than a type. */
6335 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6336 if (DECL_NAME (*x) == NULL_TREE)
6338 if (DECL_NAME (*y) == NULL_TREE)
6341 tree d1 = DECL_NAME (*x);
6342 tree d2 = DECL_NAME (*y);
6343 resort_data.new_value (&d1, resort_data.cookie);
6344 resort_data.new_value (&d2, resort_data.cookie);
6351 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
6354 resort_sorted_fields (void *obj,
6355 void * ARG_UNUSED (orig_obj),
6356 gt_pointer_operator new_value,
6359 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6360 resort_data.new_value = new_value;
6361 resort_data.cookie = cookie;
6362 qsort (&sf->elts[0], sf->len, sizeof (tree),
6363 resort_field_decl_cmp);
6366 /* Subroutine of c_parse_error.
6367 Return the result of concatenating LHS and RHS. RHS is really
6368 a string literal, its first character is indicated by RHS_START and
6369 RHS_SIZE is its length (including the terminating NUL character).
6371 The caller is responsible for deleting the returned pointer. */
6374 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6376 const int lhs_size = strlen (lhs);
6377 char *result = XNEWVEC (char, lhs_size + rhs_size);
6378 strncpy (result, lhs, lhs_size);
6379 strncpy (result + lhs_size, rhs_start, rhs_size);
6383 /* Issue the error given by GMSGID, indicating that it occurred before
6384 TOKEN, which had the associated VALUE. */
6387 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6389 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6391 char *message = NULL;
6393 if (token == CPP_EOF)
6394 message = catenate_messages (gmsgid, " at end of input");
6395 else if (token == CPP_CHAR || token == CPP_WCHAR)
6397 unsigned int val = TREE_INT_CST_LOW (value);
6398 const char *const ell = (token == CPP_CHAR) ? "" : "L";
6399 if (val <= UCHAR_MAX && ISGRAPH (val))
6400 message = catenate_messages (gmsgid, " before %s'%c'");
6402 message = catenate_messages (gmsgid, " before %s'\\x%x'");
6404 error (message, ell, val);
6408 else if (token == CPP_STRING || token == CPP_WSTRING)
6409 message = catenate_messages (gmsgid, " before string constant");
6410 else if (token == CPP_NUMBER)
6411 message = catenate_messages (gmsgid, " before numeric constant");
6412 else if (token == CPP_NAME)
6414 message = catenate_messages (gmsgid, " before %qE");
6415 error (message, value);
6419 else if (token == CPP_PRAGMA)
6420 message = catenate_messages (gmsgid, " before %<#pragma%>");
6421 else if (token == CPP_PRAGMA_EOL)
6422 message = catenate_messages (gmsgid, " before end of line");
6423 else if (token < N_TTYPES)
6425 message = catenate_messages (gmsgid, " before %qs token");
6426 error (message, cpp_type2name (token));
6438 #undef catenate_messages
6441 /* Walk a gimplified function and warn for functions whose return value is
6442 ignored and attribute((warn_unused_result)) is set. This is done before
6443 inlining, so we don't have to worry about that. */
6446 c_warn_unused_result (tree *top_p)
6449 tree_stmt_iterator i;
6452 switch (TREE_CODE (t))
6454 case STATEMENT_LIST:
6455 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6456 c_warn_unused_result (tsi_stmt_ptr (i));
6460 c_warn_unused_result (&COND_EXPR_THEN (t));
6461 c_warn_unused_result (&COND_EXPR_ELSE (t));
6464 c_warn_unused_result (&BIND_EXPR_BODY (t));
6466 case TRY_FINALLY_EXPR:
6467 case TRY_CATCH_EXPR:
6468 c_warn_unused_result (&TREE_OPERAND (t, 0));
6469 c_warn_unused_result (&TREE_OPERAND (t, 1));
6472 c_warn_unused_result (&CATCH_BODY (t));
6474 case EH_FILTER_EXPR:
6475 c_warn_unused_result (&EH_FILTER_FAILURE (t));
6482 /* This is a naked call, as opposed to a CALL_EXPR nested inside
6483 a MODIFY_EXPR. All calls whose value is ignored should be
6484 represented like this. Look for the attribute. */
6485 fdecl = get_callee_fndecl (t);
6487 ftype = TREE_TYPE (fdecl);
6490 ftype = TREE_TYPE (CALL_EXPR_FN (t));
6491 /* Look past pointer-to-function to the function type itself. */
6492 ftype = TREE_TYPE (ftype);
6495 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
6498 warning (0, "%Hignoring return value of %qD, "
6499 "declared with attribute warn_unused_result",
6500 EXPR_LOCUS (t), fdecl);
6502 warning (0, "%Hignoring return value of function "
6503 "declared with attribute warn_unused_result",
6509 /* Not a container, not a call, or a call whose value is used. */
6514 /* Convert a character from the host to the target execution character
6515 set. cpplib handles this, mostly. */
6518 c_common_to_target_charset (HOST_WIDE_INT c)
6520 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6521 zero-extended under -fno-signed-char. cpplib insists that characters
6522 and character constants are always unsigned. Hence we must convert
6524 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6526 uc = cpp_host_to_exec_charset (parse_in, uc);
6528 if (flag_signed_char)
6529 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6530 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6535 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6536 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6537 NULL, at the bottom; much like the traditional rendering of offsetof as a
6538 macro. Returns the folded and properly cast result. */
6541 fold_offsetof_1 (tree expr, tree stop_ref)
6543 enum tree_code code = PLUS_EXPR;
6546 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6547 return size_zero_node;
6549 switch (TREE_CODE (expr))
6555 error ("cannot apply %<offsetof%> to static data member %qD", expr);
6556 return error_mark_node;
6559 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6560 return error_mark_node;
6563 gcc_assert (integer_zerop (expr));
6564 return size_zero_node;
6568 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6569 gcc_assert (base == error_mark_node || base == size_zero_node);
6573 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6574 if (base == error_mark_node)
6577 t = TREE_OPERAND (expr, 1);
6578 if (DECL_C_BIT_FIELD (t))
6580 error ("attempt to take address of bit-field structure "
6582 return error_mark_node;
6584 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6585 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6590 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6591 if (base == error_mark_node)
6594 t = TREE_OPERAND (expr, 1);
6595 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6598 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6600 t = convert (sizetype, t);
6601 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6605 /* Handle static members of volatile structs. */
6606 t = TREE_OPERAND (expr, 1);
6607 gcc_assert (TREE_CODE (t) == VAR_DECL);
6608 return fold_offsetof_1 (t, stop_ref);
6614 return size_binop (code, base, off);
6618 fold_offsetof (tree expr, tree stop_ref)
6620 /* Convert back from the internal sizetype to size_t. */
6621 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6624 /* Print an error message for an invalid lvalue. USE says
6625 how the lvalue is being used and so selects the error message. */
6628 lvalue_error (enum lvalue_use use)
6633 error ("lvalue required as left operand of assignment");
6636 error ("lvalue required as increment operand");
6639 error ("lvalue required as decrement operand");
6642 error ("lvalue required as unary %<&%> operand");
6645 error ("lvalue required in asm statement");
6652 /* *PTYPE is an incomplete array. Complete it with a domain based on
6653 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6654 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6655 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6658 complete_array_type (tree *ptype, tree initial_value, bool do_default)
6660 tree maxindex, type, main_type, elt, unqual_elt;
6661 int failure = 0, quals;
6662 hashval_t hashcode = 0;
6664 maxindex = size_zero_node;
6667 if (TREE_CODE (initial_value) == STRING_CST)
6670 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6671 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6673 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6675 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6677 if (VEC_empty (constructor_elt, v))
6681 maxindex = integer_minus_one_node;
6686 unsigned HOST_WIDE_INT cnt;
6687 constructor_elt *ce;
6689 if (VEC_index (constructor_elt, v, 0)->index)
6690 maxindex = fold_convert (sizetype,
6691 VEC_index (constructor_elt,
6693 curindex = maxindex;
6696 VEC_iterate (constructor_elt, v, cnt, ce);
6700 curindex = fold_convert (sizetype, ce->index);
6702 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6704 if (tree_int_cst_lt (maxindex, curindex))
6705 maxindex = curindex;
6711 /* Make an error message unless that happened already. */
6712 if (initial_value != error_mark_node)
6724 elt = TREE_TYPE (type);
6725 quals = TYPE_QUALS (strip_array_types (elt));
6729 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6731 /* Using build_distinct_type_copy and modifying things afterward instead
6732 of using build_array_type to create a new type preserves all of the
6733 TYPE_LANG_FLAG_? bits that the front end may have set. */
6734 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6735 TREE_TYPE (main_type) = unqual_elt;
6736 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6737 layout_type (main_type);
6739 /* Make sure we have the canonical MAIN_TYPE. */
6740 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
6741 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
6743 main_type = type_hash_canon (hashcode, main_type);
6748 type = c_build_qualified_type (main_type, quals);
6755 /* Used to help initialize the builtin-types.def table. When a type of
6756 the correct size doesn't exist, use error_mark_node instead of NULL.
6757 The later results in segfaults even when a decl using the type doesn't
6761 builtin_type_for_size (int size, bool unsignedp)
6763 tree type = lang_hooks.types.type_for_size (size, unsignedp);
6764 return type ? type : error_mark_node;
6767 /* A helper function for resolve_overloaded_builtin in resolving the
6768 overloaded __sync_ builtins. Returns a positive power of 2 if the
6769 first operand of PARAMS is a pointer to a supported data type.
6770 Returns 0 if an error is encountered. */
6773 sync_resolve_size (tree function, tree params)
6780 error ("too few arguments to function %qE", function);
6784 type = TREE_TYPE (TREE_VALUE (params));
6785 if (TREE_CODE (type) != POINTER_TYPE)
6788 type = TREE_TYPE (type);
6789 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6792 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6793 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6797 error ("incompatible type for argument %d of %qE", 1, function);
6801 /* A helper function for resolve_overloaded_builtin. Adds casts to
6802 PARAMS to make arguments match up with those of FUNCTION. Drops
6803 the variadic arguments at the end. Returns false if some error
6804 was encountered; true on success. */
6807 sync_resolve_params (tree orig_function, tree function, tree params)
6809 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6813 /* We've declared the implementation functions to use "volatile void *"
6814 as the pointer parameter, so we shouldn't get any complaints from the
6815 call to check_function_arguments what ever type the user used. */
6816 arg_types = TREE_CHAIN (arg_types);
6817 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6820 /* For the rest of the values, we need to cast these to FTYPE, so that we
6821 don't get warnings for passing pointer types, etc. */
6822 while (arg_types != void_list_node)
6826 params = TREE_CHAIN (params);
6829 error ("too few arguments to function %qE", orig_function);
6833 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6834 so that we get warnings for anything that doesn't match the pointer
6835 type. This isn't portable across the C and C++ front ends atm. */
6836 val = TREE_VALUE (params);
6837 val = convert (ptype, val);
6838 val = convert (TREE_VALUE (arg_types), val);
6839 TREE_VALUE (params) = val;
6841 arg_types = TREE_CHAIN (arg_types);
6845 /* The definition of these primitives is variadic, with the remaining
6846 being "an optional list of variables protected by the memory barrier".
6847 No clue what that's supposed to mean, precisely, but we consider all
6848 call-clobbered variables to be protected so we're safe. */
6849 TREE_CHAIN (params) = NULL;
6854 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6855 RESULT to make it match the type of the first pointer argument in
6859 sync_resolve_return (tree params, tree result)
6861 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6862 ptype = TYPE_MAIN_VARIANT (ptype);
6863 return convert (ptype, result);
6866 /* Some builtin functions are placeholders for other expressions. This
6867 function should be called immediately after parsing the call expression
6868 before surrounding code has committed to the type of the expression.
6870 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6871 PARAMS is the argument list for the call. The return value is non-null
6872 when expansion is complete, and null if normal processing should
6876 resolve_overloaded_builtin (tree function, tree params)
6878 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6879 switch (DECL_BUILT_IN_CLASS (function))
6881 case BUILT_IN_NORMAL:
6884 if (targetm.resolve_overloaded_builtin)
6885 return targetm.resolve_overloaded_builtin (function, params);
6892 /* Handle BUILT_IN_NORMAL here. */
6895 case BUILT_IN_FETCH_AND_ADD_N:
6896 case BUILT_IN_FETCH_AND_SUB_N:
6897 case BUILT_IN_FETCH_AND_OR_N:
6898 case BUILT_IN_FETCH_AND_AND_N:
6899 case BUILT_IN_FETCH_AND_XOR_N:
6900 case BUILT_IN_FETCH_AND_NAND_N:
6901 case BUILT_IN_ADD_AND_FETCH_N:
6902 case BUILT_IN_SUB_AND_FETCH_N:
6903 case BUILT_IN_OR_AND_FETCH_N:
6904 case BUILT_IN_AND_AND_FETCH_N:
6905 case BUILT_IN_XOR_AND_FETCH_N:
6906 case BUILT_IN_NAND_AND_FETCH_N:
6907 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6908 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6909 case BUILT_IN_LOCK_TEST_AND_SET_N:
6910 case BUILT_IN_LOCK_RELEASE_N:
6912 int n = sync_resolve_size (function, params);
6913 tree new_function, result;
6916 return error_mark_node;
6918 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6919 if (!sync_resolve_params (function, new_function, params))
6920 return error_mark_node;
6922 result = build_function_call (new_function, params);
6923 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6924 && orig_code != BUILT_IN_LOCK_RELEASE_N)
6925 result = sync_resolve_return (params, result);
6935 /* Ignoring their sign, return true if two scalar types are the same. */
6937 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6939 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6941 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6942 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6944 /* Equality works here because c_common_signed_type uses
6945 TYPE_MAIN_VARIANT. */
6946 return c_common_signed_type (t1)
6947 == c_common_signed_type (t2);
6950 /* Check for missing format attributes on function pointers. LTYPE is
6951 the new type or left-hand side type. RTYPE is the old type or
6952 right-hand side type. Returns TRUE if LTYPE is missing the desired
6956 check_missing_format_attribute (tree ltype, tree rtype)
6958 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6961 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6962 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6967 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6968 if (is_attribute_p ("format", TREE_PURPOSE (la)))
6976 /* Subscripting with type char is likely to lose on a machine where
6977 chars are signed. So warn on any machine, but optionally. Don't
6978 warn for unsigned char since that type is safe. Don't warn for
6979 signed char because anyone who uses that must have done so
6980 deliberately. Furthermore, we reduce the false positive load by
6981 warning only for non-constant value of type char. */
6984 warn_array_subscript_with_type_char (tree index)
6986 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6987 && TREE_CODE (index) != INTEGER_CST)
6988 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6991 /* Implement -Wparentheses for the unexpected C precedence rules, to
6992 cover cases like x + y << z which readers are likely to
6993 misinterpret. We have seen an expression in which CODE is a binary
6994 operator used to combine expressions headed by CODE_LEFT and
6995 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
6996 means that that side of the expression was not formed using a
6997 binary operator, or it was enclosed in parentheses. */
7000 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
7001 enum tree_code code_right)
7003 if (!warn_parentheses)
7006 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
7008 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7009 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7010 warning (OPT_Wparentheses,
7011 "suggest parentheses around + or - inside shift");
7014 if (code == TRUTH_ORIF_EXPR)
7016 if (code_left == TRUTH_ANDIF_EXPR
7017 || code_right == TRUTH_ANDIF_EXPR)
7018 warning (OPT_Wparentheses,
7019 "suggest parentheses around && within ||");
7022 if (code == BIT_IOR_EXPR)
7024 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
7025 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7026 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
7027 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7028 warning (OPT_Wparentheses,
7029 "suggest parentheses around arithmetic in operand of |");
7030 /* Check cases like x|y==z */
7031 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7032 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7033 warning (OPT_Wparentheses,
7034 "suggest parentheses around comparison in operand of |");
7037 if (code == BIT_XOR_EXPR)
7039 if (code_left == BIT_AND_EXPR
7040 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7041 || code_right == BIT_AND_EXPR
7042 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7043 warning (OPT_Wparentheses,
7044 "suggest parentheses around arithmetic in operand of ^");
7045 /* Check cases like x^y==z */
7046 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7047 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7048 warning (OPT_Wparentheses,
7049 "suggest parentheses around comparison in operand of ^");
7052 if (code == BIT_AND_EXPR)
7054 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7055 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7056 warning (OPT_Wparentheses,
7057 "suggest parentheses around + or - in operand of &");
7058 /* Check cases like x&y==z */
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 &");
7065 if (code == EQ_EXPR || code == NE_EXPR)
7067 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7068 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7069 warning (OPT_Wparentheses,
7070 "suggest parentheses around comparison in operand of %s",
7071 code == EQ_EXPR ? "==" : "!=");
7073 else if (TREE_CODE_CLASS (code) == tcc_comparison)
7075 if ((TREE_CODE_CLASS (code_left) == tcc_comparison
7076 && code_left != NE_EXPR && code_left != EQ_EXPR)
7077 || (TREE_CODE_CLASS (code_right) == tcc_comparison
7078 && code_right != NE_EXPR && code_right != EQ_EXPR))
7079 warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
7080 "have their mathematical meaning");
7084 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
7087 warn_for_unused_label (tree label)
7089 if (!TREE_USED (label))
7091 if (DECL_INITIAL (label))
7092 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
7094 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
7098 #ifndef TARGET_HAS_TARGETCM
7099 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
7102 /* Warn for division by zero according to the value of DIVISOR. */
7105 warn_for_div_by_zero (tree divisor)
7107 /* If DIVISOR is zero, and has integral type, issue a warning about
7108 division by zero. Do not issue a warning if DIVISOR has a
7109 floating-point type, since we consider 0.0/0.0 a valid way of
7110 generating a NaN. */
7111 if (skip_evaluation == 0 && integer_zerop (divisor))
7112 warning (OPT_Wdiv_by_zero, "division by zero");
7115 #include "gt-c-common.h"