1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 #include "tree-iterator.h"
47 #include "tree-mudflap.h"
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 /* Nonzero if we want to allow the use of experimental features that
409 are likely to become part of C++0x. */
413 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
414 initialization variables.
415 0: Old rules, set by -fno-for-scope.
416 2: New ISO rules, set by -ffor-scope.
417 1: Try to implement new ISO rules, but with backup compatibility
418 (and warnings). This is the default, for now. */
420 int flag_new_for_scope = 1;
422 /* Nonzero if we want to emit defined symbols with common-like linkage as
423 weak symbols where possible, in order to conform to C++ semantics.
424 Otherwise, emit them as local symbols. */
428 /* 0 means we want the preprocessor to not emit line directives for
429 the current working directory. 1 means we want it to do it. -1
430 means we should decide depending on whether debugging information
431 is being emitted or not. */
433 int flag_working_directory = -1;
435 /* Nonzero to use __cxa_atexit, rather than atexit, to register
436 destructors for local statics and global objects. '2' means it has been
437 set nonzero as a default, not by a command-line flag. */
439 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
441 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
442 code. '2' means it has not been set explicitly on the command line. */
444 int flag_use_cxa_get_exception_ptr = 2;
446 /* Nonzero means make the default pedwarns warnings instead of errors.
447 The value of this flag is ignored if -pedantic is specified. */
451 /* Nonzero means to implement standard semantics for exception
452 specifications, calling unexpected if an exception is thrown that
453 doesn't match the specification. Zero means to treat them as
454 assertions and optimize accordingly, but not check them. */
456 int flag_enforce_eh_specs = 1;
458 /* Nonzero means to generate thread-safe code for initializing local
461 int flag_threadsafe_statics = 1;
463 /* Nonzero means warn about implicit declarations. */
465 int warn_implicit = 1;
467 /* Maximum template instantiation depth. This limit is rather
468 arbitrary, but it exists to limit the time it takes to notice
469 infinite template instantiations. */
471 int max_tinst_depth = 500;
475 /* The elements of `ridpointers' are identifier nodes for the reserved
476 type names and storage classes. It is indexed by a RID_... value. */
479 tree (*make_fname_decl) (tree, int);
481 /* Nonzero means the expression being parsed will never be evaluated.
482 This is a count, since unevaluated expressions can nest. */
485 /* Information about how a function name is generated. */
488 tree *const decl; /* pointer to the VAR_DECL. */
489 const unsigned rid; /* RID number for the identifier. */
490 const int pretty; /* How pretty is it? */
493 /* The three ways of getting then name of the current function. */
495 const struct fname_var_t fname_vars[] =
497 /* C99 compliant __func__, must be first. */
498 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
499 /* GCC __FUNCTION__ compliant. */
500 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
501 /* GCC __PRETTY_FUNCTION__ compliant. */
502 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
506 static tree check_case_value (tree);
507 static bool check_case_bounds (tree, tree, tree *, tree *);
509 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
510 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
511 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
512 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
513 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
514 static tree handle_always_inline_attribute (tree *, tree, tree, int,
516 static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
518 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
519 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
520 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
521 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
523 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
524 static tree handle_transparent_union_attribute (tree *, tree, tree,
526 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
528 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
532 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
533 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
534 static tree handle_visibility_attribute (tree *, tree, tree, int,
536 static tree handle_tls_model_attribute (tree *, tree, tree, int,
538 static tree handle_no_instrument_function_attribute (tree *, tree,
540 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
541 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
544 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
545 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
546 static tree handle_deprecated_attribute (tree *, tree, tree, int,
548 static tree handle_vector_size_attribute (tree *, tree, tree, int,
550 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
551 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
552 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
553 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
555 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
557 static void check_function_nonnull (tree, tree);
558 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
559 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
560 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
561 static int resort_field_decl_cmp (const void *, const void *);
563 /* Table of machine-independent attributes common to all C-like languages. */
564 const struct attribute_spec c_common_attribute_table[] =
566 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
567 { "packed", 0, 0, false, false, false,
568 handle_packed_attribute },
569 { "nocommon", 0, 0, true, false, false,
570 handle_nocommon_attribute },
571 { "common", 0, 0, true, false, false,
572 handle_common_attribute },
573 /* FIXME: logically, noreturn attributes should be listed as
574 "false, true, true" and apply to function types. But implementing this
575 would require all the places in the compiler that use TREE_THIS_VOLATILE
576 on a decl to identify non-returning functions to be located and fixed
577 to check the function type instead. */
578 { "noreturn", 0, 0, true, false, false,
579 handle_noreturn_attribute },
580 { "volatile", 0, 0, true, false, false,
581 handle_noreturn_attribute },
582 { "noinline", 0, 0, true, false, false,
583 handle_noinline_attribute },
584 { "always_inline", 0, 0, true, false, false,
585 handle_always_inline_attribute },
586 { "gnu_inline", 0, 0, true, false, false,
587 handle_gnu_inline_attribute },
588 { "flatten", 0, 0, true, false, false,
589 handle_flatten_attribute },
590 { "used", 0, 0, true, false, false,
591 handle_used_attribute },
592 { "unused", 0, 0, false, false, false,
593 handle_unused_attribute },
594 { "externally_visible", 0, 0, true, false, false,
595 handle_externally_visible_attribute },
596 /* The same comments as for noreturn attributes apply to const ones. */
597 { "const", 0, 0, true, false, false,
598 handle_const_attribute },
599 { "transparent_union", 0, 0, false, false, false,
600 handle_transparent_union_attribute },
601 { "constructor", 0, 0, true, false, false,
602 handle_constructor_attribute },
603 { "destructor", 0, 0, true, false, false,
604 handle_destructor_attribute },
605 { "mode", 1, 1, false, true, false,
606 handle_mode_attribute },
607 { "section", 1, 1, true, false, false,
608 handle_section_attribute },
609 { "aligned", 0, 1, false, false, false,
610 handle_aligned_attribute },
611 { "weak", 0, 0, true, false, false,
612 handle_weak_attribute },
613 { "alias", 1, 1, true, false, false,
614 handle_alias_attribute },
615 { "weakref", 0, 1, true, false, false,
616 handle_weakref_attribute },
617 { "no_instrument_function", 0, 0, true, false, false,
618 handle_no_instrument_function_attribute },
619 { "malloc", 0, 0, true, false, false,
620 handle_malloc_attribute },
621 { "returns_twice", 0, 0, true, false, false,
622 handle_returns_twice_attribute },
623 { "no_stack_limit", 0, 0, true, false, false,
624 handle_no_limit_stack_attribute },
625 { "pure", 0, 0, true, false, false,
626 handle_pure_attribute },
627 /* For internal use (marking of builtins) only. The name contains space
628 to prevent its usage in source code. */
629 { "no vops", 0, 0, true, false, false,
630 handle_novops_attribute },
631 { "deprecated", 0, 0, false, false, false,
632 handle_deprecated_attribute },
633 { "vector_size", 1, 1, false, true, false,
634 handle_vector_size_attribute },
635 { "visibility", 1, 1, false, false, false,
636 handle_visibility_attribute },
637 { "tls_model", 1, 1, true, false, false,
638 handle_tls_model_attribute },
639 { "nonnull", 0, -1, false, true, true,
640 handle_nonnull_attribute },
641 { "nothrow", 0, 0, true, false, false,
642 handle_nothrow_attribute },
643 { "may_alias", 0, 0, false, true, false, NULL },
644 { "cleanup", 1, 1, true, false, false,
645 handle_cleanup_attribute },
646 { "warn_unused_result", 0, 0, false, true, true,
647 handle_warn_unused_result_attribute },
648 { "sentinel", 0, 1, false, true, true,
649 handle_sentinel_attribute },
650 { NULL, 0, 0, false, false, false, NULL }
653 /* Give the specifications for the format attributes, used by C and all
656 const struct attribute_spec c_common_format_attribute_table[] =
658 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
659 { "format", 3, 3, false, true, true,
660 handle_format_attribute },
661 { "format_arg", 1, 1, false, true, true,
662 handle_format_arg_attribute },
663 { NULL, 0, 0, false, false, false, NULL }
666 /* Push current bindings for the function name VAR_DECLS. */
669 start_fname_decls (void)
672 tree saved = NULL_TREE;
674 for (ix = 0; fname_vars[ix].decl; ix++)
676 tree decl = *fname_vars[ix].decl;
680 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
681 *fname_vars[ix].decl = NULL_TREE;
684 if (saved || saved_function_name_decls)
685 /* Normally they'll have been NULL, so only push if we've got a
686 stack, or they are non-NULL. */
687 saved_function_name_decls = tree_cons (saved, NULL_TREE,
688 saved_function_name_decls);
691 /* Finish up the current bindings, adding them into the current function's
692 statement tree. This must be done _before_ finish_stmt_tree is called.
693 If there is no current function, we must be at file scope and no statements
694 are involved. Pop the previous bindings. */
697 finish_fname_decls (void)
700 tree stmts = NULL_TREE;
701 tree stack = saved_function_name_decls;
703 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
704 append_to_statement_list (TREE_VALUE (stack), &stmts);
708 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
710 if (TREE_CODE (*bodyp) == BIND_EXPR)
711 bodyp = &BIND_EXPR_BODY (*bodyp);
713 append_to_statement_list_force (*bodyp, &stmts);
717 for (ix = 0; fname_vars[ix].decl; ix++)
718 *fname_vars[ix].decl = NULL_TREE;
722 /* We had saved values, restore them. */
725 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
727 tree decl = TREE_PURPOSE (saved);
728 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
730 *fname_vars[ix].decl = decl;
732 stack = TREE_CHAIN (stack);
734 saved_function_name_decls = stack;
737 /* Return the text name of the current function, suitably prettified
738 by PRETTY_P. Return string must be freed by caller. */
741 fname_as_string (int pretty_p)
743 const char *name = "top level";
753 if (current_function_decl)
754 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
756 if (c_lex_string_translate)
758 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
759 cpp_string cstr = { 0, 0 }, strname;
761 namep = XNEWVEC (char, len);
762 snprintf (namep, len, "\"%s\"", name);
763 strname.text = (unsigned char *) namep;
764 strname.len = len - 1;
766 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
769 return (char *) cstr.text;
773 namep = xstrdup (name);
778 /* Expand DECL if it declares an entity not handled by the
782 c_expand_decl (tree decl)
784 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
786 /* Let the back-end know about this variable. */
787 if (!anon_aggr_type_p (TREE_TYPE (decl)))
788 emit_local_var (decl);
790 expand_anon_union_decl (decl, NULL_TREE,
791 DECL_ANON_UNION_ELEMS (decl));
800 /* Return the VAR_DECL for a const char array naming the current
801 function. If the VAR_DECL has not yet been created, create it
802 now. RID indicates how it should be formatted and IDENTIFIER_NODE
803 ID is its name (unfortunately C and C++ hold the RID values of
804 keywords in different places, so we can't derive RID from ID in
805 this language independent code. */
808 fname_decl (unsigned int rid, tree id)
811 tree decl = NULL_TREE;
813 for (ix = 0; fname_vars[ix].decl; ix++)
814 if (fname_vars[ix].rid == rid)
817 decl = *fname_vars[ix].decl;
820 /* If a tree is built here, it would normally have the lineno of
821 the current statement. Later this tree will be moved to the
822 beginning of the function and this line number will be wrong.
823 To avoid this problem set the lineno to 0 here; that prevents
824 it from appearing in the RTL. */
826 location_t saved_location = input_location;
827 #ifdef USE_MAPPED_LOCATION
828 input_location = UNKNOWN_LOCATION;
833 stmts = push_stmt_list ();
834 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
835 stmts = pop_stmt_list (stmts);
836 if (!IS_EMPTY_STMT (stmts))
837 saved_function_name_decls
838 = tree_cons (decl, stmts, saved_function_name_decls);
839 *fname_vars[ix].decl = decl;
840 input_location = saved_location;
842 if (!ix && !current_function_decl)
843 pedwarn ("%qD is not defined outside of function scope", decl);
848 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
851 fix_string_type (tree value)
853 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
854 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
855 int length = TREE_STRING_LENGTH (value);
857 tree e_type, i_type, a_type;
859 /* Compute the number of elements, for the array type. */
860 nchars = wide_flag ? length / wchar_bytes : length;
862 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
863 limit in C++98 Annex B is very large (65536) and is not normative,
864 so we do not diagnose it (warn_overlength_strings is forced off
865 in c_common_post_options). */
866 if (warn_overlength_strings)
868 const int nchars_max = flag_isoc99 ? 4095 : 509;
869 const int relevant_std = flag_isoc99 ? 99 : 90;
870 if (nchars - 1 > nchars_max)
871 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
872 separate the %d from the 'C'. 'ISO' should not be
873 translated, but it may be moved after 'C%d' in languages
874 where modifiers follow nouns. */
875 pedwarn ("string length %qd is greater than the length %qd "
876 "ISO C%d compilers are required to support",
877 nchars - 1, nchars_max, relevant_std);
880 /* Create the array type for the string constant. The ISO C++
881 standard says that a string literal has type `const char[N]' or
882 `const wchar_t[N]'. We use the same logic when invoked as a C
883 front-end with -Wwrite-strings.
884 ??? We should change the type of an expression depending on the
885 state of a warning flag. We should just be warning -- see how
886 this is handled in the C++ front-end for the deprecated implicit
887 conversion from string literals to `char*' or `wchar_t*'.
889 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
890 array type being the unqualified version of that type.
891 Therefore, if we are constructing an array of const char, we must
892 construct the matching unqualified array type first. The C front
893 end does not require this, but it does no harm, so we do it
895 e_type = wide_flag ? wchar_type_node : char_type_node;
896 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
897 a_type = build_array_type (e_type, i_type);
898 if (c_dialect_cxx() || warn_write_strings)
899 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
901 TREE_TYPE (value) = a_type;
902 TREE_CONSTANT (value) = 1;
903 TREE_INVARIANT (value) = 1;
904 TREE_READONLY (value) = 1;
905 TREE_STATIC (value) = 1;
909 /* Print a warning if a constant expression had overflow in folding.
910 Invoke this function on every expression that the language
911 requires to be a constant expression.
912 Note the ANSI C standard says it is erroneous for a
913 constant expression to overflow. */
916 constant_expression_warning (tree value)
918 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
919 || TREE_CODE (value) == VECTOR_CST
920 || TREE_CODE (value) == COMPLEX_CST)
921 && TREE_OVERFLOW (value)
924 pedwarn ("overflow in constant expression");
927 /* Print a warning if an expression had overflow in folding and its
930 Invoke this function on every expression that
931 (1) appears in the source code, and
932 (2) is a constant expression that overflowed, and
933 (3) is not already checked by convert_and_check;
934 however, do not invoke this function on operands of explicit casts
935 or when the expression is the result of an operator and any operand
936 already overflowed. */
939 overflow_warning (tree value)
941 if (skip_evaluation) return;
943 switch (TREE_CODE (value))
946 warning (OPT_Woverflow, "integer overflow in expression");
950 warning (OPT_Woverflow, "floating point overflow in expression");
954 warning (OPT_Woverflow, "vector overflow in expression");
958 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
959 warning (OPT_Woverflow, "complex integer overflow in expression");
960 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
961 warning (OPT_Woverflow, "complex floating point overflow in expression");
969 /* Print a warning about casts that might indicate violation
970 of strict aliasing rules if -Wstrict-aliasing is used and
971 strict aliasing mode is in effect. OTYPE is the original
972 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
975 strict_aliasing_warning (tree otype, tree type, tree expr)
977 if (flag_strict_aliasing && warn_strict_aliasing
978 && POINTER_TYPE_P (type) && POINTER_TYPE_P (otype)
979 && TREE_CODE (expr) == ADDR_EXPR
980 && (DECL_P (TREE_OPERAND (expr, 0))
981 || handled_component_p (TREE_OPERAND (expr, 0)))
982 && !VOID_TYPE_P (TREE_TYPE (type)))
984 /* Casting the address of an object to non void pointer. Warn
985 if the cast breaks type based aliasing. */
986 if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
987 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
988 "might break strict-aliasing rules");
991 HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
992 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
994 if (!alias_sets_conflict_p (set1, set2))
995 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
996 "pointer will break strict-aliasing rules");
997 else if (warn_strict_aliasing > 1
998 && !alias_sets_might_conflict_p (set1, set2))
999 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1000 "pointer might break strict-aliasing rules");
1005 /* Print a warning about if (); or if () .. else; constructs
1006 via the special empty statement node that we create. INNER_THEN
1007 and INNER_ELSE are the statement lists of the if and the else
1011 empty_body_warning (tree inner_then, tree inner_else)
1013 if (warn_empty_body)
1015 if (TREE_CODE (inner_then) == STATEMENT_LIST
1016 && STATEMENT_LIST_TAIL (inner_then))
1017 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1019 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1020 && STATEMENT_LIST_TAIL (inner_else))
1021 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1023 if (IS_EMPTY_STMT (inner_then) && !inner_else)
1024 warning (OPT_Wempty_body, "%Hempty body in an if-statement",
1025 EXPR_LOCUS (inner_then));
1027 if (inner_else && IS_EMPTY_STMT (inner_else))
1028 warning (OPT_Wempty_body, "%Hempty body in an else-statement",
1029 EXPR_LOCUS (inner_else));
1033 /* Warn for unlikely, improbable, or stupid DECL declarations
1037 check_main_parameter_types (tree decl)
1042 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1043 args = TREE_CHAIN (args))
1045 tree type = args ? TREE_VALUE (args) : 0;
1047 if (type == void_type_node || type == error_mark_node )
1054 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1055 pedwarn ("first argument of %q+D should be %<int%>", decl);
1059 if (TREE_CODE (type) != POINTER_TYPE
1060 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1061 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1063 pedwarn ("second argument of %q+D should be %<char **%>",
1068 if (TREE_CODE (type) != POINTER_TYPE
1069 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1070 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1072 pedwarn ("third argument of %q+D should probably be "
1073 "%<char **%>", decl);
1078 /* It is intentional that this message does not mention the third
1079 argument because it's only mentioned in an appendix of the
1081 if (argct > 0 && (argct < 2 || argct > 3))
1082 pedwarn ("%q+D takes only zero or two arguments", decl);
1085 /* True if vector types T1 and T2 can be converted to each other
1086 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1087 can only be converted with -flax-vector-conversions yet that is not
1088 in effect, emit a note telling the user about that option if such
1089 a note has not previously been emitted. */
1091 vector_types_convertible_p (tree t1, tree t2, bool emit_lax_note)
1093 static bool emitted_lax_note = false;
1094 bool convertible_lax;
1096 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1097 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1101 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1102 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1103 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1104 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1105 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1107 if (!convertible_lax || flag_lax_vector_conversions)
1108 return convertible_lax;
1110 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1111 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
1114 if (emit_lax_note && !emitted_lax_note)
1116 emitted_lax_note = true;
1117 inform ("use -flax-vector-conversions to permit "
1118 "conversions between vectors with differing "
1119 "element types or numbers of subparts");
1125 /* Warns if the conversion of EXPR to TYPE may alter a value.
1126 This function is called from convert_and_check. */
1129 conversion_warning (tree type, tree expr)
1131 bool give_warning = false;
1133 unsigned int formal_prec = TYPE_PRECISION (type);
1135 if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST)
1137 /* Warn for real constant that is not an exact integer converted
1139 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1140 && TREE_CODE (type) == INTEGER_TYPE)
1142 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (TREE_TYPE (expr))))
1143 give_warning = true;
1145 /* Warn for an integer constant that does not fit into integer type. */
1146 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1147 && TREE_CODE (type) == INTEGER_TYPE
1148 && !int_fits_type_p (expr, type))
1150 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr)))
1151 warning (OPT_Wconversion,
1152 "negative integer implicitly converted to unsigned type");
1154 give_warning = true;
1156 else if (TREE_CODE (type) == REAL_TYPE)
1158 /* Warn for an integer constant that does not fit into real type. */
1159 if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE)
1161 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1162 if (!exact_real_truncate (TYPE_MODE (type), &a))
1163 give_warning = true;
1165 /* Warn for a real constant that does not fit into a smaller
1167 else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1168 && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1170 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1171 if (!exact_real_truncate (TYPE_MODE (type), &a))
1172 give_warning = true;
1177 warning (OPT_Wconversion,
1178 "conversion to %qT alters %qT constant value",
1179 type, TREE_TYPE (expr));
1181 else /* 'expr' is not a constant. */
1183 /* Warn for real types converted to integer types. */
1184 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1185 && TREE_CODE (type) == INTEGER_TYPE)
1186 give_warning = true;
1188 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1189 && TREE_CODE (type) == INTEGER_TYPE)
1191 /* Warn for integer types converted to smaller integer types. */
1192 if (formal_prec < TYPE_PRECISION (TREE_TYPE (expr))
1193 /* When they are the same width but different signedness,
1194 then the value may change. */
1195 || (formal_prec == TYPE_PRECISION (TREE_TYPE (expr))
1196 && TYPE_UNSIGNED (TREE_TYPE (expr)) != TYPE_UNSIGNED (type))
1197 /* Even when converted to a bigger type, if the type is
1198 unsigned but expr is signed, then negative values
1200 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr))))
1201 give_warning = true;
1204 /* Warn for integer types converted to real types if and only if
1205 all the range of values of the integer type cannot be
1206 represented by the real type. */
1207 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1208 && TREE_CODE (type) == REAL_TYPE)
1210 tree type_low_bound = TYPE_MIN_VALUE (TREE_TYPE (expr));
1211 tree type_high_bound = TYPE_MAX_VALUE (TREE_TYPE (expr));
1212 REAL_VALUE_TYPE real_low_bound = real_value_from_int_cst (0, type_low_bound);
1213 REAL_VALUE_TYPE real_high_bound = real_value_from_int_cst (0, type_high_bound);
1215 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1216 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1217 give_warning = true;
1220 /* Warn for real types converted to smaller real types. */
1221 else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1222 && TREE_CODE (type) == REAL_TYPE
1223 && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1224 give_warning = true;
1228 warning (OPT_Wconversion,
1229 "conversion to %qT from %qT may alter its value",
1230 type, TREE_TYPE (expr));
1234 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1235 Invoke this function on every expression that is converted implicitly,
1236 i.e. because of language rules and not because of an explicit cast. */
1239 convert_and_check (tree type, tree expr)
1243 if (TREE_TYPE (expr) == type)
1246 result = convert (type, expr);
1248 if (skip_evaluation)
1252 if (TREE_CODE (expr) == INTEGER_CST
1253 && (TREE_CODE (type) == INTEGER_TYPE
1254 || TREE_CODE (type) == ENUMERAL_TYPE)
1255 && !int_fits_type_p (expr, type))
1257 /* Do not diagnose overflow in a constant expression merely
1258 because a conversion overflowed. */
1259 if (TREE_OVERFLOW (result))
1260 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1262 if (TYPE_UNSIGNED (type))
1264 /* This detects cases like converting -129 or 256 to
1266 if (!int_fits_type_p (expr, c_common_signed_type (type)))
1267 warning (OPT_Woverflow,
1268 "large integer implicitly truncated to unsigned type");
1269 else if (warn_conversion)
1270 conversion_warning (type, expr);
1274 if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
1275 warning (OPT_Woverflow,
1276 "overflow in implicit constant conversion");
1277 /* No warning for converting 0x80000000 to int. */
1279 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1280 || TYPE_PRECISION (TREE_TYPE (expr))
1281 != TYPE_PRECISION (type)))
1282 warning (OPT_Woverflow,
1283 "overflow in implicit constant conversion");
1284 else if (warn_conversion)
1285 conversion_warning (type, expr);
1288 else if (TREE_CODE (result) == INTEGER_CST && TREE_OVERFLOW (result))
1289 warning (OPT_Woverflow,
1290 "overflow in implicit constant conversion");
1291 else if (warn_conversion)
1292 conversion_warning (type, expr);
1297 /* A node in a list that describes references to variables (EXPR), which are
1298 either read accesses if WRITER is zero, or write accesses, in which case
1299 WRITER is the parent of EXPR. */
1306 /* Used to implement a cache the results of a call to verify_tree. We only
1307 use this for SAVE_EXPRs. */
1310 struct tlist_cache *next;
1311 struct tlist *cache_before_sp;
1312 struct tlist *cache_after_sp;
1316 /* Obstack to use when allocating tlist structures, and corresponding
1318 static struct obstack tlist_obstack;
1319 static char *tlist_firstobj = 0;
1321 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1323 static struct tlist *warned_ids;
1324 /* SAVE_EXPRs need special treatment. We process them only once and then
1325 cache the results. */
1326 static struct tlist_cache *save_expr_cache;
1328 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1329 static void merge_tlist (struct tlist **, struct tlist *, int);
1330 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1331 static int warning_candidate_p (tree);
1332 static void warn_for_collisions (struct tlist *);
1333 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1334 static struct tlist *new_tlist (struct tlist *, tree, tree);
1336 /* Create a new struct tlist and fill in its fields. */
1337 static struct tlist *
1338 new_tlist (struct tlist *next, tree t, tree writer)
1341 l = XOBNEW (&tlist_obstack, struct tlist);
1348 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1349 is nonnull, we ignore any node we find which has a writer equal to it. */
1352 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1356 struct tlist *next = add->next;
1359 if (!exclude_writer || add->writer != exclude_writer)
1360 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1365 /* Merge the nodes of ADD into TO. This merging process is done so that for
1366 each variable that already exists in TO, no new node is added; however if
1367 there is a write access recorded in ADD, and an occurrence on TO is only
1368 a read access, then the occurrence in TO will be modified to record the
1372 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1374 struct tlist **end = to;
1377 end = &(*end)->next;
1383 struct tlist *next = add->next;
1385 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1386 if (tmp2->expr == add->expr)
1390 tmp2->writer = add->writer;
1394 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1395 end = &(*end)->next;
1402 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1403 references in list LIST conflict with it, excluding reads if ONLY writers
1407 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1412 /* Avoid duplicate warnings. */
1413 for (tmp = warned_ids; tmp; tmp = tmp->next)
1414 if (tmp->expr == written)
1419 if (list->expr == written
1420 && list->writer != writer
1421 && (!only_writes || list->writer)
1422 && DECL_NAME (list->expr))
1424 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1425 warning (0, "operation on %qE may be undefined", list->expr);
1431 /* Given a list LIST of references to variables, find whether any of these
1432 can cause conflicts due to missing sequence points. */
1435 warn_for_collisions (struct tlist *list)
1439 for (tmp = list; tmp; tmp = tmp->next)
1442 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1446 /* Return nonzero if X is a tree that can be verified by the sequence point
1449 warning_candidate_p (tree x)
1451 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1454 /* Walk the tree X, and record accesses to variables. If X is written by the
1455 parent tree, WRITER is the parent.
1456 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1457 expression or its only operand forces a sequence point, then everything up
1458 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1460 Once we return, we will have emitted warnings if any subexpression before
1461 such a sequence point could be undefined. On a higher level, however, the
1462 sequence point may not be relevant, and we'll merge the two lists.
1464 Example: (b++, a) + b;
1465 The call that processes the COMPOUND_EXPR will store the increment of B
1466 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1467 processes the PLUS_EXPR will need to merge the two lists so that
1468 eventually, all accesses end up on the same list (and we'll warn about the
1469 unordered subexpressions b++ and b.
1471 A note on merging. If we modify the former example so that our expression
1474 care must be taken not simply to add all three expressions into the final
1475 PNO_SP list. The function merge_tlist takes care of that by merging the
1476 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1477 way, so that no more than one access to B is recorded. */
1480 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1483 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1484 enum tree_code code;
1485 enum tree_code_class cl;
1487 /* X may be NULL if it is the operand of an empty statement expression
1493 code = TREE_CODE (x);
1494 cl = TREE_CODE_CLASS (code);
1496 if (warning_candidate_p (x))
1498 *pno_sp = new_tlist (*pno_sp, x, writer);
1508 case TRUTH_ANDIF_EXPR:
1509 case TRUTH_ORIF_EXPR:
1510 tmp_before = tmp_nosp = tmp_list3 = 0;
1511 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1512 warn_for_collisions (tmp_nosp);
1513 merge_tlist (pbefore_sp, tmp_before, 0);
1514 merge_tlist (pbefore_sp, tmp_nosp, 0);
1515 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1516 merge_tlist (pbefore_sp, tmp_list3, 0);
1520 tmp_before = tmp_list2 = 0;
1521 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1522 warn_for_collisions (tmp_list2);
1523 merge_tlist (pbefore_sp, tmp_before, 0);
1524 merge_tlist (pbefore_sp, tmp_list2, 1);
1526 tmp_list3 = tmp_nosp = 0;
1527 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1528 warn_for_collisions (tmp_nosp);
1529 merge_tlist (pbefore_sp, tmp_list3, 0);
1531 tmp_list3 = tmp_list2 = 0;
1532 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1533 warn_for_collisions (tmp_list2);
1534 merge_tlist (pbefore_sp, tmp_list3, 0);
1535 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1536 two first, to avoid warning for (a ? b++ : b++). */
1537 merge_tlist (&tmp_nosp, tmp_list2, 0);
1538 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1541 case PREDECREMENT_EXPR:
1542 case PREINCREMENT_EXPR:
1543 case POSTDECREMENT_EXPR:
1544 case POSTINCREMENT_EXPR:
1545 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1549 tmp_before = tmp_nosp = tmp_list3 = 0;
1550 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1551 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1552 /* Expressions inside the LHS are not ordered wrt. the sequence points
1553 in the RHS. Example:
1555 Despite the fact that the modification of "a" is in the before_sp
1556 list (tmp_before), it conflicts with the use of "a" in the LHS.
1557 We can handle this by adding the contents of tmp_list3
1558 to those of tmp_before, and redoing the collision warnings for that
1560 add_tlist (&tmp_before, tmp_list3, x, 1);
1561 warn_for_collisions (tmp_before);
1562 /* Exclude the LHS itself here; we first have to merge it into the
1563 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1564 didn't exclude the LHS, we'd get it twice, once as a read and once
1566 add_tlist (pno_sp, tmp_list3, x, 0);
1567 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1569 merge_tlist (pbefore_sp, tmp_before, 0);
1570 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1571 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1572 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1576 /* We need to warn about conflicts among arguments and conflicts between
1577 args and the function address. Side effects of the function address,
1578 however, are not ordered by the sequence point of the call. */
1579 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1580 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1581 if (TREE_OPERAND (x, 1))
1582 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1583 merge_tlist (&tmp_list3, tmp_list2, 0);
1584 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1585 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1586 warn_for_collisions (tmp_before);
1587 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1591 /* Scan all the list, e.g. indices of multi dimensional array. */
1594 tmp_before = tmp_nosp = 0;
1595 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1596 merge_tlist (&tmp_nosp, tmp_before, 0);
1597 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1604 struct tlist_cache *t;
1605 for (t = save_expr_cache; t; t = t->next)
1611 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1612 t->next = save_expr_cache;
1614 save_expr_cache = t;
1616 tmp_before = tmp_nosp = 0;
1617 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1618 warn_for_collisions (tmp_nosp);
1623 struct tlist *t = tmp_nosp;
1625 merge_tlist (&tmp_list3, t, 0);
1627 t->cache_before_sp = tmp_before;
1628 t->cache_after_sp = tmp_list3;
1630 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1631 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1636 /* For other expressions, simply recurse on their operands.
1637 Manual tail recursion for unary expressions.
1638 Other non-expressions need not be processed. */
1639 if (cl == tcc_unary)
1641 x = TREE_OPERAND (x, 0);
1645 else if (IS_EXPR_CODE_CLASS (cl))
1648 int max = TREE_CODE_LENGTH (TREE_CODE (x));
1649 for (lp = 0; lp < max; lp++)
1651 tmp_before = tmp_nosp = 0;
1652 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1653 merge_tlist (&tmp_nosp, tmp_before, 0);
1654 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1661 /* Try to warn for undefined behavior in EXPR due to missing sequence
1665 verify_sequence_points (tree expr)
1667 struct tlist *before_sp = 0, *after_sp = 0;
1670 save_expr_cache = 0;
1671 if (tlist_firstobj == 0)
1673 gcc_obstack_init (&tlist_obstack);
1674 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1677 verify_tree (expr, &before_sp, &after_sp, 0);
1678 warn_for_collisions (after_sp);
1679 obstack_free (&tlist_obstack, tlist_firstobj);
1682 /* Validate the expression after `case' and apply default promotions. */
1685 check_case_value (tree value)
1687 if (value == NULL_TREE)
1690 /* ??? Can we ever get nops here for a valid case value? We
1692 STRIP_TYPE_NOPS (value);
1693 /* In C++, the following is allowed:
1696 switch (...) { case i: ... }
1698 So, we try to reduce the VALUE to a constant that way. */
1699 if (c_dialect_cxx ())
1701 value = decl_constant_value (value);
1702 STRIP_TYPE_NOPS (value);
1703 value = fold (value);
1706 if (TREE_CODE (value) == INTEGER_CST)
1707 /* Promote char or short to int. */
1708 value = perform_integral_promotions (value);
1709 else if (value != error_mark_node)
1711 error ("case label does not reduce to an integer constant");
1712 value = error_mark_node;
1715 constant_expression_warning (value);
1720 /* See if the case values LOW and HIGH are in the range of the original
1721 type (i.e. before the default conversion to int) of the switch testing
1723 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1724 the type before promoting it. CASE_LOW_P is a pointer to the lower
1725 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1726 if the case is not a case range.
1727 The caller has to make sure that we are not called with NULL for
1728 CASE_LOW_P (i.e. the default case).
1729 Returns true if the case label is in range of ORIG_TYPE (saturated or
1730 untouched) or false if the label is out of range. */
1733 check_case_bounds (tree type, tree orig_type,
1734 tree *case_low_p, tree *case_high_p)
1736 tree min_value, max_value;
1737 tree case_low = *case_low_p;
1738 tree case_high = case_high_p ? *case_high_p : case_low;
1740 /* If there was a problem with the original type, do nothing. */
1741 if (orig_type == error_mark_node)
1744 min_value = TYPE_MIN_VALUE (orig_type);
1745 max_value = TYPE_MAX_VALUE (orig_type);
1747 /* Case label is less than minimum for type. */
1748 if (tree_int_cst_compare (case_low, min_value) < 0
1749 && tree_int_cst_compare (case_high, min_value) < 0)
1751 warning (0, "case label value is less than minimum value for type");
1755 /* Case value is greater than maximum for type. */
1756 if (tree_int_cst_compare (case_low, max_value) > 0
1757 && tree_int_cst_compare (case_high, max_value) > 0)
1759 warning (0, "case label value exceeds maximum value for type");
1763 /* Saturate lower case label value to minimum. */
1764 if (tree_int_cst_compare (case_high, min_value) >= 0
1765 && tree_int_cst_compare (case_low, min_value) < 0)
1767 warning (0, "lower value in case label range"
1768 " less than minimum value for type");
1769 case_low = min_value;
1772 /* Saturate upper case label value to maximum. */
1773 if (tree_int_cst_compare (case_low, max_value) <= 0
1774 && tree_int_cst_compare (case_high, max_value) > 0)
1776 warning (0, "upper value in case label range"
1777 " exceeds maximum value for type");
1778 case_high = max_value;
1781 if (*case_low_p != case_low)
1782 *case_low_p = convert (type, case_low);
1783 if (case_high_p && *case_high_p != case_high)
1784 *case_high_p = convert (type, case_high);
1789 /* Return an integer type with BITS bits of precision,
1790 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1793 c_common_type_for_size (unsigned int bits, int unsignedp)
1795 if (bits == TYPE_PRECISION (integer_type_node))
1796 return unsignedp ? unsigned_type_node : integer_type_node;
1798 if (bits == TYPE_PRECISION (signed_char_type_node))
1799 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1801 if (bits == TYPE_PRECISION (short_integer_type_node))
1802 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1804 if (bits == TYPE_PRECISION (long_integer_type_node))
1805 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1807 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1808 return (unsignedp ? long_long_unsigned_type_node
1809 : long_long_integer_type_node);
1811 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1812 return (unsignedp ? widest_unsigned_literal_type_node
1813 : widest_integer_literal_type_node);
1815 if (bits <= TYPE_PRECISION (intQI_type_node))
1816 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1818 if (bits <= TYPE_PRECISION (intHI_type_node))
1819 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1821 if (bits <= TYPE_PRECISION (intSI_type_node))
1822 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1824 if (bits <= TYPE_PRECISION (intDI_type_node))
1825 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1830 /* Used for communication between c_common_type_for_mode and
1831 c_register_builtin_type. */
1832 static GTY(()) tree registered_builtin_types;
1834 /* Return a data type that has machine mode MODE.
1835 If the mode is an integer,
1836 then UNSIGNEDP selects between signed and unsigned types. */
1839 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1843 if (mode == TYPE_MODE (integer_type_node))
1844 return unsignedp ? unsigned_type_node : integer_type_node;
1846 if (mode == TYPE_MODE (signed_char_type_node))
1847 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1849 if (mode == TYPE_MODE (short_integer_type_node))
1850 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1852 if (mode == TYPE_MODE (long_integer_type_node))
1853 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1855 if (mode == TYPE_MODE (long_long_integer_type_node))
1856 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1858 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1859 return unsignedp ? widest_unsigned_literal_type_node
1860 : widest_integer_literal_type_node;
1863 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1866 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1869 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1872 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1874 #if HOST_BITS_PER_WIDE_INT >= 64
1875 if (mode == TYPE_MODE (intTI_type_node))
1876 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1879 if (mode == TYPE_MODE (float_type_node))
1880 return float_type_node;
1882 if (mode == TYPE_MODE (double_type_node))
1883 return double_type_node;
1885 if (mode == TYPE_MODE (long_double_type_node))
1886 return long_double_type_node;
1888 if (mode == TYPE_MODE (void_type_node))
1889 return void_type_node;
1891 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1893 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1894 : make_signed_type (GET_MODE_PRECISION (mode)));
1896 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1898 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1899 : make_signed_type (GET_MODE_PRECISION (mode)));
1901 if (COMPLEX_MODE_P (mode))
1903 enum machine_mode inner_mode;
1906 if (mode == TYPE_MODE (complex_float_type_node))
1907 return complex_float_type_node;
1908 if (mode == TYPE_MODE (complex_double_type_node))
1909 return complex_double_type_node;
1910 if (mode == TYPE_MODE (complex_long_double_type_node))
1911 return complex_long_double_type_node;
1913 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1914 return complex_integer_type_node;
1916 inner_mode = GET_MODE_INNER (mode);
1917 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1918 if (inner_type != NULL_TREE)
1919 return build_complex_type (inner_type);
1921 else if (VECTOR_MODE_P (mode))
1923 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1924 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1925 if (inner_type != NULL_TREE)
1926 return build_vector_type_for_mode (inner_type, mode);
1929 if (mode == TYPE_MODE (dfloat32_type_node))
1930 return dfloat32_type_node;
1931 if (mode == TYPE_MODE (dfloat64_type_node))
1932 return dfloat64_type_node;
1933 if (mode == TYPE_MODE (dfloat128_type_node))
1934 return dfloat128_type_node;
1936 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1937 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1938 return TREE_VALUE (t);
1943 /* Return an unsigned type the same as TYPE in other respects. */
1945 c_common_unsigned_type (tree type)
1947 tree type1 = TYPE_MAIN_VARIANT (type);
1948 if (type1 == signed_char_type_node || type1 == char_type_node)
1949 return unsigned_char_type_node;
1950 if (type1 == integer_type_node)
1951 return unsigned_type_node;
1952 if (type1 == short_integer_type_node)
1953 return short_unsigned_type_node;
1954 if (type1 == long_integer_type_node)
1955 return long_unsigned_type_node;
1956 if (type1 == long_long_integer_type_node)
1957 return long_long_unsigned_type_node;
1958 if (type1 == widest_integer_literal_type_node)
1959 return widest_unsigned_literal_type_node;
1960 #if HOST_BITS_PER_WIDE_INT >= 64
1961 if (type1 == intTI_type_node)
1962 return unsigned_intTI_type_node;
1964 if (type1 == intDI_type_node)
1965 return unsigned_intDI_type_node;
1966 if (type1 == intSI_type_node)
1967 return unsigned_intSI_type_node;
1968 if (type1 == intHI_type_node)
1969 return unsigned_intHI_type_node;
1970 if (type1 == intQI_type_node)
1971 return unsigned_intQI_type_node;
1973 return c_common_signed_or_unsigned_type (1, type);
1976 /* Return a signed type the same as TYPE in other respects. */
1979 c_common_signed_type (tree type)
1981 tree type1 = TYPE_MAIN_VARIANT (type);
1982 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1983 return signed_char_type_node;
1984 if (type1 == unsigned_type_node)
1985 return integer_type_node;
1986 if (type1 == short_unsigned_type_node)
1987 return short_integer_type_node;
1988 if (type1 == long_unsigned_type_node)
1989 return long_integer_type_node;
1990 if (type1 == long_long_unsigned_type_node)
1991 return long_long_integer_type_node;
1992 if (type1 == widest_unsigned_literal_type_node)
1993 return widest_integer_literal_type_node;
1994 #if HOST_BITS_PER_WIDE_INT >= 64
1995 if (type1 == unsigned_intTI_type_node)
1996 return intTI_type_node;
1998 if (type1 == unsigned_intDI_type_node)
1999 return intDI_type_node;
2000 if (type1 == unsigned_intSI_type_node)
2001 return intSI_type_node;
2002 if (type1 == unsigned_intHI_type_node)
2003 return intHI_type_node;
2004 if (type1 == unsigned_intQI_type_node)
2005 return intQI_type_node;
2007 return c_common_signed_or_unsigned_type (0, type);
2010 /* Return a type the same as TYPE except unsigned or
2011 signed according to UNSIGNEDP. */
2014 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2016 if (!INTEGRAL_TYPE_P (type)
2017 || TYPE_UNSIGNED (type) == unsignedp)
2020 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2021 the precision; they have precision set to match their range, but
2022 may use a wider mode to match an ABI. If we change modes, we may
2023 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2024 the precision as well, so as to yield correct results for
2025 bit-field types. C++ does not have these separate bit-field
2026 types, and producing a signed or unsigned variant of an
2027 ENUMERAL_TYPE may cause other problems as well. */
2029 #define TYPE_OK(node) \
2030 (TYPE_MODE (type) == TYPE_MODE (node) \
2031 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
2032 if (TYPE_OK (signed_char_type_node))
2033 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2034 if (TYPE_OK (integer_type_node))
2035 return unsignedp ? unsigned_type_node : integer_type_node;
2036 if (TYPE_OK (short_integer_type_node))
2037 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2038 if (TYPE_OK (long_integer_type_node))
2039 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2040 if (TYPE_OK (long_long_integer_type_node))
2041 return (unsignedp ? long_long_unsigned_type_node
2042 : long_long_integer_type_node);
2043 if (TYPE_OK (widest_integer_literal_type_node))
2044 return (unsignedp ? widest_unsigned_literal_type_node
2045 : widest_integer_literal_type_node);
2047 #if HOST_BITS_PER_WIDE_INT >= 64
2048 if (TYPE_OK (intTI_type_node))
2049 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2051 if (TYPE_OK (intDI_type_node))
2052 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2053 if (TYPE_OK (intSI_type_node))
2054 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2055 if (TYPE_OK (intHI_type_node))
2056 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2057 if (TYPE_OK (intQI_type_node))
2058 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2061 if (c_dialect_cxx ())
2064 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2067 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2070 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2072 /* Extended integer types of the same width as a standard type have
2073 lesser rank, so those of the same width as int promote to int or
2074 unsigned int and are valid for printf formats expecting int or
2075 unsigned int. To avoid such special cases, avoid creating
2076 extended integer types for bit-fields if a standard integer type
2078 if (width == TYPE_PRECISION (integer_type_node))
2079 return unsignedp ? unsigned_type_node : integer_type_node;
2080 if (width == TYPE_PRECISION (signed_char_type_node))
2081 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2082 if (width == TYPE_PRECISION (short_integer_type_node))
2083 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2084 if (width == TYPE_PRECISION (long_integer_type_node))
2085 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2086 if (width == TYPE_PRECISION (long_long_integer_type_node))
2087 return (unsignedp ? long_long_unsigned_type_node
2088 : long_long_integer_type_node);
2089 return build_nonstandard_integer_type (width, unsignedp);
2092 /* The C version of the register_builtin_type langhook. */
2095 c_register_builtin_type (tree type, const char* name)
2099 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2100 DECL_ARTIFICIAL (decl) = 1;
2101 if (!TYPE_NAME (type))
2102 TYPE_NAME (type) = decl;
2105 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2109 /* Return the minimum number of bits needed to represent VALUE in a
2110 signed or unsigned type, UNSIGNEDP says which. */
2113 min_precision (tree value, int unsignedp)
2117 /* If the value is negative, compute its negative minus 1. The latter
2118 adjustment is because the absolute value of the largest negative value
2119 is one larger than the largest positive value. This is equivalent to
2120 a bit-wise negation, so use that operation instead. */
2122 if (tree_int_cst_sgn (value) < 0)
2123 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2125 /* Return the number of bits needed, taking into account the fact
2126 that we need one more bit for a signed than unsigned type. */
2128 if (integer_zerop (value))
2131 log = tree_floor_log2 (value);
2133 return log + 1 + !unsignedp;
2136 /* Print an error message for invalid operands to arith operation
2140 binary_op_error (enum tree_code code)
2147 opname = "+"; break;
2149 opname = "-"; break;
2151 opname = "*"; break;
2153 opname = "max"; break;
2155 opname = "min"; break;
2157 opname = "=="; break;
2159 opname = "!="; break;
2161 opname = "<="; break;
2163 opname = ">="; break;
2165 opname = "<"; break;
2167 opname = ">"; break;
2169 opname = "<<"; break;
2171 opname = ">>"; break;
2172 case TRUNC_MOD_EXPR:
2173 case FLOOR_MOD_EXPR:
2174 opname = "%"; break;
2175 case TRUNC_DIV_EXPR:
2176 case FLOOR_DIV_EXPR:
2177 opname = "/"; break;
2179 opname = "&"; break;
2181 opname = "|"; break;
2182 case TRUTH_ANDIF_EXPR:
2183 opname = "&&"; break;
2184 case TRUTH_ORIF_EXPR:
2185 opname = "||"; break;
2187 opname = "^"; break;
2191 error ("invalid operands to binary %s", opname);
2194 /* Subroutine of build_binary_op, used for comparison operations.
2195 See if the operands have both been converted from subword integer types
2196 and, if so, perhaps change them both back to their original type.
2197 This function is also responsible for converting the two operands
2198 to the proper common type for comparison.
2200 The arguments of this function are all pointers to local variables
2201 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2202 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2204 If this function returns nonzero, it means that the comparison has
2205 a constant value. What this function returns is an expression for
2209 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2210 enum tree_code *rescode_ptr)
2213 tree op0 = *op0_ptr;
2214 tree op1 = *op1_ptr;
2215 int unsignedp0, unsignedp1;
2217 tree primop0, primop1;
2218 enum tree_code code = *rescode_ptr;
2220 /* Throw away any conversions to wider types
2221 already present in the operands. */
2223 primop0 = get_narrower (op0, &unsignedp0);
2224 primop1 = get_narrower (op1, &unsignedp1);
2226 /* Handle the case that OP0 does not *contain* a conversion
2227 but it *requires* conversion to FINAL_TYPE. */
2229 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2230 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2231 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2232 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2234 /* If one of the operands must be floated, we cannot optimize. */
2235 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2236 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2238 /* If first arg is constant, swap the args (changing operation
2239 so value is preserved), for canonicalization. Don't do this if
2240 the second arg is 0. */
2242 if (TREE_CONSTANT (primop0)
2243 && !integer_zerop (primop1) && !real_zerop (primop1))
2246 int temi = unsignedp0;
2254 unsignedp0 = unsignedp1;
2277 *rescode_ptr = code;
2280 /* If comparing an integer against a constant more bits wide,
2281 maybe we can deduce a value of 1 or 0 independent of the data.
2282 Or else truncate the constant now
2283 rather than extend the variable at run time.
2285 This is only interesting if the constant is the wider arg.
2286 Also, it is not safe if the constant is unsigned and the
2287 variable arg is signed, since in this case the variable
2288 would be sign-extended and then regarded as unsigned.
2289 Our technique fails in this case because the lowest/highest
2290 possible unsigned results don't follow naturally from the
2291 lowest/highest possible values of the variable operand.
2292 For just EQ_EXPR and NE_EXPR there is another technique that
2293 could be used: see if the constant can be faithfully represented
2294 in the other operand's type, by truncating it and reextending it
2295 and see if that preserves the constant's value. */
2297 if (!real1 && !real2
2298 && TREE_CODE (primop1) == INTEGER_CST
2299 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2301 int min_gt, max_gt, min_lt, max_lt;
2302 tree maxval, minval;
2303 /* 1 if comparison is nominally unsigned. */
2304 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2307 type = c_common_signed_or_unsigned_type (unsignedp0,
2308 TREE_TYPE (primop0));
2310 maxval = TYPE_MAX_VALUE (type);
2311 minval = TYPE_MIN_VALUE (type);
2313 if (unsignedp && !unsignedp0)
2314 *restype_ptr = c_common_signed_type (*restype_ptr);
2316 if (TREE_TYPE (primop1) != *restype_ptr)
2318 /* Convert primop1 to target type, but do not introduce
2319 additional overflow. We know primop1 is an int_cst. */
2320 primop1 = force_fit_type_double (*restype_ptr,
2321 TREE_INT_CST_LOW (primop1),
2322 TREE_INT_CST_HIGH (primop1), 0,
2323 TREE_OVERFLOW (primop1));
2325 if (type != *restype_ptr)
2327 minval = convert (*restype_ptr, minval);
2328 maxval = convert (*restype_ptr, maxval);
2331 if (unsignedp && unsignedp0)
2333 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2334 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2335 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2336 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2340 min_gt = INT_CST_LT (primop1, minval);
2341 max_gt = INT_CST_LT (primop1, maxval);
2342 min_lt = INT_CST_LT (minval, primop1);
2343 max_lt = INT_CST_LT (maxval, primop1);
2347 /* This used to be a switch, but Genix compiler can't handle that. */
2348 if (code == NE_EXPR)
2350 if (max_lt || min_gt)
2351 val = truthvalue_true_node;
2353 else if (code == EQ_EXPR)
2355 if (max_lt || min_gt)
2356 val = truthvalue_false_node;
2358 else if (code == LT_EXPR)
2361 val = truthvalue_true_node;
2363 val = truthvalue_false_node;
2365 else if (code == GT_EXPR)
2368 val = truthvalue_true_node;
2370 val = truthvalue_false_node;
2372 else if (code == LE_EXPR)
2375 val = truthvalue_true_node;
2377 val = truthvalue_false_node;
2379 else if (code == GE_EXPR)
2382 val = truthvalue_true_node;
2384 val = truthvalue_false_node;
2387 /* If primop0 was sign-extended and unsigned comparison specd,
2388 we did a signed comparison above using the signed type bounds.
2389 But the comparison we output must be unsigned.
2391 Also, for inequalities, VAL is no good; but if the signed
2392 comparison had *any* fixed result, it follows that the
2393 unsigned comparison just tests the sign in reverse
2394 (positive values are LE, negative ones GE).
2395 So we can generate an unsigned comparison
2396 against an extreme value of the signed type. */
2398 if (unsignedp && !unsignedp0)
2405 primop1 = TYPE_MIN_VALUE (type);
2411 primop1 = TYPE_MAX_VALUE (type);
2418 type = c_common_unsigned_type (type);
2421 if (TREE_CODE (primop0) != INTEGER_CST)
2423 if (val == truthvalue_false_node)
2424 warning (0, "comparison is always false due to limited range of data type");
2425 if (val == truthvalue_true_node)
2426 warning (0, "comparison is always true due to limited range of data type");
2431 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2432 if (TREE_SIDE_EFFECTS (primop0))
2433 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2437 /* Value is not predetermined, but do the comparison
2438 in the type of the operand that is not constant.
2439 TYPE is already properly set. */
2442 /* If either arg is decimal float and the other is float, find the
2443 proper common type to use for comparison. */
2444 else if (real1 && real2
2445 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2446 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2447 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2449 else if (real1 && real2
2450 && (TYPE_PRECISION (TREE_TYPE (primop0))
2451 == TYPE_PRECISION (TREE_TYPE (primop1))))
2452 type = TREE_TYPE (primop0);
2454 /* If args' natural types are both narrower than nominal type
2455 and both extend in the same manner, compare them
2456 in the type of the wider arg.
2457 Otherwise must actually extend both to the nominal
2458 common type lest different ways of extending
2460 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2462 else if (unsignedp0 == unsignedp1 && real1 == real2
2463 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2464 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2466 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2467 type = c_common_signed_or_unsigned_type (unsignedp0
2468 || TYPE_UNSIGNED (*restype_ptr),
2470 /* Make sure shorter operand is extended the right way
2471 to match the longer operand. */
2473 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2474 TREE_TYPE (primop0)),
2477 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2478 TREE_TYPE (primop1)),
2483 /* Here we must do the comparison on the nominal type
2484 using the args exactly as we received them. */
2485 type = *restype_ptr;
2489 if (!real1 && !real2 && integer_zerop (primop1)
2490 && TYPE_UNSIGNED (*restype_ptr))
2496 /* All unsigned values are >= 0, so we warn if extra warnings
2497 are requested. However, if OP0 is a constant that is
2498 >= 0, the signedness of the comparison isn't an issue,
2499 so suppress the warning. */
2500 if (extra_warnings && !in_system_header
2501 && !(TREE_CODE (primop0) == INTEGER_CST
2502 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2504 warning (0, "comparison of unsigned expression >= 0 is always true");
2505 value = truthvalue_true_node;
2509 if (extra_warnings && !in_system_header
2510 && !(TREE_CODE (primop0) == INTEGER_CST
2511 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2513 warning (0, "comparison of unsigned expression < 0 is always false");
2514 value = truthvalue_false_node;
2523 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2524 if (TREE_SIDE_EFFECTS (primop0))
2525 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2532 *op0_ptr = convert (type, primop0);
2533 *op1_ptr = convert (type, primop1);
2535 *restype_ptr = truthvalue_type_node;
2540 /* Return a tree for the sum or difference (RESULTCODE says which)
2541 of pointer PTROP and integer INTOP. */
2544 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2548 /* The result is a pointer of the same type that is being added. */
2550 tree result_type = TREE_TYPE (ptrop);
2552 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2554 if (pedantic || warn_pointer_arith)
2555 pedwarn ("pointer of type %<void *%> used in arithmetic");
2556 size_exp = integer_one_node;
2558 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2560 if (pedantic || warn_pointer_arith)
2561 pedwarn ("pointer to a function used in arithmetic");
2562 size_exp = integer_one_node;
2564 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2566 if (pedantic || warn_pointer_arith)
2567 pedwarn ("pointer to member function used in arithmetic");
2568 size_exp = integer_one_node;
2571 size_exp = size_in_bytes (TREE_TYPE (result_type));
2573 /* We are manipulating pointer values, so we don't need to warn
2574 about relying on undefined signed overflow. We disable the
2575 warning here because we use integer types so fold won't know that
2576 they are really pointers. */
2577 fold_defer_overflow_warnings ();
2579 /* If what we are about to multiply by the size of the elements
2580 contains a constant term, apply distributive law
2581 and multiply that constant term separately.
2582 This helps produce common subexpressions. */
2584 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2585 && !TREE_CONSTANT (intop)
2586 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2587 && TREE_CONSTANT (size_exp)
2588 /* If the constant comes from pointer subtraction,
2589 skip this optimization--it would cause an error. */
2590 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2591 /* If the constant is unsigned, and smaller than the pointer size,
2592 then we must skip this optimization. This is because it could cause
2593 an overflow error if the constant is negative but INTOP is not. */
2594 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2595 || (TYPE_PRECISION (TREE_TYPE (intop))
2596 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2598 enum tree_code subcode = resultcode;
2599 tree int_type = TREE_TYPE (intop);
2600 if (TREE_CODE (intop) == MINUS_EXPR)
2601 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2602 /* Convert both subexpression types to the type of intop,
2603 because weird cases involving pointer arithmetic
2604 can result in a sum or difference with different type args. */
2605 ptrop = build_binary_op (subcode, ptrop,
2606 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2607 intop = convert (int_type, TREE_OPERAND (intop, 0));
2610 /* Convert the integer argument to a type the same size as sizetype
2611 so the multiply won't overflow spuriously. */
2613 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2614 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2615 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2616 TYPE_UNSIGNED (sizetype)), intop);
2618 /* Replace the integer argument with a suitable product by the object size.
2619 Do this multiplication as signed, then convert to the appropriate
2620 pointer type (actually unsigned integral). */
2622 intop = convert (result_type,
2623 build_binary_op (MULT_EXPR, intop,
2624 convert (TREE_TYPE (intop), size_exp), 1));
2626 /* Create the sum or difference. */
2627 ret = fold_build2 (resultcode, result_type, ptrop, intop);
2629 fold_undefer_and_ignore_overflow_warnings ();
2634 /* Return whether EXPR is a declaration whose address can never be
2638 decl_with_nonnull_addr_p (tree expr)
2640 return (DECL_P (expr)
2641 && (TREE_CODE (expr) == PARM_DECL
2642 || TREE_CODE (expr) == LABEL_DECL
2643 || !DECL_WEAK (expr)));
2646 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2647 or for an `if' or `while' statement or ?..: exp. It should already
2648 have been validated to be of suitable type; otherwise, a bad
2649 diagnostic may result.
2651 This preparation consists of taking the ordinary
2652 representation of an expression expr and producing a valid tree
2653 boolean expression describing whether expr is nonzero. We could
2654 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2655 but we optimize comparisons, &&, ||, and !.
2657 The resulting type should always be `truthvalue_type_node'. */
2660 c_common_truthvalue_conversion (tree expr)
2662 switch (TREE_CODE (expr))
2664 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2665 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2666 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2667 case ORDERED_EXPR: case UNORDERED_EXPR:
2668 if (TREE_TYPE (expr) == truthvalue_type_node)
2670 return build2 (TREE_CODE (expr), truthvalue_type_node,
2671 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2673 case TRUTH_ANDIF_EXPR:
2674 case TRUTH_ORIF_EXPR:
2675 case TRUTH_AND_EXPR:
2677 case TRUTH_XOR_EXPR:
2678 if (TREE_TYPE (expr) == truthvalue_type_node)
2680 return build2 (TREE_CODE (expr), truthvalue_type_node,
2681 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2682 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2684 case TRUTH_NOT_EXPR:
2685 if (TREE_TYPE (expr) == truthvalue_type_node)
2687 return build1 (TREE_CODE (expr), truthvalue_type_node,
2688 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2694 return integer_zerop (expr) ? truthvalue_false_node
2695 : truthvalue_true_node;
2698 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2699 ? truthvalue_true_node
2700 : truthvalue_false_node;
2703 expr = build_unary_op (ADDR_EXPR, expr, 0);
2708 tree inner = TREE_OPERAND (expr, 0);
2709 if (decl_with_nonnull_addr_p (inner))
2711 /* Common Ada/Pascal programmer's mistake. */
2712 warning (OPT_Walways_true,
2713 "the address of %qD will always evaluate as %<true%>",
2715 return truthvalue_true_node;
2718 /* If we still have a decl, it is possible for its address to
2719 be NULL, so we cannot optimize. */
2722 gcc_assert (DECL_WEAK (inner));
2726 if (TREE_SIDE_EFFECTS (inner))
2727 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2728 inner, truthvalue_true_node);
2730 return truthvalue_true_node;
2734 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2735 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2736 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2737 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2743 /* These don't change whether an object is nonzero or zero. */
2744 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2748 /* These don't change whether an object is zero or nonzero, but
2749 we can't ignore them if their second arg has side-effects. */
2750 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2751 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2752 TREE_OPERAND (expr, 1),
2753 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2755 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2758 /* Distribute the conversion into the arms of a COND_EXPR. */
2759 return fold_build3 (COND_EXPR, truthvalue_type_node,
2760 TREE_OPERAND (expr, 0),
2761 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2762 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2766 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2767 since that affects how `default_conversion' will behave. */
2768 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2769 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2771 /* If this is widening the argument, we can ignore it. */
2772 if (TYPE_PRECISION (TREE_TYPE (expr))
2773 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2774 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2778 if (!TREE_NO_WARNING (expr)
2779 && warn_parentheses)
2781 warning (OPT_Wparentheses,
2782 "suggest parentheses around assignment used as truth value");
2783 TREE_NO_WARNING (expr) = 1;
2791 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2793 tree t = save_expr (expr);
2794 return (build_binary_op
2795 ((TREE_SIDE_EFFECTS (expr)
2796 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2797 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2798 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2802 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2805 static void def_builtin_1 (enum built_in_function fncode,
2807 enum built_in_class fnclass,
2808 tree fntype, tree libtype,
2809 bool both_p, bool fallback_p, bool nonansi_p,
2810 tree fnattrs, bool implicit_p);
2812 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2813 down to the element type of an array. */
2816 c_build_qualified_type (tree type, int type_quals)
2818 if (type == error_mark_node)
2821 if (TREE_CODE (type) == ARRAY_TYPE)
2824 tree element_type = c_build_qualified_type (TREE_TYPE (type),
2827 /* See if we already have an identically qualified type. */
2828 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2830 if (TYPE_QUALS (strip_array_types (t)) == type_quals
2831 && TYPE_NAME (t) == TYPE_NAME (type)
2832 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2833 && attribute_list_equal (TYPE_ATTRIBUTES (t),
2834 TYPE_ATTRIBUTES (type)))
2839 t = build_variant_type_copy (type);
2840 TREE_TYPE (t) = element_type;
2845 /* A restrict-qualified pointer type must be a pointer to object or
2846 incomplete type. Note that the use of POINTER_TYPE_P also allows
2847 REFERENCE_TYPEs, which is appropriate for C++. */
2848 if ((type_quals & TYPE_QUAL_RESTRICT)
2849 && (!POINTER_TYPE_P (type)
2850 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2852 error ("invalid use of %<restrict%>");
2853 type_quals &= ~TYPE_QUAL_RESTRICT;
2856 return build_qualified_type (type, type_quals);
2859 /* Apply the TYPE_QUALS to the new DECL. */
2862 c_apply_type_quals_to_decl (int type_quals, tree decl)
2864 tree type = TREE_TYPE (decl);
2866 if (type == error_mark_node)
2869 if (((type_quals & TYPE_QUAL_CONST)
2870 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2871 /* An object declared 'const' is only readonly after it is
2872 initialized. We don't have any way of expressing this currently,
2873 so we need to be conservative and unset TREE_READONLY for types
2874 with constructors. Otherwise aliasing code will ignore stores in
2875 an inline constructor. */
2876 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2877 TREE_READONLY (decl) = 1;
2878 if (type_quals & TYPE_QUAL_VOLATILE)
2880 TREE_SIDE_EFFECTS (decl) = 1;
2881 TREE_THIS_VOLATILE (decl) = 1;
2883 if (type_quals & TYPE_QUAL_RESTRICT)
2885 while (type && TREE_CODE (type) == ARRAY_TYPE)
2886 /* Allow 'restrict' on arrays of pointers.
2887 FIXME currently we just ignore it. */
2888 type = TREE_TYPE (type);
2890 || !POINTER_TYPE_P (type)
2891 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2892 error ("invalid use of %<restrict%>");
2893 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2894 /* Indicate we need to make a unique alias set for this pointer.
2895 We can't do it here because it might be pointing to an
2897 DECL_POINTER_ALIAS_SET (decl) = -2;
2901 /* Hash function for the problem of multiple type definitions in
2902 different files. This must hash all types that will compare
2903 equal via comptypes to the same value. In practice it hashes
2904 on some of the simple stuff and leaves the details to comptypes. */
2907 c_type_hash (const void *p)
2913 switch (TREE_CODE (t))
2915 /* For pointers, hash on pointee type plus some swizzling. */
2917 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2918 /* Hash on number of elements and total size. */
2921 t2 = TYPE_VALUES (t);
2925 t2 = TYPE_FIELDS (t);
2927 case QUAL_UNION_TYPE:
2929 t2 = TYPE_FIELDS (t);
2933 t2 = TYPE_FIELDS (t);
2938 for (; t2; t2 = TREE_CHAIN (t2))
2940 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2941 return ((size << 24) | (i << shift));
2944 static GTY((param_is (union tree_node))) htab_t type_hash_table;
2946 /* Return the typed-based alias set for T, which may be an expression
2947 or a type. Return -1 if we don't do anything special. */
2950 c_common_get_alias_set (tree t)
2955 /* Permit type-punning when accessing a union, provided the access
2956 is directly through the union. For example, this code does not
2957 permit taking the address of a union member and then storing
2958 through it. Even the type-punning allowed here is a GCC
2959 extension, albeit a common and useful one; the C standard says
2960 that such accesses have implementation-defined behavior. */
2962 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2963 u = TREE_OPERAND (u, 0))
2964 if (TREE_CODE (u) == COMPONENT_REF
2965 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2968 /* That's all the expressions we handle specially. */
2972 /* The C standard guarantees that any object may be accessed via an
2973 lvalue that has character type. */
2974 if (t == char_type_node
2975 || t == signed_char_type_node
2976 || t == unsigned_char_type_node)
2979 /* If it has the may_alias attribute, it can alias anything. */
2980 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2983 /* The C standard specifically allows aliasing between signed and
2984 unsigned variants of the same type. We treat the signed
2985 variant as canonical. */
2986 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2988 tree t1 = c_common_signed_type (t);
2990 /* t1 == t can happen for boolean nodes which are always unsigned. */
2992 return get_alias_set (t1);
2994 else if (POINTER_TYPE_P (t))
2998 /* Unfortunately, there is no canonical form of a pointer type.
2999 In particular, if we have `typedef int I', then `int *', and
3000 `I *' are different types. So, we have to pick a canonical
3001 representative. We do this below.
3003 Technically, this approach is actually more conservative that
3004 it needs to be. In particular, `const int *' and `int *'
3005 should be in different alias sets, according to the C and C++
3006 standard, since their types are not the same, and so,
3007 technically, an `int **' and `const int **' cannot point at
3010 But, the standard is wrong. In particular, this code is
3015 const int* const* cipp = ipp;
3017 And, it doesn't make sense for that to be legal unless you
3018 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3019 the pointed-to types. This issue has been reported to the
3021 t1 = build_type_no_quals (t);
3023 return get_alias_set (t1);
3026 /* Handle the case of multiple type nodes referring to "the same" type,
3027 which occurs with IMA. These share an alias set. FIXME: Currently only
3028 C90 is handled. (In C99 type compatibility is not transitive, which
3029 complicates things mightily. The alias set splay trees can theoretically
3030 represent this, but insertion is tricky when you consider all the
3031 different orders things might arrive in.) */
3033 if (c_language != clk_c || flag_isoc99)
3036 /* Save time if there's only one input file. */
3037 if (num_in_fnames == 1)
3040 /* Pointers need special handling if they point to any type that
3041 needs special handling (below). */
3042 if (TREE_CODE (t) == POINTER_TYPE)
3045 /* Find bottom type under any nested POINTERs. */
3046 for (t2 = TREE_TYPE (t);
3047 TREE_CODE (t2) == POINTER_TYPE;
3048 t2 = TREE_TYPE (t2))
3050 if (TREE_CODE (t2) != RECORD_TYPE
3051 && TREE_CODE (t2) != ENUMERAL_TYPE
3052 && TREE_CODE (t2) != QUAL_UNION_TYPE
3053 && TREE_CODE (t2) != UNION_TYPE)
3055 if (TYPE_SIZE (t2) == 0)
3058 /* These are the only cases that need special handling. */
3059 if (TREE_CODE (t) != RECORD_TYPE
3060 && TREE_CODE (t) != ENUMERAL_TYPE
3061 && TREE_CODE (t) != QUAL_UNION_TYPE
3062 && TREE_CODE (t) != UNION_TYPE
3063 && TREE_CODE (t) != POINTER_TYPE)
3066 if (TYPE_SIZE (t) == 0)
3069 /* Look up t in hash table. Only one of the compatible types within each
3070 alias set is recorded in the table. */
3071 if (!type_hash_table)
3072 type_hash_table = htab_create_ggc (1021, c_type_hash,
3073 (htab_eq) lang_hooks.types_compatible_p,
3075 slot = htab_find_slot (type_hash_table, t, INSERT);
3078 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3079 return TYPE_ALIAS_SET ((tree)*slot);
3082 /* Our caller will assign and record (in t) a new alias set; all we need
3083 to do is remember t in the hash table. */
3089 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3090 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3091 flag controls whether we should diagnose possibly ill-formed
3092 constructs or not. */
3095 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3097 const char *op_name;
3099 enum tree_code type_code = TREE_CODE (type);
3101 op_name = is_sizeof ? "sizeof" : "__alignof__";
3103 if (type_code == FUNCTION_TYPE)
3107 if (complain && (pedantic || warn_pointer_arith))
3108 pedwarn ("invalid application of %<sizeof%> to a function type");
3109 value = size_one_node;
3112 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3114 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3116 if (type_code == VOID_TYPE
3117 && complain && (pedantic || warn_pointer_arith))
3118 pedwarn ("invalid application of %qs to a void type", op_name);
3119 value = size_one_node;
3121 else if (!COMPLETE_TYPE_P (type))
3124 error ("invalid application of %qs to incomplete type %qT ",
3126 value = size_zero_node;
3131 /* Convert in case a char is more than one unit. */
3132 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3133 size_int (TYPE_PRECISION (char_type_node)
3136 value = size_int (TYPE_ALIGN_UNIT (type));
3139 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3140 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3141 never happen. However, this node should really have type
3142 `size_t', which is just a typedef for an ordinary integer type. */
3143 value = fold_convert (size_type_node, value);
3144 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3149 /* Implement the __alignof keyword: Return the minimum required
3150 alignment of EXPR, measured in bytes. For VAR_DECL's and
3151 FIELD_DECL's return DECL_ALIGN (which can be set from an
3152 "aligned" __attribute__ specification). */
3155 c_alignof_expr (tree expr)
3159 if (TREE_CODE (expr) == VAR_DECL)
3160 t = size_int (DECL_ALIGN_UNIT (expr));
3162 else if (TREE_CODE (expr) == COMPONENT_REF
3163 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3165 error ("%<__alignof%> applied to a bit-field");
3168 else if (TREE_CODE (expr) == COMPONENT_REF
3169 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3170 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3172 else if (TREE_CODE (expr) == INDIRECT_REF)
3174 tree t = TREE_OPERAND (expr, 0);
3176 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3178 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3179 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3183 t = TREE_OPERAND (t, 0);
3184 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3185 if (thisalign > bestalign)
3186 best = t, bestalign = thisalign;
3188 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3191 return c_alignof (TREE_TYPE (expr));
3193 return fold_convert (size_type_node, t);
3196 /* Handle C and C++ default attributes. */
3198 enum built_in_attribute
3200 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3201 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3202 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3203 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3204 #include "builtin-attrs.def"
3205 #undef DEF_ATTR_NULL_TREE
3207 #undef DEF_ATTR_IDENT
3208 #undef DEF_ATTR_TREE_LIST
3212 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3214 static void c_init_attributes (void);
3218 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3219 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3220 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3221 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3222 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3223 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3224 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3225 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3226 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3227 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3228 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3229 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3230 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3231 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3232 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3234 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3235 #include "builtin-types.def"
3236 #undef DEF_PRIMITIVE_TYPE
3237 #undef DEF_FUNCTION_TYPE_0
3238 #undef DEF_FUNCTION_TYPE_1
3239 #undef DEF_FUNCTION_TYPE_2
3240 #undef DEF_FUNCTION_TYPE_3
3241 #undef DEF_FUNCTION_TYPE_4
3242 #undef DEF_FUNCTION_TYPE_5
3243 #undef DEF_FUNCTION_TYPE_6
3244 #undef DEF_FUNCTION_TYPE_7
3245 #undef DEF_FUNCTION_TYPE_VAR_0
3246 #undef DEF_FUNCTION_TYPE_VAR_1
3247 #undef DEF_FUNCTION_TYPE_VAR_2
3248 #undef DEF_FUNCTION_TYPE_VAR_3
3249 #undef DEF_FUNCTION_TYPE_VAR_4
3250 #undef DEF_FUNCTION_TYPE_VAR_5
3251 #undef DEF_POINTER_TYPE
3255 typedef enum c_builtin_type builtin_type;
3257 /* A temporary array for c_common_nodes_and_builtins. Used in
3258 communication with def_fn_type. */
3259 static tree builtin_types[(int) BT_LAST + 1];
3261 /* A helper function for c_common_nodes_and_builtins. Build function type
3262 for DEF with return type RET and N arguments. If VAR is true, then the
3263 function should be variadic after those N arguments.
3265 Takes special care not to ICE if any of the types involved are
3266 error_mark_node, which indicates that said type is not in fact available
3267 (see builtin_type_for_size). In which case the function type as a whole
3268 should be error_mark_node. */
3271 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3273 tree args = NULL, t;
3278 for (i = 0; i < n; ++i)
3280 builtin_type a = va_arg (list, builtin_type);
3281 t = builtin_types[a];
3282 if (t == error_mark_node)
3284 args = tree_cons (NULL_TREE, t, args);
3288 args = nreverse (args);
3290 args = chainon (args, void_list_node);
3292 t = builtin_types[ret];
3293 if (t == error_mark_node)
3295 t = build_function_type (t, args);
3298 builtin_types[def] = t;
3301 /* Build builtin functions common to both C and C++ language
3305 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3307 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3308 builtin_types[ENUM] = VALUE;
3309 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3310 def_fn_type (ENUM, RETURN, 0, 0);
3311 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3312 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3313 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3314 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3315 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3316 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3317 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3318 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3319 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3320 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3321 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3323 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3324 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3326 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3327 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3328 def_fn_type (ENUM, RETURN, 1, 0);
3329 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3330 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3331 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3332 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3333 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3334 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3335 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3336 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3337 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3338 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3339 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3340 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3342 #include "builtin-types.def"
3344 #undef DEF_PRIMITIVE_TYPE
3345 #undef DEF_FUNCTION_TYPE_1
3346 #undef DEF_FUNCTION_TYPE_2
3347 #undef DEF_FUNCTION_TYPE_3
3348 #undef DEF_FUNCTION_TYPE_4
3349 #undef DEF_FUNCTION_TYPE_5
3350 #undef DEF_FUNCTION_TYPE_6
3351 #undef DEF_FUNCTION_TYPE_VAR_0
3352 #undef DEF_FUNCTION_TYPE_VAR_1
3353 #undef DEF_FUNCTION_TYPE_VAR_2
3354 #undef DEF_FUNCTION_TYPE_VAR_3
3355 #undef DEF_FUNCTION_TYPE_VAR_4
3356 #undef DEF_FUNCTION_TYPE_VAR_5
3357 #undef DEF_POINTER_TYPE
3358 builtin_types[(int) BT_LAST] = NULL_TREE;
3360 c_init_attributes ();
3362 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3363 NONANSI_P, ATTRS, IMPLICIT, COND) \
3365 def_builtin_1 (ENUM, NAME, CLASS, \
3366 builtin_types[(int) TYPE], \
3367 builtin_types[(int) LIBTYPE], \
3368 BOTH_P, FALLBACK_P, NONANSI_P, \
3369 built_in_attributes[(int) ATTRS], IMPLICIT);
3370 #include "builtins.def"
3373 build_common_builtin_nodes ();
3375 targetm.init_builtins ();
3380 /* Build tree nodes and builtin functions common to both C and C++ language
3384 c_common_nodes_and_builtins (void)
3386 int wchar_type_size;
3387 tree array_domain_type;
3388 tree va_list_ref_type_node;
3389 tree va_list_arg_type_node;
3391 /* Define `int' and `char' first so that dbx will output them first. */
3392 record_builtin_type (RID_INT, NULL, integer_type_node);
3393 record_builtin_type (RID_CHAR, "char", char_type_node);
3395 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3396 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3397 but not C. Are the conditionals here needed? */
3398 if (c_dialect_cxx ())
3399 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3400 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3401 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3402 record_builtin_type (RID_MAX, "long unsigned int",
3403 long_unsigned_type_node);
3404 if (c_dialect_cxx ())
3405 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3406 record_builtin_type (RID_MAX, "long long int",
3407 long_long_integer_type_node);
3408 record_builtin_type (RID_MAX, "long long unsigned int",
3409 long_long_unsigned_type_node);
3410 if (c_dialect_cxx ())
3411 record_builtin_type (RID_MAX, "long long unsigned",
3412 long_long_unsigned_type_node);
3413 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3414 record_builtin_type (RID_MAX, "short unsigned int",
3415 short_unsigned_type_node);
3416 if (c_dialect_cxx ())
3417 record_builtin_type (RID_MAX, "unsigned short",
3418 short_unsigned_type_node);
3420 /* Define both `signed char' and `unsigned char'. */
3421 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3422 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3424 /* These are types that c_common_type_for_size and
3425 c_common_type_for_mode use. */
3426 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3428 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3430 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3432 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3434 #if HOST_BITS_PER_WIDE_INT >= 64
3435 if (targetm.scalar_mode_supported_p (TImode))
3436 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3437 get_identifier ("__int128_t"),
3440 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3441 unsigned_intQI_type_node));
3442 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3443 unsigned_intHI_type_node));
3444 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3445 unsigned_intSI_type_node));
3446 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3447 unsigned_intDI_type_node));
3448 #if HOST_BITS_PER_WIDE_INT >= 64
3449 if (targetm.scalar_mode_supported_p (TImode))
3450 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3451 get_identifier ("__uint128_t"),
3452 unsigned_intTI_type_node));
3455 /* Create the widest literal types. */
3456 widest_integer_literal_type_node
3457 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3458 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3459 widest_integer_literal_type_node));
3461 widest_unsigned_literal_type_node
3462 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3463 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3464 widest_unsigned_literal_type_node));
3466 /* `unsigned long' is the standard type for sizeof.
3467 Note that stddef.h uses `unsigned long',
3468 and this must agree, even if long and int are the same size. */
3470 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3471 signed_size_type_node = c_common_signed_type (size_type_node);
3472 set_sizetype (size_type_node);
3475 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3477 build_common_tree_nodes_2 (flag_short_double);
3479 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3480 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3481 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3483 /* Only supported decimal floating point extension if the target
3484 actually supports underlying modes. */
3485 if (targetm.scalar_mode_supported_p (SDmode)
3486 && targetm.scalar_mode_supported_p (DDmode)
3487 && targetm.scalar_mode_supported_p (TDmode))
3489 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3490 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3491 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3494 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3495 get_identifier ("complex int"),
3496 complex_integer_type_node));
3497 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3498 get_identifier ("complex float"),
3499 complex_float_type_node));
3500 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3501 get_identifier ("complex double"),
3502 complex_double_type_node));
3503 lang_hooks.decls.pushdecl
3504 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3505 complex_long_double_type_node));
3507 if (c_dialect_cxx ())
3508 /* For C++, make fileptr_type_node a distinct void * type until
3509 FILE type is defined. */
3510 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3512 record_builtin_type (RID_VOID, NULL, void_type_node);
3514 /* Set the TYPE_NAME for any variants that were built before
3515 record_builtin_type gave names to the built-in types. */
3517 tree void_name = TYPE_NAME (void_type_node);
3518 TYPE_NAME (void_type_node) = NULL_TREE;
3519 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
3521 TYPE_NAME (void_type_node) = void_name;
3524 /* This node must not be shared. */
3525 void_zero_node = make_node (INTEGER_CST);
3526 TREE_TYPE (void_zero_node) = void_type_node;
3528 void_list_node = build_void_list_node ();
3530 /* Make a type to be the domain of a few array types
3531 whose domains don't really matter.
3532 200 is small enough that it always fits in size_t
3533 and large enough that it can hold most function names for the
3534 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3535 array_domain_type = build_index_type (size_int (200));
3537 /* Make a type for arrays of characters.
3538 With luck nothing will ever really depend on the length of this
3540 char_array_type_node
3541 = build_array_type (char_type_node, array_domain_type);
3543 /* Likewise for arrays of ints. */
3545 = build_array_type (integer_type_node, array_domain_type);
3547 string_type_node = build_pointer_type (char_type_node);
3548 const_string_type_node
3549 = build_pointer_type (build_qualified_type
3550 (char_type_node, TYPE_QUAL_CONST));
3552 /* This is special for C++ so functions can be overloaded. */
3553 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3554 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3555 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3556 if (c_dialect_cxx ())
3558 if (TYPE_UNSIGNED (wchar_type_node))
3559 wchar_type_node = make_unsigned_type (wchar_type_size);
3561 wchar_type_node = make_signed_type (wchar_type_size);
3562 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3566 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3567 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3570 /* This is for wide string constants. */
3571 wchar_array_type_node
3572 = build_array_type (wchar_type_node, array_domain_type);
3575 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3578 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3580 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3582 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3584 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3585 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3587 lang_hooks.decls.pushdecl
3588 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3589 va_list_type_node));
3591 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3593 va_list_arg_type_node = va_list_ref_type_node =
3594 build_pointer_type (TREE_TYPE (va_list_type_node));
3598 va_list_arg_type_node = va_list_type_node;
3599 va_list_ref_type_node = build_reference_type (va_list_type_node);
3602 if (!flag_preprocess_only)
3603 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
3605 main_identifier_node = get_identifier ("main");
3607 /* Create the built-in __null node. It is important that this is
3609 null_node = make_node (INTEGER_CST);
3610 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3612 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3613 memset (builtin_types, 0, sizeof (builtin_types));
3616 /* Look up the function in built_in_decls that corresponds to DECL
3617 and set ASMSPEC as its user assembler name. DECL must be a
3618 function decl that declares a builtin. */
3621 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3624 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3625 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3628 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3629 set_user_assembler_name (builtin, asmspec);
3630 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3631 init_block_move_fn (asmspec);
3632 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3633 init_block_clear_fn (asmspec);
3636 /* The number of named compound-literals generated thus far. */
3637 static GTY(()) int compound_literal_number;
3639 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3642 set_compound_literal_name (tree decl)
3645 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3646 compound_literal_number);
3647 compound_literal_number++;
3648 DECL_NAME (decl) = get_identifier (name);
3652 build_va_arg (tree expr, tree type)
3654 return build1 (VA_ARG_EXPR, type, expr);
3658 /* Linked list of disabled built-in functions. */
3660 typedef struct disabled_builtin
3663 struct disabled_builtin *next;
3665 static disabled_builtin *disabled_builtins = NULL;
3667 static bool builtin_function_disabled_p (const char *);
3669 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3670 begins with "__builtin_", give an error. */
3673 disable_builtin_function (const char *name)
3675 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3676 error ("cannot disable built-in function %qs", name);
3679 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3680 new_disabled_builtin->name = name;
3681 new_disabled_builtin->next = disabled_builtins;
3682 disabled_builtins = new_disabled_builtin;
3687 /* Return true if the built-in function NAME has been disabled, false
3691 builtin_function_disabled_p (const char *name)
3693 disabled_builtin *p;
3694 for (p = disabled_builtins; p != NULL; p = p->next)
3696 if (strcmp (name, p->name) == 0)
3703 /* Worker for DEF_BUILTIN.
3704 Possibly define a builtin function with one or two names.
3705 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3706 nonansi_p and flag_no_nonansi_builtin. */
3709 def_builtin_1 (enum built_in_function fncode,
3711 enum built_in_class fnclass,
3712 tree fntype, tree libtype,
3713 bool both_p, bool fallback_p, bool nonansi_p,
3714 tree fnattrs, bool implicit_p)
3717 const char *libname;
3719 if (fntype == error_mark_node)
3722 gcc_assert ((!both_p && !fallback_p)
3723 || !strncmp (name, "__builtin_",
3724 strlen ("__builtin_")));
3726 libname = name + strlen ("__builtin_");
3727 decl = add_builtin_function (name, fntype, fncode, fnclass,
3728 (fallback_p ? libname : NULL),
3731 && !flag_no_builtin && !builtin_function_disabled_p (libname)
3732 && !(nonansi_p && flag_no_nonansi_builtin))
3733 add_builtin_function (libname, libtype, fncode, fnclass,
3736 built_in_decls[(int) fncode] = decl;
3738 implicit_built_in_decls[(int) fncode] = decl;
3741 /* Nonzero if the type T promotes to int. This is (nearly) the
3742 integral promotions defined in ISO C99 6.3.1.1/2. */
3745 c_promoting_integer_type_p (tree t)
3747 switch (TREE_CODE (t))
3750 return (TYPE_MAIN_VARIANT (t) == char_type_node
3751 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3752 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3753 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3754 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3755 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3758 /* ??? Technically all enumerations not larger than an int
3759 promote to an int. But this is used along code paths
3760 that only want to notice a size change. */
3761 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3771 /* Return 1 if PARMS specifies a fixed number of parameters
3772 and none of their types is affected by default promotions. */
3775 self_promoting_args_p (tree parms)
3778 for (t = parms; t; t = TREE_CHAIN (t))
3780 tree type = TREE_VALUE (t);
3782 if (type == error_mark_node)
3785 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3791 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3794 if (c_promoting_integer_type_p (type))
3800 /* Recursively examines the array elements of TYPE, until a non-array
3801 element type is found. */
3804 strip_array_types (tree type)
3806 while (TREE_CODE (type) == ARRAY_TYPE)
3807 type = TREE_TYPE (type);
3812 /* Recursively remove any '*' or '&' operator from TYPE. */
3814 strip_pointer_operator (tree t)
3816 while (POINTER_TYPE_P (t))
3821 /* Used to compare case labels. K1 and K2 are actually tree nodes
3822 representing case labels, or NULL_TREE for a `default' label.
3823 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3824 K2, and 0 if K1 and K2 are equal. */
3827 case_compare (splay_tree_key k1, splay_tree_key k2)
3829 /* Consider a NULL key (such as arises with a `default' label) to be
3830 smaller than anything else. */
3836 return tree_int_cst_compare ((tree) k1, (tree) k2);
3839 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3840 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3841 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3842 case label was declared using the usual C/C++ syntax, rather than
3843 the GNU case range extension. CASES is a tree containing all the
3844 case ranges processed so far; COND is the condition for the
3845 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3846 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3849 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3850 tree low_value, tree high_value)
3855 splay_tree_node node;
3857 /* Create the LABEL_DECL itself. */
3858 label = create_artificial_label ();
3860 /* If there was an error processing the switch condition, bail now
3861 before we get more confused. */
3862 if (!cond || cond == error_mark_node)
3865 if ((low_value && TREE_TYPE (low_value)
3866 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3867 || (high_value && TREE_TYPE (high_value)
3868 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3870 error ("pointers are not permitted as case values");
3874 /* Case ranges are a GNU extension. */
3875 if (high_value && pedantic)
3876 pedwarn ("range expressions in switch statements are non-standard");
3878 type = TREE_TYPE (cond);
3881 low_value = check_case_value (low_value);
3882 low_value = convert_and_check (type, low_value);
3883 if (low_value == error_mark_node)
3888 high_value = check_case_value (high_value);
3889 high_value = convert_and_check (type, high_value);
3890 if (high_value == error_mark_node)
3894 if (low_value && high_value)
3896 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3897 really a case range, even though it was written that way.
3898 Remove the HIGH_VALUE to simplify later processing. */
3899 if (tree_int_cst_equal (low_value, high_value))
3900 high_value = NULL_TREE;
3901 else if (!tree_int_cst_lt (low_value, high_value))
3902 warning (0, "empty range specified");
3905 /* See if the case is in range of the type of the original testing
3906 expression. If both low_value and high_value are out of range,
3907 don't insert the case label and return NULL_TREE. */
3909 && !check_case_bounds (type, orig_type,
3910 &low_value, high_value ? &high_value : NULL))
3913 /* Look up the LOW_VALUE in the table of case labels we already
3915 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3916 /* If there was not an exact match, check for overlapping ranges.
3917 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3918 that's a `default' label and the only overlap is an exact match. */
3919 if (!node && (low_value || high_value))
3921 splay_tree_node low_bound;
3922 splay_tree_node high_bound;
3924 /* Even though there wasn't an exact match, there might be an
3925 overlap between this case range and another case range.
3926 Since we've (inductively) not allowed any overlapping case
3927 ranges, we simply need to find the greatest low case label
3928 that is smaller that LOW_VALUE, and the smallest low case
3929 label that is greater than LOW_VALUE. If there is an overlap
3930 it will occur in one of these two ranges. */
3931 low_bound = splay_tree_predecessor (cases,
3932 (splay_tree_key) low_value);
3933 high_bound = splay_tree_successor (cases,
3934 (splay_tree_key) low_value);
3936 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3937 the LOW_VALUE, so there is no need to check unless the
3938 LOW_BOUND is in fact itself a case range. */
3940 && CASE_HIGH ((tree) low_bound->value)
3941 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3944 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3945 range is bigger than the low end of the current range, so we
3946 are only interested if the current range is a real range, and
3947 not an ordinary case label. */
3950 && (tree_int_cst_compare ((tree) high_bound->key,
3955 /* If there was an overlap, issue an error. */
3958 tree duplicate = CASE_LABEL ((tree) node->value);
3962 error ("duplicate (or overlapping) case value");
3963 error ("%Jthis is the first entry overlapping that value", duplicate);
3967 error ("duplicate case value") ;
3968 error ("%Jpreviously used here", duplicate);
3972 error ("multiple default labels in one switch");
3973 error ("%Jthis is the first default label", duplicate);
3978 /* Add a CASE_LABEL to the statement-tree. */
3979 case_label = add_stmt (build_case_label (low_value, high_value, label));
3980 /* Register this case label in the splay tree. */
3981 splay_tree_insert (cases,
3982 (splay_tree_key) low_value,
3983 (splay_tree_value) case_label);
3988 /* Add a label so that the back-end doesn't think that the beginning of
3989 the switch is unreachable. Note that we do not add a case label, as
3990 that just leads to duplicates and thence to failure later on. */
3993 tree t = create_artificial_label ();
3994 add_stmt (build_stmt (LABEL_EXPR, t));
3996 return error_mark_node;
3999 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4000 Used to verify that case values match up with enumerator values. */
4003 match_case_to_enum_1 (tree key, tree type, tree label)
4005 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4007 /* ??? Not working too hard to print the double-word value.
4008 Should perhaps be done with %lwd in the diagnostic routines? */
4009 if (TREE_INT_CST_HIGH (key) == 0)
4010 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4011 TREE_INT_CST_LOW (key));
4012 else if (!TYPE_UNSIGNED (type)
4013 && TREE_INT_CST_HIGH (key) == -1
4014 && TREE_INT_CST_LOW (key) != 0)
4015 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4016 -TREE_INT_CST_LOW (key));
4018 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4019 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
4021 if (TYPE_NAME (type) == 0)
4022 warning (0, "%Jcase value %qs not in enumerated type",
4023 CASE_LABEL (label), buf);
4025 warning (0, "%Jcase value %qs not in enumerated type %qT",
4026 CASE_LABEL (label), buf, type);
4029 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4030 Used to verify that case values match up with enumerator values. */
4033 match_case_to_enum (splay_tree_node node, void *data)
4035 tree label = (tree) node->value;
4036 tree type = (tree) data;
4038 /* Skip default case. */
4039 if (!CASE_LOW (label))
4042 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4043 when we did our enum->case scan. Reset our scratch bit after. */
4044 if (!CASE_LOW_SEEN (label))
4045 match_case_to_enum_1 (CASE_LOW (label), type, label);
4047 CASE_LOW_SEEN (label) = 0;
4049 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4050 not set, that means that CASE_HIGH did not appear when we did our
4051 enum->case scan. Reset our scratch bit after. */
4052 if (CASE_HIGH (label))
4054 if (!CASE_HIGH_SEEN (label))
4055 match_case_to_enum_1 (CASE_HIGH (label), type, label);
4057 CASE_HIGH_SEEN (label) = 0;
4063 /* Handle -Wswitch*. Called from the front end after parsing the
4064 switch construct. */
4065 /* ??? Should probably be somewhere generic, since other languages
4066 besides C and C++ would want this. At the moment, however, C/C++
4067 are the only tree-ssa languages that support enumerations at all,
4068 so the point is moot. */
4071 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4072 tree type, tree cond)
4074 splay_tree_node default_node;
4075 splay_tree_node node;
4078 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4081 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4083 warning (OPT_Wswitch_default, "%Hswitch missing default case",
4086 /* From here on, we only care about about enumerated types. */
4087 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4090 /* If the switch expression was an enumerated type, check that
4091 exactly all enumeration literals are covered by the cases.
4092 The check is made when -Wswitch was specified and there is no
4093 default case, or when -Wswitch-enum was specified. */
4095 if (!warn_switch_enum
4096 && !(warn_switch && !default_node))
4099 /* Clearing COND if it is not an integer constant simplifies
4100 the tests inside the loop below. */
4101 if (TREE_CODE (cond) != INTEGER_CST)
4104 /* The time complexity here is O(N*lg(N)) worst case, but for the
4105 common case of monotonically increasing enumerators, it is
4106 O(N), since the nature of the splay tree will keep the next
4107 element adjacent to the root at all times. */
4109 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4111 tree value = TREE_VALUE (chain);
4112 node = splay_tree_lookup (cases, (splay_tree_key) value);
4115 /* Mark the CASE_LOW part of the case entry as seen. */
4116 tree label = (tree) node->value;
4117 CASE_LOW_SEEN (label) = 1;
4121 /* Even though there wasn't an exact match, there might be a
4122 case range which includes the enumator's value. */
4123 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4124 if (node && CASE_HIGH ((tree) node->value))
4126 tree label = (tree) node->value;
4127 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4130 /* If we match the upper bound exactly, mark the CASE_HIGH
4131 part of the case entry as seen. */
4133 CASE_HIGH_SEEN (label) = 1;
4138 /* We've now determined that this enumerated literal isn't
4139 handled by the case labels of the switch statement. */
4141 /* If the switch expression is a constant, we only really care
4142 about whether that constant is handled by the switch. */
4143 if (cond && tree_int_cst_compare (cond, value))
4146 warning (0, "%Henumeration value %qE not handled in switch",
4147 &switch_location, TREE_PURPOSE (chain));
4150 /* Warn if there are case expressions that don't correspond to
4151 enumerators. This can occur since C and C++ don't enforce
4152 type-checking of assignments to enumeration variables.
4154 The time complexity here is now always O(N) worst case, since
4155 we should have marked both the lower bound and upper bound of
4156 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4157 above. This scan also resets those fields. */
4158 splay_tree_foreach (cases, match_case_to_enum, type);
4161 /* Finish an expression taking the address of LABEL (an
4162 IDENTIFIER_NODE). Returns an expression for the address. */
4165 finish_label_address_expr (tree label)
4170 pedwarn ("taking the address of a label is non-standard");
4172 if (label == error_mark_node)
4173 return error_mark_node;
4175 label = lookup_label (label);
4176 if (label == NULL_TREE)
4177 result = null_pointer_node;
4180 TREE_USED (label) = 1;
4181 result = build1 (ADDR_EXPR, ptr_type_node, label);
4182 /* The current function in not necessarily uninlinable.
4183 Computed gotos are incompatible with inlining, but the value
4184 here could be used only in a diagnostic, for example. */
4190 /* Hook used by expand_expr to expand language-specific tree codes. */
4191 /* The only things that should go here are bits needed to expand
4192 constant initializers. Everything else should be handled by the
4193 gimplification routines. */
4196 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4197 int modifier /* Actually enum_modifier. */,
4200 switch (TREE_CODE (exp))
4202 case COMPOUND_LITERAL_EXPR:
4204 /* Initialize the anonymous variable declared in the compound
4205 literal, then return the variable. */
4206 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4207 emit_local_var (decl);
4208 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4216 /* Hook used by staticp to handle language-specific tree codes. */
4219 c_staticp (tree exp)
4221 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4222 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4227 /* Given a boolean expression ARG, return a tree representing an increment
4228 or decrement (as indicated by CODE) of ARG. The front end must check for
4229 invalid cases (e.g., decrement in C++). */
4231 boolean_increment (enum tree_code code, tree arg)
4234 tree true_res = boolean_true_node;
4236 arg = stabilize_reference (arg);
4239 case PREINCREMENT_EXPR:
4240 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4242 case POSTINCREMENT_EXPR:
4243 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4244 arg = save_expr (arg);
4245 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4246 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4248 case PREDECREMENT_EXPR:
4249 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4250 invert_truthvalue (arg));
4252 case POSTDECREMENT_EXPR:
4253 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4254 invert_truthvalue (arg));
4255 arg = save_expr (arg);
4256 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4257 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4262 TREE_SIDE_EFFECTS (val) = 1;
4266 /* Built-in macros for stddef.h, that require macros defined in this
4269 c_stddef_cpp_builtins(void)
4271 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4272 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4273 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4274 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4275 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4276 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4280 c_init_attributes (void)
4282 /* Fill in the built_in_attributes array. */
4283 #define DEF_ATTR_NULL_TREE(ENUM) \
4284 built_in_attributes[(int) ENUM] = NULL_TREE;
4285 #define DEF_ATTR_INT(ENUM, VALUE) \
4286 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4287 #define DEF_ATTR_IDENT(ENUM, STRING) \
4288 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4289 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4290 built_in_attributes[(int) ENUM] \
4291 = tree_cons (built_in_attributes[(int) PURPOSE], \
4292 built_in_attributes[(int) VALUE], \
4293 built_in_attributes[(int) CHAIN]);
4294 #include "builtin-attrs.def"
4295 #undef DEF_ATTR_NULL_TREE
4297 #undef DEF_ATTR_IDENT
4298 #undef DEF_ATTR_TREE_LIST
4301 /* Attribute handlers common to C front ends. */
4303 /* Handle a "packed" attribute; arguments as in
4304 struct attribute_spec.handler. */
4307 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4308 int flags, bool *no_add_attrs)
4312 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4313 *node = build_variant_type_copy (*node);
4314 TYPE_PACKED (*node) = 1;
4316 else if (TREE_CODE (*node) == FIELD_DECL)
4318 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4319 warning (OPT_Wattributes,
4320 "%qE attribute ignored for field of type %qT",
4321 name, TREE_TYPE (*node));
4323 DECL_PACKED (*node) = 1;
4325 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4326 used for DECL_REGISTER. It wouldn't mean anything anyway.
4327 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4328 that changes what the typedef is typing. */
4331 warning (OPT_Wattributes, "%qE attribute ignored", name);
4332 *no_add_attrs = true;
4338 /* Handle a "nocommon" attribute; arguments as in
4339 struct attribute_spec.handler. */
4342 handle_nocommon_attribute (tree *node, tree name,
4343 tree ARG_UNUSED (args),
4344 int ARG_UNUSED (flags), bool *no_add_attrs)
4346 if (TREE_CODE (*node) == VAR_DECL)
4347 DECL_COMMON (*node) = 0;
4350 warning (OPT_Wattributes, "%qE attribute ignored", name);
4351 *no_add_attrs = true;
4357 /* Handle a "common" attribute; arguments as in
4358 struct attribute_spec.handler. */
4361 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4362 int ARG_UNUSED (flags), bool *no_add_attrs)
4364 if (TREE_CODE (*node) == VAR_DECL)
4365 DECL_COMMON (*node) = 1;
4368 warning (OPT_Wattributes, "%qE attribute ignored", name);
4369 *no_add_attrs = true;
4375 /* Handle a "noreturn" attribute; arguments as in
4376 struct attribute_spec.handler. */
4379 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4380 int ARG_UNUSED (flags), bool *no_add_attrs)
4382 tree type = TREE_TYPE (*node);
4384 /* See FIXME comment in c_common_attribute_table. */
4385 if (TREE_CODE (*node) == FUNCTION_DECL)
4386 TREE_THIS_VOLATILE (*node) = 1;
4387 else if (TREE_CODE (type) == POINTER_TYPE
4388 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4390 = build_pointer_type
4391 (build_type_variant (TREE_TYPE (type),
4392 TYPE_READONLY (TREE_TYPE (type)), 1));
4395 warning (OPT_Wattributes, "%qE attribute ignored", name);
4396 *no_add_attrs = true;
4402 /* Handle a "noinline" attribute; arguments as in
4403 struct attribute_spec.handler. */
4406 handle_noinline_attribute (tree *node, tree name,
4407 tree ARG_UNUSED (args),
4408 int ARG_UNUSED (flags), bool *no_add_attrs)
4410 if (TREE_CODE (*node) == FUNCTION_DECL)
4411 DECL_UNINLINABLE (*node) = 1;
4414 warning (OPT_Wattributes, "%qE attribute ignored", name);
4415 *no_add_attrs = true;
4421 /* Handle a "always_inline" attribute; arguments as in
4422 struct attribute_spec.handler. */
4425 handle_always_inline_attribute (tree *node, tree name,
4426 tree ARG_UNUSED (args),
4427 int ARG_UNUSED (flags),
4430 if (TREE_CODE (*node) == FUNCTION_DECL)
4432 /* Do nothing else, just set the attribute. We'll get at
4433 it later with lookup_attribute. */
4437 warning (OPT_Wattributes, "%qE attribute ignored", name);
4438 *no_add_attrs = true;
4444 /* Handle a "gnu_inline" attribute; arguments as in
4445 struct attribute_spec.handler. */
4448 handle_gnu_inline_attribute (tree *node, tree name,
4449 tree ARG_UNUSED (args),
4450 int ARG_UNUSED (flags),
4453 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4455 /* Do nothing else, just set the attribute. We'll get at
4456 it later with lookup_attribute. */
4460 warning (OPT_Wattributes, "%qE attribute ignored", name);
4461 *no_add_attrs = true;
4467 /* Handle a "flatten" attribute; arguments as in
4468 struct attribute_spec.handler. */
4471 handle_flatten_attribute (tree *node, tree name,
4472 tree args ATTRIBUTE_UNUSED,
4473 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4475 if (TREE_CODE (*node) == FUNCTION_DECL)
4476 /* Do nothing else, just set the attribute. We'll get at
4477 it later with lookup_attribute. */
4481 warning (OPT_Wattributes, "%qE attribute ignored", name);
4482 *no_add_attrs = true;
4489 /* Handle a "used" attribute; arguments as in
4490 struct attribute_spec.handler. */
4493 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4494 int ARG_UNUSED (flags), bool *no_add_attrs)
4498 if (TREE_CODE (node) == FUNCTION_DECL
4499 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4501 TREE_USED (node) = 1;
4502 DECL_PRESERVE_P (node) = 1;
4506 warning (OPT_Wattributes, "%qE attribute ignored", name);
4507 *no_add_attrs = true;
4513 /* Handle a "unused" attribute; arguments as in
4514 struct attribute_spec.handler. */
4517 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4518 int flags, bool *no_add_attrs)
4524 if (TREE_CODE (decl) == PARM_DECL
4525 || TREE_CODE (decl) == VAR_DECL
4526 || TREE_CODE (decl) == FUNCTION_DECL
4527 || TREE_CODE (decl) == LABEL_DECL
4528 || TREE_CODE (decl) == TYPE_DECL)
4529 TREE_USED (decl) = 1;
4532 warning (OPT_Wattributes, "%qE attribute ignored", name);
4533 *no_add_attrs = true;
4538 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4539 *node = build_variant_type_copy (*node);
4540 TREE_USED (*node) = 1;
4546 /* Handle a "externally_visible" attribute; arguments as in
4547 struct attribute_spec.handler. */
4550 handle_externally_visible_attribute (tree *pnode, tree name,
4551 tree ARG_UNUSED (args),
4552 int ARG_UNUSED (flags),
4557 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4559 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4560 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4562 warning (OPT_Wattributes,
4563 "%qE attribute have effect only on public objects", name);
4564 *no_add_attrs = true;
4569 warning (OPT_Wattributes, "%qE attribute ignored", name);
4570 *no_add_attrs = true;
4576 /* Handle a "const" attribute; arguments as in
4577 struct attribute_spec.handler. */
4580 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4581 int ARG_UNUSED (flags), bool *no_add_attrs)
4583 tree type = TREE_TYPE (*node);
4585 /* See FIXME comment on noreturn in c_common_attribute_table. */
4586 if (TREE_CODE (*node) == FUNCTION_DECL)
4587 TREE_READONLY (*node) = 1;
4588 else if (TREE_CODE (type) == POINTER_TYPE
4589 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4591 = build_pointer_type
4592 (build_type_variant (TREE_TYPE (type), 1,
4593 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4596 warning (OPT_Wattributes, "%qE attribute ignored", name);
4597 *no_add_attrs = true;
4603 /* Handle a "transparent_union" attribute; arguments as in
4604 struct attribute_spec.handler. */
4607 handle_transparent_union_attribute (tree *node, tree name,
4608 tree ARG_UNUSED (args), int flags,
4613 *no_add_attrs = true;
4617 if (TREE_CODE (*node) != TYPE_DECL)
4619 node = &TREE_TYPE (*node);
4622 else if (TYPE_P (*node))
4627 if (TREE_CODE (type) == UNION_TYPE)
4629 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4630 the code in finish_struct. */
4631 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4633 if (TYPE_FIELDS (type) == NULL_TREE
4634 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4637 /* A type variant isn't good enough, since we don't a cast
4638 to such a type removed as a no-op. */
4639 *node = type = build_duplicate_type (type);
4642 TYPE_TRANSPARENT_UNION (type) = 1;
4647 warning (OPT_Wattributes, "%qE attribute ignored", name);
4651 /* Handle a "constructor" attribute; arguments as in
4652 struct attribute_spec.handler. */
4655 handle_constructor_attribute (tree *node, tree name,
4656 tree ARG_UNUSED (args),
4657 int ARG_UNUSED (flags),
4661 tree type = TREE_TYPE (decl);
4663 if (TREE_CODE (decl) == FUNCTION_DECL
4664 && TREE_CODE (type) == FUNCTION_TYPE
4665 && decl_function_context (decl) == 0)
4667 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4668 TREE_USED (decl) = 1;
4672 warning (OPT_Wattributes, "%qE attribute ignored", name);
4673 *no_add_attrs = true;
4679 /* Handle a "destructor" attribute; arguments as in
4680 struct attribute_spec.handler. */
4683 handle_destructor_attribute (tree *node, tree name,
4684 tree ARG_UNUSED (args),
4685 int ARG_UNUSED (flags),
4689 tree type = TREE_TYPE (decl);
4691 if (TREE_CODE (decl) == FUNCTION_DECL
4692 && TREE_CODE (type) == FUNCTION_TYPE
4693 && decl_function_context (decl) == 0)
4695 DECL_STATIC_DESTRUCTOR (decl) = 1;
4696 TREE_USED (decl) = 1;
4700 warning (OPT_Wattributes, "%qE attribute ignored", name);
4701 *no_add_attrs = true;
4707 /* Handle a "mode" attribute; arguments as in
4708 struct attribute_spec.handler. */
4711 handle_mode_attribute (tree *node, tree name, tree args,
4712 int ARG_UNUSED (flags), bool *no_add_attrs)
4716 *no_add_attrs = true;
4718 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4719 warning (OPT_Wattributes, "%qE attribute ignored", name);
4723 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4724 int len = strlen (p);
4725 enum machine_mode mode = VOIDmode;
4729 if (len > 4 && p[0] == '_' && p[1] == '_'
4730 && p[len - 1] == '_' && p[len - 2] == '_')
4732 char *newp = (char *) alloca (len - 1);
4734 strcpy (newp, &p[2]);
4735 newp[len - 4] = '\0';
4739 /* Change this type to have a type with the specified mode.
4740 First check for the special modes. */
4741 if (!strcmp (p, "byte"))
4743 else if (!strcmp (p, "word"))
4745 else if (!strcmp (p, "pointer"))
4748 for (j = 0; j < NUM_MACHINE_MODES; j++)
4749 if (!strcmp (p, GET_MODE_NAME (j)))
4751 mode = (enum machine_mode) j;
4755 if (mode == VOIDmode)
4757 error ("unknown machine mode %qs", p);
4762 switch (GET_MODE_CLASS (mode))
4765 case MODE_PARTIAL_INT:
4767 case MODE_DECIMAL_FLOAT:
4768 valid_mode = targetm.scalar_mode_supported_p (mode);
4771 case MODE_COMPLEX_INT:
4772 case MODE_COMPLEX_FLOAT:
4773 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4776 case MODE_VECTOR_INT:
4777 case MODE_VECTOR_FLOAT:
4778 warning (OPT_Wattributes, "specifying vector types with "
4779 "__attribute__ ((mode)) is deprecated");
4780 warning (OPT_Wattributes,
4781 "use __attribute__ ((vector_size)) instead");
4782 valid_mode = vector_mode_valid_p (mode);
4790 error ("unable to emulate %qs", p);
4794 if (POINTER_TYPE_P (type))
4796 tree (*fn)(tree, enum machine_mode, bool);
4798 if (!targetm.valid_pointer_mode (mode))
4800 error ("invalid pointer mode %qs", p);
4804 if (TREE_CODE (type) == POINTER_TYPE)
4805 fn = build_pointer_type_for_mode;
4807 fn = build_reference_type_for_mode;
4808 typefm = fn (TREE_TYPE (type), mode, false);
4811 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4813 if (typefm == NULL_TREE)
4815 error ("no data type for mode %qs", p);
4818 else if (TREE_CODE (type) == ENUMERAL_TYPE)
4820 /* For enumeral types, copy the precision from the integer
4821 type returned above. If not an INTEGER_TYPE, we can't use
4822 this mode for this type. */
4823 if (TREE_CODE (typefm) != INTEGER_TYPE)
4825 error ("cannot use mode %qs for enumeral types", p);
4829 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
4831 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4836 /* We cannot build a type variant, as there's code that assumes
4837 that TYPE_MAIN_VARIANT has the same mode. This includes the
4838 debug generators. Instead, create a subrange type. This
4839 results in all of the enumeral values being emitted only once
4840 in the original, and the subtype gets them by reference. */
4841 if (TYPE_UNSIGNED (type))
4842 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
4844 typefm = make_signed_type (TYPE_PRECISION (typefm));
4845 TREE_TYPE (typefm) = type;
4848 else if (VECTOR_MODE_P (mode)
4849 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4850 : TREE_CODE (type) != TREE_CODE (typefm))
4852 error ("mode %qs applied to inappropriate type", p);
4862 /* Handle a "section" attribute; arguments as in
4863 struct attribute_spec.handler. */
4866 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4867 int ARG_UNUSED (flags), bool *no_add_attrs)
4871 if (targetm.have_named_sections)
4873 user_defined_section_attribute = true;
4875 if ((TREE_CODE (decl) == FUNCTION_DECL
4876 || TREE_CODE (decl) == VAR_DECL)
4877 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4879 if (TREE_CODE (decl) == VAR_DECL
4880 && current_function_decl != NULL_TREE
4881 && !TREE_STATIC (decl))
4883 error ("%Jsection attribute cannot be specified for "
4884 "local variables", decl);
4885 *no_add_attrs = true;
4888 /* The decl may have already been given a section attribute
4889 from a previous declaration. Ensure they match. */
4890 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4891 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4892 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4894 error ("section of %q+D conflicts with previous declaration",
4896 *no_add_attrs = true;
4899 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4903 error ("section attribute not allowed for %q+D", *node);
4904 *no_add_attrs = true;
4909 error ("%Jsection attributes are not supported for this target", *node);
4910 *no_add_attrs = true;
4916 /* Handle a "aligned" attribute; arguments as in
4917 struct attribute_spec.handler. */
4920 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4921 int flags, bool *no_add_attrs)
4923 tree decl = NULL_TREE;
4926 tree align_expr = (args ? TREE_VALUE (args)
4927 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4933 type = &TREE_TYPE (decl);
4934 is_type = TREE_CODE (*node) == TYPE_DECL;
4936 else if (TYPE_P (*node))
4937 type = node, is_type = 1;
4939 if (TREE_CODE (align_expr) != INTEGER_CST)
4941 error ("requested alignment is not a constant");
4942 *no_add_attrs = true;
4944 else if ((i = tree_log2 (align_expr)) == -1)
4946 error ("requested alignment is not a power of 2");
4947 *no_add_attrs = true;
4949 else if (i > HOST_BITS_PER_INT - 2)
4951 error ("requested alignment is too large");
4952 *no_add_attrs = true;
4956 /* If we have a TYPE_DECL, then copy the type, so that we
4957 don't accidentally modify a builtin type. See pushdecl. */
4958 if (decl && TREE_TYPE (decl) != error_mark_node
4959 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4961 tree tt = TREE_TYPE (decl);
4962 *type = build_variant_type_copy (*type);
4963 DECL_ORIGINAL_TYPE (decl) = tt;
4964 TYPE_NAME (*type) = decl;
4965 TREE_USED (*type) = TREE_USED (decl);
4966 TREE_TYPE (decl) = *type;
4968 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4969 *type = build_variant_type_copy (*type);
4971 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4972 TYPE_USER_ALIGN (*type) = 1;
4974 else if (TREE_CODE (decl) != VAR_DECL
4975 && TREE_CODE (decl) != FIELD_DECL)
4977 error ("alignment may not be specified for %q+D", decl);
4978 *no_add_attrs = true;
4982 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4983 DECL_USER_ALIGN (decl) = 1;
4989 /* Handle a "weak" attribute; arguments as in
4990 struct attribute_spec.handler. */
4993 handle_weak_attribute (tree *node, tree name,
4994 tree ARG_UNUSED (args),
4995 int ARG_UNUSED (flags),
4996 bool * ARG_UNUSED (no_add_attrs))
4998 if (TREE_CODE (*node) == FUNCTION_DECL
4999 || TREE_CODE (*node) == VAR_DECL)
5000 declare_weak (*node);
5002 warning (OPT_Wattributes, "%qE attribute ignored", name);
5008 /* Handle an "alias" attribute; arguments as in
5009 struct attribute_spec.handler. */
5012 handle_alias_attribute (tree *node, tree name, tree args,
5013 int ARG_UNUSED (flags), bool *no_add_attrs)
5017 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5018 || (TREE_CODE (decl) != FUNCTION_DECL
5019 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
5020 /* A static variable declaration is always a tentative definition,
5021 but the alias is a non-tentative definition which overrides. */
5022 || (TREE_CODE (decl) != FUNCTION_DECL
5023 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
5025 error ("%q+D defined both normally and as an alias", decl);
5026 *no_add_attrs = true;
5029 /* Note that the very first time we process a nested declaration,
5030 decl_function_context will not be set. Indeed, *would* never
5031 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
5032 we do below. After such frobbery, pushdecl would set the context.
5033 In any case, this is never what we want. */
5034 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
5038 id = TREE_VALUE (args);
5039 if (TREE_CODE (id) != STRING_CST)
5041 error ("alias argument not a string");
5042 *no_add_attrs = true;
5045 id = get_identifier (TREE_STRING_POINTER (id));
5046 /* This counts as a use of the object pointed to. */
5049 if (TREE_CODE (decl) == FUNCTION_DECL)
5050 DECL_INITIAL (decl) = error_mark_node;
5053 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
5054 DECL_EXTERNAL (decl) = 1;
5056 DECL_EXTERNAL (decl) = 0;
5057 TREE_STATIC (decl) = 1;
5062 warning (OPT_Wattributes, "%qE attribute ignored", name);
5063 *no_add_attrs = true;
5069 /* Handle a "weakref" attribute; arguments as in struct
5070 attribute_spec.handler. */
5073 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5074 int flags, bool *no_add_attrs)
5076 tree attr = NULL_TREE;
5078 /* We must ignore the attribute when it is associated with
5079 local-scoped decls, since attribute alias is ignored and many
5080 such symbols do not even have a DECL_WEAK field. */
5081 if (decl_function_context (*node) || current_function_decl)
5083 warning (OPT_Wattributes, "%qE attribute ignored", name);
5084 *no_add_attrs = true;
5088 /* The idea here is that `weakref("name")' mutates into `weakref,
5089 alias("name")', and weakref without arguments, in turn,
5090 implicitly adds weak. */
5094 attr = tree_cons (get_identifier ("alias"), args, attr);
5095 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
5097 *no_add_attrs = true;
5099 decl_attributes (node, attr, flags);
5103 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
5104 error ("%Jweakref attribute must appear before alias attribute",
5107 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5108 and that isn't supported; and because it wants to add it to
5109 the list of weak decls, which isn't helpful. */
5110 DECL_WEAK (*node) = 1;
5116 /* Handle an "visibility" attribute; arguments as in
5117 struct attribute_spec.handler. */
5120 handle_visibility_attribute (tree *node, tree name, tree args,
5121 int ARG_UNUSED (flags),
5122 bool *ARG_UNUSED (no_add_attrs))
5125 tree id = TREE_VALUE (args);
5126 enum symbol_visibility vis;
5130 if (TREE_CODE (*node) == ENUMERAL_TYPE)
5132 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5134 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5138 else if (TYPE_FIELDS (*node))
5140 error ("%qE attribute ignored because %qT is already defined",
5145 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5147 warning (OPT_Wattributes, "%qE attribute ignored", name);
5151 if (TREE_CODE (id) != STRING_CST)
5153 error ("visibility argument not a string");
5157 /* If this is a type, set the visibility on the type decl. */
5160 decl = TYPE_NAME (decl);
5163 if (TREE_CODE (decl) == IDENTIFIER_NODE)
5165 warning (OPT_Wattributes, "%qE attribute ignored on types",
5171 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5172 vis = VISIBILITY_DEFAULT;
5173 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5174 vis = VISIBILITY_INTERNAL;
5175 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5176 vis = VISIBILITY_HIDDEN;
5177 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5178 vis = VISIBILITY_PROTECTED;
5181 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5182 vis = VISIBILITY_DEFAULT;
5185 if (DECL_VISIBILITY_SPECIFIED (decl)
5186 && vis != DECL_VISIBILITY (decl)
5187 && lookup_attribute ("visibility", (TYPE_P (*node)
5188 ? TYPE_ATTRIBUTES (*node)
5189 : DECL_ATTRIBUTES (decl))))
5190 error ("%qD redeclared with different visibility", decl);
5192 DECL_VISIBILITY (decl) = vis;
5193 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5195 /* Go ahead and attach the attribute to the node as well. This is needed
5196 so we can determine whether we have VISIBILITY_DEFAULT because the
5197 visibility was not specified, or because it was explicitly overridden
5198 from the containing scope. */
5203 /* Determine the ELF symbol visibility for DECL, which is either a
5204 variable or a function. It is an error to use this function if a
5205 definition of DECL is not available in this translation unit.
5206 Returns true if the final visibility has been determined by this
5207 function; false if the caller is free to make additional
5211 c_determine_visibility (tree decl)
5213 gcc_assert (TREE_CODE (decl) == VAR_DECL
5214 || TREE_CODE (decl) == FUNCTION_DECL);
5216 /* If the user explicitly specified the visibility with an
5217 attribute, honor that. DECL_VISIBILITY will have been set during
5218 the processing of the attribute. We check for an explicit
5219 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5220 to distinguish the use of an attribute from the use of a "#pragma
5221 GCC visibility push(...)"; in the latter case we still want other
5222 considerations to be able to overrule the #pragma. */
5223 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
5226 /* Anything that is exported must have default visibility. */
5227 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5228 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
5230 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5231 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5235 /* Set default visibility to whatever the user supplied with
5236 visibility_specified depending on #pragma GCC visibility. */
5237 if (!DECL_VISIBILITY_SPECIFIED (decl))
5239 DECL_VISIBILITY (decl) = default_visibility;
5240 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5245 /* Handle an "tls_model" attribute; arguments as in
5246 struct attribute_spec.handler. */
5249 handle_tls_model_attribute (tree *node, tree name, tree args,
5250 int ARG_UNUSED (flags), bool *no_add_attrs)
5254 enum tls_model kind;
5256 *no_add_attrs = true;
5258 if (!DECL_THREAD_LOCAL_P (decl))
5260 warning (OPT_Wattributes, "%qE attribute ignored", name);
5264 kind = DECL_TLS_MODEL (decl);
5265 id = TREE_VALUE (args);
5266 if (TREE_CODE (id) != STRING_CST)
5268 error ("tls_model argument not a string");
5272 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5273 kind = TLS_MODEL_LOCAL_EXEC;
5274 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5275 kind = TLS_MODEL_INITIAL_EXEC;
5276 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5277 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5278 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5279 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5281 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5283 DECL_TLS_MODEL (decl) = kind;
5287 /* Handle a "no_instrument_function" attribute; arguments as in
5288 struct attribute_spec.handler. */
5291 handle_no_instrument_function_attribute (tree *node, tree name,
5292 tree ARG_UNUSED (args),
5293 int ARG_UNUSED (flags),
5298 if (TREE_CODE (decl) != FUNCTION_DECL)
5300 error ("%J%qE attribute applies only to functions", decl, name);
5301 *no_add_attrs = true;
5303 else if (DECL_INITIAL (decl))
5305 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5306 *no_add_attrs = true;
5309 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5314 /* Handle a "malloc" attribute; arguments as in
5315 struct attribute_spec.handler. */
5318 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5319 int ARG_UNUSED (flags), bool *no_add_attrs)
5321 if (TREE_CODE (*node) == FUNCTION_DECL
5322 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5323 DECL_IS_MALLOC (*node) = 1;
5326 warning (OPT_Wattributes, "%qE attribute ignored", name);
5327 *no_add_attrs = true;
5333 /* Handle a "returns_twice" attribute; arguments as in
5334 struct attribute_spec.handler. */
5337 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5338 int ARG_UNUSED (flags), bool *no_add_attrs)
5340 if (TREE_CODE (*node) == FUNCTION_DECL)
5341 DECL_IS_RETURNS_TWICE (*node) = 1;
5344 warning (OPT_Wattributes, "%qE attribute ignored", name);
5345 *no_add_attrs = true;
5351 /* Handle a "no_limit_stack" attribute; arguments as in
5352 struct attribute_spec.handler. */
5355 handle_no_limit_stack_attribute (tree *node, tree name,
5356 tree ARG_UNUSED (args),
5357 int ARG_UNUSED (flags),
5362 if (TREE_CODE (decl) != FUNCTION_DECL)
5364 error ("%J%qE attribute applies only to functions", decl, name);
5365 *no_add_attrs = true;
5367 else if (DECL_INITIAL (decl))
5369 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5370 *no_add_attrs = true;
5373 DECL_NO_LIMIT_STACK (decl) = 1;
5378 /* Handle a "pure" attribute; arguments as in
5379 struct attribute_spec.handler. */
5382 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5383 int ARG_UNUSED (flags), bool *no_add_attrs)
5385 if (TREE_CODE (*node) == FUNCTION_DECL)
5386 DECL_IS_PURE (*node) = 1;
5387 /* ??? TODO: Support types. */
5390 warning (OPT_Wattributes, "%qE attribute ignored", name);
5391 *no_add_attrs = true;
5397 /* Handle a "no vops" attribute; arguments as in
5398 struct attribute_spec.handler. */
5401 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5402 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5403 bool *ARG_UNUSED (no_add_attrs))
5405 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5406 DECL_IS_NOVOPS (*node) = 1;
5410 /* Handle a "deprecated" attribute; arguments as in
5411 struct attribute_spec.handler. */
5414 handle_deprecated_attribute (tree *node, tree name,
5415 tree ARG_UNUSED (args), int flags,
5418 tree type = NULL_TREE;
5420 tree what = NULL_TREE;
5425 type = TREE_TYPE (decl);
5427 if (TREE_CODE (decl) == TYPE_DECL
5428 || TREE_CODE (decl) == PARM_DECL
5429 || TREE_CODE (decl) == VAR_DECL
5430 || TREE_CODE (decl) == FUNCTION_DECL
5431 || TREE_CODE (decl) == FIELD_DECL)
5432 TREE_DEPRECATED (decl) = 1;
5436 else if (TYPE_P (*node))
5438 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5439 *node = build_variant_type_copy (*node);
5440 TREE_DEPRECATED (*node) = 1;
5448 *no_add_attrs = true;
5449 if (type && TYPE_NAME (type))
5451 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5452 what = TYPE_NAME (*node);
5453 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5454 && DECL_NAME (TYPE_NAME (type)))
5455 what = DECL_NAME (TYPE_NAME (type));
5458 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5460 warning (OPT_Wattributes, "%qE attribute ignored", name);
5466 /* Handle a "vector_size" attribute; arguments as in
5467 struct attribute_spec.handler. */
5470 handle_vector_size_attribute (tree *node, tree name, tree args,
5471 int ARG_UNUSED (flags),
5474 unsigned HOST_WIDE_INT vecsize, nunits;
5475 enum machine_mode orig_mode;
5476 tree type = *node, new_type, size;
5478 *no_add_attrs = true;
5480 size = TREE_VALUE (args);
5482 if (!host_integerp (size, 1))
5484 warning (OPT_Wattributes, "%qE attribute ignored", name);
5488 /* Get the vector size (in bytes). */
5489 vecsize = tree_low_cst (size, 1);
5491 /* We need to provide for vector pointers, vector arrays, and
5492 functions returning vectors. For example:
5494 __attribute__((vector_size(16))) short *foo;
5496 In this case, the mode is SI, but the type being modified is
5497 HI, so we need to look further. */
5499 while (POINTER_TYPE_P (type)
5500 || TREE_CODE (type) == FUNCTION_TYPE
5501 || TREE_CODE (type) == METHOD_TYPE
5502 || TREE_CODE (type) == ARRAY_TYPE)
5503 type = TREE_TYPE (type);
5505 /* Get the mode of the type being modified. */
5506 orig_mode = TYPE_MODE (type);
5508 if (TREE_CODE (type) == RECORD_TYPE
5509 || TREE_CODE (type) == UNION_TYPE
5510 || TREE_CODE (type) == VECTOR_TYPE
5511 || (!SCALAR_FLOAT_MODE_P (orig_mode)
5512 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5513 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5515 error ("invalid vector type for attribute %qE", name);
5519 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5521 error ("vector size not an integral multiple of component size");
5527 error ("zero vector size");
5531 /* Calculate how many units fit in the vector. */
5532 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5533 if (nunits & (nunits - 1))
5535 error ("number of components of the vector not a power of two");
5539 new_type = build_vector_type (type, nunits);
5541 /* Build back pointers if needed. */
5542 *node = reconstruct_complex_type (*node, new_type);
5547 /* Handle the "nonnull" attribute. */
5549 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5550 tree args, int ARG_UNUSED (flags),
5554 unsigned HOST_WIDE_INT attr_arg_num;
5556 /* If no arguments are specified, all pointer arguments should be
5557 non-null. Verify a full prototype is given so that the arguments
5558 will have the correct types when we actually check them later. */
5561 if (!TYPE_ARG_TYPES (type))
5563 error ("nonnull attribute without arguments on a non-prototype");
5564 *no_add_attrs = true;
5569 /* Argument list specified. Verify that each argument number references
5570 a pointer argument. */
5571 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5574 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5576 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5578 error ("nonnull argument has invalid operand number (argument %lu)",
5579 (unsigned long) attr_arg_num);
5580 *no_add_attrs = true;
5584 argument = TYPE_ARG_TYPES (type);
5587 for (ck_num = 1; ; ck_num++)
5589 if (!argument || ck_num == arg_num)
5591 argument = TREE_CHAIN (argument);
5595 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5597 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5598 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5599 *no_add_attrs = true;
5603 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5605 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5606 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5607 *no_add_attrs = true;
5616 /* Check the argument list of a function call for null in argument slots
5617 that are marked as requiring a non-null pointer argument. */
5620 check_function_nonnull (tree attrs, tree params)
5622 tree a, args, param;
5625 for (a = attrs; a; a = TREE_CHAIN (a))
5627 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5629 args = TREE_VALUE (a);
5631 /* Walk the argument list. If we encounter an argument number we
5632 should check for non-null, do it. If the attribute has no args,
5633 then every pointer argument is checked (in which case the check
5634 for pointer type is done in check_nonnull_arg). */
5635 for (param = params, param_num = 1; ;
5636 param_num++, param = TREE_CHAIN (param))
5640 if (!args || nonnull_check_p (args, param_num))
5641 check_function_arguments_recurse (check_nonnull_arg, NULL,
5649 /* Check that the Nth argument of a function call (counting backwards
5650 from the end) is a (pointer)0. */
5653 check_function_sentinel (tree attrs, tree params, tree typelist)
5655 tree attr = lookup_attribute ("sentinel", attrs);
5659 /* Skip over the named arguments. */
5660 while (typelist && params)
5662 typelist = TREE_CHAIN (typelist);
5663 params = TREE_CHAIN (params);
5666 if (typelist || !params)
5667 warning (OPT_Wformat,
5668 "not enough variable arguments to fit a sentinel");
5674 if (TREE_VALUE (attr))
5676 tree p = TREE_VALUE (TREE_VALUE (attr));
5677 pos = TREE_INT_CST_LOW (p);
5680 sentinel = end = params;
5682 /* Advance `end' ahead of `sentinel' by `pos' positions. */
5683 while (pos > 0 && TREE_CHAIN (end))
5686 end = TREE_CHAIN (end);
5690 warning (OPT_Wformat,
5691 "not enough variable arguments to fit a sentinel");
5695 /* Now advance both until we find the last parameter. */
5696 while (TREE_CHAIN (end))
5698 end = TREE_CHAIN (end);
5699 sentinel = TREE_CHAIN (sentinel);
5702 /* Validate the sentinel. */
5703 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5704 || !integer_zerop (TREE_VALUE (sentinel)))
5705 /* Although __null (in C++) is only an integer we allow it
5706 nevertheless, as we are guaranteed that it's exactly
5707 as wide as a pointer, and we don't want to force
5708 users to cast the NULL they have written there.
5709 We warn with -Wstrict-null-sentinel, though. */
5710 && (warn_strict_null_sentinel
5711 || null_node != TREE_VALUE (sentinel)))
5712 warning (OPT_Wformat, "missing sentinel in function call");
5717 /* Helper for check_function_nonnull; given a list of operands which
5718 must be non-null in ARGS, determine if operand PARAM_NUM should be
5722 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5724 unsigned HOST_WIDE_INT arg_num = 0;
5726 for (; args; args = TREE_CHAIN (args))
5728 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5732 if (arg_num == param_num)
5738 /* Check that the function argument PARAM (which is operand number
5739 PARAM_NUM) is non-null. This is called by check_function_nonnull
5740 via check_function_arguments_recurse. */
5743 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5744 unsigned HOST_WIDE_INT param_num)
5746 /* Just skip checking the argument if it's not a pointer. This can
5747 happen if the "nonnull" attribute was given without an operand
5748 list (which means to check every pointer argument). */
5750 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5753 if (integer_zerop (param))
5754 warning (OPT_Wnonnull, "null argument where non-null required "
5755 "(argument %lu)", (unsigned long) param_num);
5758 /* Helper for nonnull attribute handling; fetch the operand number
5759 from the attribute argument list. */
5762 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5764 /* Verify the arg number is a constant. */
5765 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5766 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5769 *valp = TREE_INT_CST_LOW (arg_num_expr);
5773 /* Handle a "nothrow" attribute; arguments as in
5774 struct attribute_spec.handler. */
5777 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5778 int ARG_UNUSED (flags), bool *no_add_attrs)
5780 if (TREE_CODE (*node) == FUNCTION_DECL)
5781 TREE_NOTHROW (*node) = 1;
5782 /* ??? TODO: Support types. */
5785 warning (OPT_Wattributes, "%qE attribute ignored", name);
5786 *no_add_attrs = true;
5792 /* Handle a "cleanup" attribute; arguments as in
5793 struct attribute_spec.handler. */
5796 handle_cleanup_attribute (tree *node, tree name, tree args,
5797 int ARG_UNUSED (flags), bool *no_add_attrs)
5800 tree cleanup_id, cleanup_decl;
5802 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5803 for global destructors in C++. This requires infrastructure that
5804 we don't have generically at the moment. It's also not a feature
5805 we'd be missing too much, since we do have attribute constructor. */
5806 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5808 warning (OPT_Wattributes, "%qE attribute ignored", name);
5809 *no_add_attrs = true;
5813 /* Verify that the argument is a function in scope. */
5814 /* ??? We could support pointers to functions here as well, if
5815 that was considered desirable. */
5816 cleanup_id = TREE_VALUE (args);
5817 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5819 error ("cleanup argument not an identifier");
5820 *no_add_attrs = true;
5823 cleanup_decl = lookup_name (cleanup_id);
5824 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5826 error ("cleanup argument not a function");
5827 *no_add_attrs = true;
5831 /* That the function has proper type is checked with the
5832 eventual call to build_function_call. */
5837 /* Handle a "warn_unused_result" attribute. No special handling. */
5840 handle_warn_unused_result_attribute (tree *node, tree name,
5841 tree ARG_UNUSED (args),
5842 int ARG_UNUSED (flags), bool *no_add_attrs)
5844 /* Ignore the attribute for functions not returning any value. */
5845 if (VOID_TYPE_P (TREE_TYPE (*node)))
5847 warning (OPT_Wattributes, "%qE attribute ignored", name);
5848 *no_add_attrs = true;
5854 /* Handle a "sentinel" attribute. */
5857 handle_sentinel_attribute (tree *node, tree name, tree args,
5858 int ARG_UNUSED (flags), bool *no_add_attrs)
5860 tree params = TYPE_ARG_TYPES (*node);
5864 warning (OPT_Wattributes,
5865 "%qE attribute requires prototypes with named arguments", name);
5866 *no_add_attrs = true;
5870 while (TREE_CHAIN (params))
5871 params = TREE_CHAIN (params);
5873 if (VOID_TYPE_P (TREE_VALUE (params)))
5875 warning (OPT_Wattributes,
5876 "%qE attribute only applies to variadic functions", name);
5877 *no_add_attrs = true;
5883 tree position = TREE_VALUE (args);
5885 if (TREE_CODE (position) != INTEGER_CST)
5887 warning (0, "requested position is not an integer constant");
5888 *no_add_attrs = true;
5892 if (tree_int_cst_lt (position, integer_zero_node))
5894 warning (0, "requested position is less than zero");
5895 *no_add_attrs = true;
5903 /* Check for valid arguments being passed to a function. */
5905 check_function_arguments (tree attrs, tree params, tree typelist)
5907 /* Check for null being passed in a pointer argument that must be
5908 non-null. We also need to do this if format checking is enabled. */
5911 check_function_nonnull (attrs, params);
5913 /* Check for errors in format strings. */
5915 if (warn_format || warn_missing_format_attribute)
5916 check_function_format (attrs, params);
5919 check_function_sentinel (attrs, params, typelist);
5922 /* Generic argument checking recursion routine. PARAM is the argument to
5923 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5924 once the argument is resolved. CTX is context for the callback. */
5926 check_function_arguments_recurse (void (*callback)
5927 (void *, tree, unsigned HOST_WIDE_INT),
5928 void *ctx, tree param,
5929 unsigned HOST_WIDE_INT param_num)
5931 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
5932 && (TYPE_PRECISION (TREE_TYPE (param))
5933 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
5935 /* Strip coercion. */
5936 check_function_arguments_recurse (callback, ctx,
5937 TREE_OPERAND (param, 0), param_num);
5941 if (TREE_CODE (param) == CALL_EXPR)
5943 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5945 bool found_format_arg = false;
5947 /* See if this is a call to a known internationalization function
5948 that modifies a format arg. Such a function may have multiple
5949 format_arg attributes (for example, ngettext). */
5951 for (attrs = TYPE_ATTRIBUTES (type);
5953 attrs = TREE_CHAIN (attrs))
5954 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5957 tree format_num_expr;
5961 /* Extract the argument number, which was previously checked
5963 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5965 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
5966 && !TREE_INT_CST_HIGH (format_num_expr));
5968 format_num = TREE_INT_CST_LOW (format_num_expr);
5970 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5972 inner_args = TREE_CHAIN (inner_args), i++)
5973 if (i == format_num)
5975 check_function_arguments_recurse (callback, ctx,
5976 TREE_VALUE (inner_args),
5978 found_format_arg = true;
5983 /* If we found a format_arg attribute and did a recursive check,
5984 we are done with checking this argument. Otherwise, we continue
5985 and this will be considered a non-literal. */
5986 if (found_format_arg)
5990 if (TREE_CODE (param) == COND_EXPR)
5992 /* Check both halves of the conditional expression. */
5993 check_function_arguments_recurse (callback, ctx,
5994 TREE_OPERAND (param, 1), param_num);
5995 check_function_arguments_recurse (callback, ctx,
5996 TREE_OPERAND (param, 2), param_num);
6000 (*callback) (ctx, param, param_num);
6003 /* Function to help qsort sort FIELD_DECLs by name order. */
6006 field_decl_cmp (const void *x_p, const void *y_p)
6008 const tree *const x = (const tree *const) x_p;
6009 const tree *const y = (const tree *const) y_p;
6011 if (DECL_NAME (*x) == DECL_NAME (*y))
6012 /* A nontype is "greater" than a type. */
6013 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6014 if (DECL_NAME (*x) == NULL_TREE)
6016 if (DECL_NAME (*y) == NULL_TREE)
6018 if (DECL_NAME (*x) < DECL_NAME (*y))
6024 gt_pointer_operator new_value;
6028 /* This routine compares two fields like field_decl_cmp but using the
6029 pointer operator in resort_data. */
6032 resort_field_decl_cmp (const void *x_p, const void *y_p)
6034 const tree *const x = (const tree *const) x_p;
6035 const tree *const y = (const tree *const) y_p;
6037 if (DECL_NAME (*x) == DECL_NAME (*y))
6038 /* A nontype is "greater" than a type. */
6039 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6040 if (DECL_NAME (*x) == NULL_TREE)
6042 if (DECL_NAME (*y) == NULL_TREE)
6045 tree d1 = DECL_NAME (*x);
6046 tree d2 = DECL_NAME (*y);
6047 resort_data.new_value (&d1, resort_data.cookie);
6048 resort_data.new_value (&d2, resort_data.cookie);
6055 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
6058 resort_sorted_fields (void *obj,
6059 void * ARG_UNUSED (orig_obj),
6060 gt_pointer_operator new_value,
6063 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6064 resort_data.new_value = new_value;
6065 resort_data.cookie = cookie;
6066 qsort (&sf->elts[0], sf->len, sizeof (tree),
6067 resort_field_decl_cmp);
6070 /* Subroutine of c_parse_error.
6071 Return the result of concatenating LHS and RHS. RHS is really
6072 a string literal, its first character is indicated by RHS_START and
6073 RHS_SIZE is its length (including the terminating NUL character).
6075 The caller is responsible for deleting the returned pointer. */
6078 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6080 const int lhs_size = strlen (lhs);
6081 char *result = XNEWVEC (char, lhs_size + rhs_size);
6082 strncpy (result, lhs, lhs_size);
6083 strncpy (result + lhs_size, rhs_start, rhs_size);
6087 /* Issue the error given by GMSGID, indicating that it occurred before
6088 TOKEN, which had the associated VALUE. */
6091 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6093 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6095 char *message = NULL;
6097 if (token == CPP_EOF)
6098 message = catenate_messages (gmsgid, " at end of input");
6099 else if (token == CPP_CHAR || token == CPP_WCHAR)
6101 unsigned int val = TREE_INT_CST_LOW (value);
6102 const char *const ell = (token == CPP_CHAR) ? "" : "L";
6103 if (val <= UCHAR_MAX && ISGRAPH (val))
6104 message = catenate_messages (gmsgid, " before %s'%c'");
6106 message = catenate_messages (gmsgid, " before %s'\\x%x'");
6108 error (message, ell, val);
6112 else if (token == CPP_STRING || token == CPP_WSTRING)
6113 message = catenate_messages (gmsgid, " before string constant");
6114 else if (token == CPP_NUMBER)
6115 message = catenate_messages (gmsgid, " before numeric constant");
6116 else if (token == CPP_NAME)
6118 message = catenate_messages (gmsgid, " before %qE");
6119 error (message, value);
6123 else if (token == CPP_PRAGMA)
6124 message = catenate_messages (gmsgid, " before %<#pragma%>");
6125 else if (token == CPP_PRAGMA_EOL)
6126 message = catenate_messages (gmsgid, " before end of line");
6127 else if (token < N_TTYPES)
6129 message = catenate_messages (gmsgid, " before %qs token");
6130 error (message, cpp_type2name (token));
6142 #undef catenate_messages
6145 /* Walk a gimplified function and warn for functions whose return value is
6146 ignored and attribute((warn_unused_result)) is set. This is done before
6147 inlining, so we don't have to worry about that. */
6150 c_warn_unused_result (tree *top_p)
6153 tree_stmt_iterator i;
6156 switch (TREE_CODE (t))
6158 case STATEMENT_LIST:
6159 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6160 c_warn_unused_result (tsi_stmt_ptr (i));
6164 c_warn_unused_result (&COND_EXPR_THEN (t));
6165 c_warn_unused_result (&COND_EXPR_ELSE (t));
6168 c_warn_unused_result (&BIND_EXPR_BODY (t));
6170 case TRY_FINALLY_EXPR:
6171 case TRY_CATCH_EXPR:
6172 c_warn_unused_result (&TREE_OPERAND (t, 0));
6173 c_warn_unused_result (&TREE_OPERAND (t, 1));
6176 c_warn_unused_result (&CATCH_BODY (t));
6178 case EH_FILTER_EXPR:
6179 c_warn_unused_result (&EH_FILTER_FAILURE (t));
6186 /* This is a naked call, as opposed to a CALL_EXPR nested inside
6187 a MODIFY_EXPR. All calls whose value is ignored should be
6188 represented like this. Look for the attribute. */
6189 fdecl = get_callee_fndecl (t);
6191 ftype = TREE_TYPE (fdecl);
6194 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
6195 /* Look past pointer-to-function to the function type itself. */
6196 ftype = TREE_TYPE (ftype);
6199 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
6202 warning (0, "%Hignoring return value of %qD, "
6203 "declared with attribute warn_unused_result",
6204 EXPR_LOCUS (t), fdecl);
6206 warning (0, "%Hignoring return value of function "
6207 "declared with attribute warn_unused_result",
6213 /* Not a container, not a call, or a call whose value is used. */
6218 /* Convert a character from the host to the target execution character
6219 set. cpplib handles this, mostly. */
6222 c_common_to_target_charset (HOST_WIDE_INT c)
6224 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6225 zero-extended under -fno-signed-char. cpplib insists that characters
6226 and character constants are always unsigned. Hence we must convert
6228 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6230 uc = cpp_host_to_exec_charset (parse_in, uc);
6232 if (flag_signed_char)
6233 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6234 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6239 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6240 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6241 NULL, at the bottom; much like the traditional rendering of offsetof as a
6242 macro. Returns the folded and properly cast result. */
6245 fold_offsetof_1 (tree expr, tree stop_ref)
6247 enum tree_code code = PLUS_EXPR;
6250 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6251 return size_zero_node;
6253 switch (TREE_CODE (expr))
6259 error ("cannot apply %<offsetof%> to static data member %qD", expr);
6260 return error_mark_node;
6263 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6264 return error_mark_node;
6267 gcc_assert (integer_zerop (expr));
6268 return size_zero_node;
6272 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6273 gcc_assert (base == error_mark_node || base == size_zero_node);
6277 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6278 if (base == error_mark_node)
6281 t = TREE_OPERAND (expr, 1);
6282 if (DECL_C_BIT_FIELD (t))
6284 error ("attempt to take address of bit-field structure "
6286 return error_mark_node;
6288 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6289 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6294 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6295 if (base == error_mark_node)
6298 t = TREE_OPERAND (expr, 1);
6299 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6302 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6304 t = convert (sizetype, t);
6305 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6312 return size_binop (code, base, off);
6316 fold_offsetof (tree expr, tree stop_ref)
6318 /* Convert back from the internal sizetype to size_t. */
6319 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6322 /* Print an error message for an invalid lvalue. USE says
6323 how the lvalue is being used and so selects the error message. */
6326 lvalue_error (enum lvalue_use use)
6331 error ("lvalue required as left operand of assignment");
6334 error ("lvalue required as increment operand");
6337 error ("lvalue required as decrement operand");
6340 error ("lvalue required as unary %<&%> operand");
6343 error ("lvalue required in asm statement");
6350 /* *PTYPE is an incomplete array. Complete it with a domain based on
6351 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6352 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6353 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6356 complete_array_type (tree *ptype, tree initial_value, bool do_default)
6358 tree maxindex, type, main_type, elt, unqual_elt;
6359 int failure = 0, quals;
6360 hashval_t hashcode = 0;
6362 maxindex = size_zero_node;
6365 if (TREE_CODE (initial_value) == STRING_CST)
6368 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6369 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6371 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6373 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6375 if (VEC_empty (constructor_elt, v))
6379 maxindex = integer_minus_one_node;
6384 unsigned HOST_WIDE_INT cnt;
6385 constructor_elt *ce;
6387 if (VEC_index (constructor_elt, v, 0)->index)
6388 maxindex = fold_convert (sizetype,
6389 VEC_index (constructor_elt,
6391 curindex = maxindex;
6394 VEC_iterate (constructor_elt, v, cnt, ce);
6398 curindex = fold_convert (sizetype, ce->index);
6400 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6402 if (tree_int_cst_lt (maxindex, curindex))
6403 maxindex = curindex;
6409 /* Make an error message unless that happened already. */
6410 if (initial_value != error_mark_node)
6422 elt = TREE_TYPE (type);
6423 quals = TYPE_QUALS (strip_array_types (elt));
6427 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6429 /* Using build_distinct_type_copy and modifying things afterward instead
6430 of using build_array_type to create a new type preserves all of the
6431 TYPE_LANG_FLAG_? bits that the front end may have set. */
6432 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6433 TREE_TYPE (main_type) = unqual_elt;
6434 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6435 layout_type (main_type);
6437 /* Make sure we have the canonical MAIN_TYPE. */
6438 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
6439 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
6441 main_type = type_hash_canon (hashcode, main_type);
6446 type = c_build_qualified_type (main_type, quals);
6453 /* Used to help initialize the builtin-types.def table. When a type of
6454 the correct size doesn't exist, use error_mark_node instead of NULL.
6455 The later results in segfaults even when a decl using the type doesn't
6459 builtin_type_for_size (int size, bool unsignedp)
6461 tree type = lang_hooks.types.type_for_size (size, unsignedp);
6462 return type ? type : error_mark_node;
6465 /* A helper function for resolve_overloaded_builtin in resolving the
6466 overloaded __sync_ builtins. Returns a positive power of 2 if the
6467 first operand of PARAMS is a pointer to a supported data type.
6468 Returns 0 if an error is encountered. */
6471 sync_resolve_size (tree function, tree params)
6478 error ("too few arguments to function %qE", function);
6482 type = TREE_TYPE (TREE_VALUE (params));
6483 if (TREE_CODE (type) != POINTER_TYPE)
6486 type = TREE_TYPE (type);
6487 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6490 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6491 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6495 error ("incompatible type for argument %d of %qE", 1, function);
6499 /* A helper function for resolve_overloaded_builtin. Adds casts to
6500 PARAMS to make arguments match up with those of FUNCTION. Drops
6501 the variadic arguments at the end. Returns false if some error
6502 was encountered; true on success. */
6505 sync_resolve_params (tree orig_function, tree function, tree params)
6507 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6511 /* We've declared the implementation functions to use "volatile void *"
6512 as the pointer parameter, so we shouldn't get any complaints from the
6513 call to check_function_arguments what ever type the user used. */
6514 arg_types = TREE_CHAIN (arg_types);
6515 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6518 /* For the rest of the values, we need to cast these to FTYPE, so that we
6519 don't get warnings for passing pointer types, etc. */
6520 while (arg_types != void_list_node)
6524 params = TREE_CHAIN (params);
6527 error ("too few arguments to function %qE", orig_function);
6531 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6532 so that we get warnings for anything that doesn't match the pointer
6533 type. This isn't portable across the C and C++ front ends atm. */
6534 val = TREE_VALUE (params);
6535 val = convert (ptype, val);
6536 val = convert (TREE_VALUE (arg_types), val);
6537 TREE_VALUE (params) = val;
6539 arg_types = TREE_CHAIN (arg_types);
6543 /* The definition of these primitives is variadic, with the remaining
6544 being "an optional list of variables protected by the memory barrier".
6545 No clue what that's supposed to mean, precisely, but we consider all
6546 call-clobbered variables to be protected so we're safe. */
6547 TREE_CHAIN (params) = NULL;
6552 /* A helper function for resolve_overloaded_builtin. Adds a cast to
6553 RESULT to make it match the type of the first pointer argument in
6557 sync_resolve_return (tree params, tree result)
6559 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6560 ptype = TYPE_MAIN_VARIANT (ptype);
6561 return convert (ptype, result);
6564 /* Some builtin functions are placeholders for other expressions. This
6565 function should be called immediately after parsing the call expression
6566 before surrounding code has committed to the type of the expression.
6568 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6569 PARAMS is the argument list for the call. The return value is non-null
6570 when expansion is complete, and null if normal processing should
6574 resolve_overloaded_builtin (tree function, tree params)
6576 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6577 switch (DECL_BUILT_IN_CLASS (function))
6579 case BUILT_IN_NORMAL:
6582 if (targetm.resolve_overloaded_builtin)
6583 return targetm.resolve_overloaded_builtin (function, params);
6590 /* Handle BUILT_IN_NORMAL here. */
6593 case BUILT_IN_FETCH_AND_ADD_N:
6594 case BUILT_IN_FETCH_AND_SUB_N:
6595 case BUILT_IN_FETCH_AND_OR_N:
6596 case BUILT_IN_FETCH_AND_AND_N:
6597 case BUILT_IN_FETCH_AND_XOR_N:
6598 case BUILT_IN_FETCH_AND_NAND_N:
6599 case BUILT_IN_ADD_AND_FETCH_N:
6600 case BUILT_IN_SUB_AND_FETCH_N:
6601 case BUILT_IN_OR_AND_FETCH_N:
6602 case BUILT_IN_AND_AND_FETCH_N:
6603 case BUILT_IN_XOR_AND_FETCH_N:
6604 case BUILT_IN_NAND_AND_FETCH_N:
6605 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6606 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6607 case BUILT_IN_LOCK_TEST_AND_SET_N:
6608 case BUILT_IN_LOCK_RELEASE_N:
6610 int n = sync_resolve_size (function, params);
6611 tree new_function, result;
6614 return error_mark_node;
6616 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6617 if (!sync_resolve_params (function, new_function, params))
6618 return error_mark_node;
6620 result = build_function_call (new_function, params);
6621 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6622 && orig_code != BUILT_IN_LOCK_RELEASE_N)
6623 result = sync_resolve_return (params, result);
6633 /* Ignoring their sign, return true if two scalar types are the same. */
6635 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6637 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6639 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6640 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6642 /* Equality works here because c_common_signed_type uses
6643 TYPE_MAIN_VARIANT. */
6644 return lang_hooks.types.signed_type (t1)
6645 == lang_hooks.types.signed_type (t2);
6648 /* Check for missing format attributes on function pointers. LTYPE is
6649 the new type or left-hand side type. RTYPE is the old type or
6650 right-hand side type. Returns TRUE if LTYPE is missing the desired
6654 check_missing_format_attribute (tree ltype, tree rtype)
6656 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6659 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6660 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6665 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6666 if (is_attribute_p ("format", TREE_PURPOSE (la)))
6674 /* Subscripting with type char is likely to lose on a machine where
6675 chars are signed. So warn on any machine, but optionally. Don't
6676 warn for unsigned char since that type is safe. Don't warn for
6677 signed char because anyone who uses that must have done so
6678 deliberately. Furthermore, we reduce the false positive load by
6679 warning only for non-constant value of type char. */
6682 warn_array_subscript_with_type_char (tree index)
6684 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6685 && TREE_CODE (index) != INTEGER_CST)
6686 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6689 /* Implement -Wparentheses for the unexpected C precedence rules, to
6690 cover cases like x + y << z which readers are likely to
6691 misinterpret. We have seen an expression in which CODE is a binary
6692 operator used to combine expressions headed by CODE_LEFT and
6693 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
6694 means that that side of the expression was not formed using a
6695 binary operator, or it was enclosed in parentheses. */
6698 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
6699 enum tree_code code_right)
6701 if (!warn_parentheses)
6704 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
6706 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6707 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6708 warning (OPT_Wparentheses,
6709 "suggest parentheses around + or - inside shift");
6712 if (code == TRUTH_ORIF_EXPR)
6714 if (code_left == TRUTH_ANDIF_EXPR
6715 || code_right == TRUTH_ANDIF_EXPR)
6716 warning (OPT_Wparentheses,
6717 "suggest parentheses around && within ||");
6720 if (code == BIT_IOR_EXPR)
6722 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
6723 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6724 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
6725 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6726 warning (OPT_Wparentheses,
6727 "suggest parentheses around arithmetic in operand of |");
6728 /* Check cases like x|y==z */
6729 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6730 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6731 warning (OPT_Wparentheses,
6732 "suggest parentheses around comparison in operand of |");
6735 if (code == BIT_XOR_EXPR)
6737 if (code_left == BIT_AND_EXPR
6738 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
6739 || code_right == BIT_AND_EXPR
6740 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6741 warning (OPT_Wparentheses,
6742 "suggest parentheses around arithmetic in operand of ^");
6743 /* Check cases like x^y==z */
6744 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6745 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6746 warning (OPT_Wparentheses,
6747 "suggest parentheses around comparison in operand of ^");
6750 if (code == BIT_AND_EXPR)
6752 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
6753 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
6754 warning (OPT_Wparentheses,
6755 "suggest parentheses around + or - in operand of &");
6756 /* Check cases like x&y==z */
6757 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6758 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6759 warning (OPT_Wparentheses,
6760 "suggest parentheses around comparison in operand of &");
6763 if (code == EQ_EXPR || code == NE_EXPR)
6765 if (TREE_CODE_CLASS (code_left) == tcc_comparison
6766 || TREE_CODE_CLASS (code_right) == tcc_comparison)
6767 warning (OPT_Wparentheses,
6768 "suggest parentheses around comparison in operand of %s",
6769 code == EQ_EXPR ? "==" : "!=");
6771 else if (TREE_CODE_CLASS (code) == tcc_comparison)
6773 if ((TREE_CODE_CLASS (code_left) == tcc_comparison
6774 && code_left != NE_EXPR && code_left != EQ_EXPR)
6775 || (TREE_CODE_CLASS (code_right) == tcc_comparison
6776 && code_right != NE_EXPR && code_right != EQ_EXPR))
6777 warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
6778 "have their mathematical meaning");
6782 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
6785 warn_for_unused_label (tree label)
6787 if (!TREE_USED (label))
6789 if (DECL_INITIAL (label))
6790 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
6792 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
6796 #include "gt-c-common.h"