1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
35 #include "diagnostic.h"
40 #include "langhooks.h"
41 #include "tree-inline.h"
44 #include "tree-iterator.h"
46 #include "tree-mudflap.h"
50 #include "target-def.h"
51 #include "fixed-value.h"
53 cpp_reader *parse_in; /* Declared in c-pragma.h. */
55 /* We let tm.h override the types used here, to handle trivial differences
56 such as the choice of unsigned int or long unsigned int for size_t.
57 When machines start needing nontrivial differences in the size type,
58 it would be best to do something here to figure out automatically
59 from other information what type to use. */
62 #define SIZE_TYPE "long unsigned int"
66 #define PID_TYPE "int"
70 #define WCHAR_TYPE "int"
73 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
74 #define MODIFIED_WCHAR_TYPE \
75 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
78 #define PTRDIFF_TYPE "long int"
82 #define WINT_TYPE "unsigned int"
86 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
88 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
94 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
96 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
97 ? "long unsigned int" \
98 : "long long unsigned int"))
101 /* The following symbols are subsumed in the c_global_trees array, and
102 listed here individually for documentation purposes.
104 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
106 tree short_integer_type_node;
107 tree long_integer_type_node;
108 tree long_long_integer_type_node;
110 tree short_unsigned_type_node;
111 tree long_unsigned_type_node;
112 tree long_long_unsigned_type_node;
114 tree truthvalue_type_node;
115 tree truthvalue_false_node;
116 tree truthvalue_true_node;
118 tree ptrdiff_type_node;
120 tree unsigned_char_type_node;
121 tree signed_char_type_node;
122 tree wchar_type_node;
123 tree signed_wchar_type_node;
124 tree unsigned_wchar_type_node;
126 tree float_type_node;
127 tree double_type_node;
128 tree long_double_type_node;
130 tree complex_integer_type_node;
131 tree complex_float_type_node;
132 tree complex_double_type_node;
133 tree complex_long_double_type_node;
135 tree dfloat32_type_node;
136 tree dfloat64_type_node;
137 tree_dfloat128_type_node;
139 tree intQI_type_node;
140 tree intHI_type_node;
141 tree intSI_type_node;
142 tree intDI_type_node;
143 tree intTI_type_node;
145 tree unsigned_intQI_type_node;
146 tree unsigned_intHI_type_node;
147 tree unsigned_intSI_type_node;
148 tree unsigned_intDI_type_node;
149 tree unsigned_intTI_type_node;
151 tree widest_integer_literal_type_node;
152 tree widest_unsigned_literal_type_node;
154 Nodes for types `void *' and `const void *'.
156 tree ptr_type_node, const_ptr_type_node;
158 Nodes for types `char *' and `const char *'.
160 tree string_type_node, const_string_type_node;
162 Type `char[SOMENUMBER]'.
163 Used when an array of char is needed and the size is irrelevant.
165 tree char_array_type_node;
167 Type `int[SOMENUMBER]' or something like it.
168 Used when an array of int needed and the size is irrelevant.
170 tree int_array_type_node;
172 Type `wchar_t[SOMENUMBER]' or something like it.
173 Used when a wide string literal is created.
175 tree wchar_array_type_node;
177 Type `int ()' -- used for implicit declaration of functions.
179 tree default_function_type;
181 A VOID_TYPE node, packaged in a TREE_LIST.
185 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
186 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
187 VAR_DECLS, but C++ does.)
189 tree function_name_decl_node;
190 tree pretty_function_name_decl_node;
191 tree c99_function_name_decl_node;
193 Stack of nested function name VAR_DECLs.
195 tree saved_function_name_decls;
199 tree c_global_trees[CTI_MAX];
201 /* Switches common to the C front ends. */
203 /* Nonzero if prepreprocessing only. */
205 int flag_preprocess_only;
207 /* Nonzero means don't output line number information. */
209 char flag_no_line_commands;
211 /* Nonzero causes -E output not to be done, but directives such as
212 #define that have side effects are still obeyed. */
216 /* Nonzero means dump macros in some fashion. */
218 char flag_dump_macros;
220 /* Nonzero means pass #include lines through to the output. */
222 char flag_dump_includes;
224 /* Nonzero means process PCH files while preprocessing. */
226 bool flag_pch_preprocess;
228 /* The file name to which we should write a precompiled header, or
229 NULL if no header will be written in this compile. */
231 const char *pch_file;
233 /* Nonzero if an ISO standard was selected. It rejects macros in the
237 /* Nonzero if -undef was given. It suppresses target built-in macros
241 /* Nonzero means don't recognize the non-ANSI builtin functions. */
245 /* Nonzero means don't recognize the non-ANSI builtin functions.
248 int flag_no_nonansi_builtin;
250 /* Nonzero means give `double' the same size as `float'. */
252 int flag_short_double;
254 /* Nonzero means give `wchar_t' the same size as `short'. */
256 int flag_short_wchar;
258 /* Nonzero means allow implicit conversions between vectors with
259 differing numbers of subparts and/or differing element types. */
260 int flag_lax_vector_conversions;
262 /* Nonzero means allow Microsoft extensions without warnings or errors. */
263 int flag_ms_extensions;
265 /* Nonzero means don't recognize the keyword `asm'. */
269 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
271 int flag_signed_bitfields = 1;
273 /* Warn about #pragma directives that are not recognized. */
275 int warn_unknown_pragmas; /* Tri state variable. */
277 /* Warn about format/argument anomalies in calls to formatted I/O functions
278 (*printf, *scanf, strftime, strfmon, etc.). */
282 /* Warn about using __null (as NULL in C++) as sentinel. For code compiled
283 with GCC this doesn't matter as __null is guaranteed to have the right
286 int warn_strict_null_sentinel;
288 /* Zero means that faster, ...NonNil variants of objc_msgSend...
289 calls will be used in ObjC; passing nil receivers to such calls
290 will most likely result in crashes. */
291 int flag_nil_receivers = 1;
293 /* Nonzero means that code generation will be altered to support
294 "zero-link" execution. This currently affects ObjC only, but may
295 affect other languages in the future. */
296 int flag_zero_link = 0;
298 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
299 unit. It will inform the ObjC runtime that class definition(s) herein
300 contained are to replace one(s) previously loaded. */
301 int flag_replace_objc_classes = 0;
303 /* C/ObjC language option variables. */
306 /* Nonzero means allow type mismatches in conditional expressions;
307 just make their values `void'. */
309 int flag_cond_mismatch;
311 /* Nonzero means enable C89 Amendment 1 features. */
315 /* Nonzero means use the ISO C99 dialect of C. */
319 /* Nonzero means that we have builtin functions, and main is an int. */
323 /* Warn if main is suspicious. */
328 /* ObjC language option variables. */
331 /* Open and close the file for outputting class declarations, if
334 int flag_gen_declaration;
336 /* Tells the compiler that this is a special run. Do not perform any
337 compiling, instead we are to test some platform dependent features
338 and output a C header file with appropriate definitions. */
340 int print_struct_values;
342 /* Tells the compiler what is the constant string class for Objc. */
344 const char *constant_string_class_name;
347 /* C++ language option variables. */
350 /* Nonzero means don't recognize any extension keywords. */
352 int flag_no_gnu_keywords;
354 /* Nonzero means do emit exported implementations of functions even if
355 they can be inlined. */
357 int flag_implement_inlines = 1;
359 /* Nonzero means that implicit instantiations will be emitted if needed. */
361 int flag_implicit_templates = 1;
363 /* Nonzero means that implicit instantiations of inline templates will be
364 emitted if needed, even if instantiations of non-inline templates
367 int flag_implicit_inline_templates = 1;
369 /* Nonzero means generate separate instantiation control files and
370 juggle them at link time. */
372 int flag_use_repository;
374 /* Nonzero if we want to issue diagnostics that the standard says are not
377 int flag_optional_diags = 1;
379 /* Nonzero means we should attempt to elide constructors when possible. */
381 int flag_elide_constructors = 1;
383 /* Nonzero means that member functions defined in class scope are
384 inline by default. */
386 int flag_default_inline = 1;
388 /* Controls whether compiler generates 'type descriptor' that give
389 run-time type information. */
393 /* Nonzero if we want to conserve space in the .o files. We do this
394 by putting uninitialized data and runtime initialized data into
395 .common instead of .data at the expense of not flagging multiple
398 int flag_conserve_space;
400 /* Nonzero if we want to obey access control semantics. */
402 int flag_access_control = 1;
404 /* Nonzero if we want to check the return value of new and avoid calling
405 constructors if it is a null pointer. */
409 /* The C++ dialect being used. C++98 is the default. */
411 enum cxx_dialect cxx_dialect = cxx98;
413 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
414 initialization variables.
415 0: Old rules, set by -fno-for-scope.
416 2: New ISO rules, set by -ffor-scope.
417 1: Try to implement new ISO rules, but with backup compatibility
418 (and warnings). This is the default, for now. */
420 int flag_new_for_scope = 1;
422 /* Nonzero if we want to emit defined symbols with common-like linkage as
423 weak symbols where possible, in order to conform to C++ semantics.
424 Otherwise, emit them as local symbols. */
428 /* 0 means we want the preprocessor to not emit line directives for
429 the current working directory. 1 means we want it to do it. -1
430 means we should decide depending on whether debugging information
431 is being emitted or not. */
433 int flag_working_directory = -1;
435 /* Nonzero to use __cxa_atexit, rather than atexit, to register
436 destructors for local statics and global objects. '2' means it has been
437 set nonzero as a default, not by a command-line flag. */
439 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
441 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
442 code. '2' means it has not been set explicitly on the command line. */
444 int flag_use_cxa_get_exception_ptr = 2;
446 /* Nonzero means make the default pedwarns warnings instead of errors.
447 The value of this flag is ignored if -pedantic is specified. */
451 /* Nonzero means to implement standard semantics for exception
452 specifications, calling unexpected if an exception is thrown that
453 doesn't match the specification. Zero means to treat them as
454 assertions and optimize accordingly, but not check them. */
456 int flag_enforce_eh_specs = 1;
458 /* Nonzero means to generate thread-safe code for initializing local
461 int flag_threadsafe_statics = 1;
463 /* Nonzero means warn about implicit declarations. */
465 int warn_implicit = 1;
467 /* Maximum template instantiation depth. This limit is rather
468 arbitrary, but it exists to limit the time it takes to notice
469 infinite template instantiations. */
471 int max_tinst_depth = 500;
475 /* The elements of `ridpointers' are identifier nodes for the reserved
476 type names and storage classes. It is indexed by a RID_... value. */
479 tree (*make_fname_decl) (tree, int);
481 /* Nonzero means the expression being parsed will never be evaluated.
482 This is a count, since unevaluated expressions can nest. */
485 /* Information about how a function name is generated. */
488 tree *const decl; /* pointer to the VAR_DECL. */
489 const unsigned rid; /* RID number for the identifier. */
490 const int pretty; /* How pretty is it? */
493 /* The three ways of getting then name of the current function. */
495 const struct fname_var_t fname_vars[] =
497 /* C99 compliant __func__, must be first. */
498 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
499 /* GCC __FUNCTION__ compliant. */
500 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
501 /* GCC __PRETTY_FUNCTION__ compliant. */
502 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
506 static tree check_case_value (tree);
507 static bool check_case_bounds (tree, tree, tree *, tree *);
509 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
510 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
511 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
512 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
513 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
514 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
515 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
516 static tree handle_always_inline_attribute (tree *, tree, tree, int,
518 static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
520 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
521 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
522 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
523 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
525 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_transparent_union_attribute (tree *, tree, tree,
528 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
532 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
533 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
534 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
535 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
536 static tree handle_visibility_attribute (tree *, tree, tree, int,
538 static tree handle_tls_model_attribute (tree *, tree, tree, int,
540 static tree handle_no_instrument_function_attribute (tree *, tree,
542 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
543 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
544 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
546 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
547 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
548 static tree handle_deprecated_attribute (tree *, tree, tree, int,
550 static tree handle_vector_size_attribute (tree *, tree, tree, int,
552 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
553 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
554 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
555 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
557 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
558 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
559 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
561 static void check_function_nonnull (tree, int, tree *);
562 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
563 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
564 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
565 static int resort_field_decl_cmp (const void *, const void *);
567 /* Table of machine-independent attributes common to all C-like languages. */
568 const struct attribute_spec c_common_attribute_table[] =
570 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
571 { "packed", 0, 0, false, false, false,
572 handle_packed_attribute },
573 { "nocommon", 0, 0, true, false, false,
574 handle_nocommon_attribute },
575 { "common", 0, 0, true, false, false,
576 handle_common_attribute },
577 /* FIXME: logically, noreturn attributes should be listed as
578 "false, true, true" and apply to function types. But implementing this
579 would require all the places in the compiler that use TREE_THIS_VOLATILE
580 on a decl to identify non-returning functions to be located and fixed
581 to check the function type instead. */
582 { "noreturn", 0, 0, true, false, false,
583 handle_noreturn_attribute },
584 { "volatile", 0, 0, true, false, false,
585 handle_noreturn_attribute },
586 { "noinline", 0, 0, true, false, false,
587 handle_noinline_attribute },
588 { "always_inline", 0, 0, true, false, false,
589 handle_always_inline_attribute },
590 { "gnu_inline", 0, 0, true, false, false,
591 handle_gnu_inline_attribute },
592 { "flatten", 0, 0, true, false, false,
593 handle_flatten_attribute },
594 { "used", 0, 0, true, false, false,
595 handle_used_attribute },
596 { "unused", 0, 0, false, false, false,
597 handle_unused_attribute },
598 { "externally_visible", 0, 0, true, false, false,
599 handle_externally_visible_attribute },
600 /* The same comments as for noreturn attributes apply to const ones. */
601 { "const", 0, 0, true, false, false,
602 handle_const_attribute },
603 { "transparent_union", 0, 0, false, false, false,
604 handle_transparent_union_attribute },
605 { "constructor", 0, 1, true, false, false,
606 handle_constructor_attribute },
607 { "destructor", 0, 1, true, false, false,
608 handle_destructor_attribute },
609 { "mode", 1, 1, false, true, false,
610 handle_mode_attribute },
611 { "section", 1, 1, true, false, false,
612 handle_section_attribute },
613 { "aligned", 0, 1, false, false, false,
614 handle_aligned_attribute },
615 { "weak", 0, 0, true, false, false,
616 handle_weak_attribute },
617 { "alias", 1, 1, true, false, false,
618 handle_alias_attribute },
619 { "weakref", 0, 1, true, false, false,
620 handle_weakref_attribute },
621 { "no_instrument_function", 0, 0, true, false, false,
622 handle_no_instrument_function_attribute },
623 { "malloc", 0, 0, true, false, false,
624 handle_malloc_attribute },
625 { "returns_twice", 0, 0, true, false, false,
626 handle_returns_twice_attribute },
627 { "no_stack_limit", 0, 0, true, false, false,
628 handle_no_limit_stack_attribute },
629 { "pure", 0, 0, true, false, false,
630 handle_pure_attribute },
631 /* For internal use (marking of builtins) only. The name contains space
632 to prevent its usage in source code. */
633 { "no vops", 0, 0, true, false, false,
634 handle_novops_attribute },
635 { "deprecated", 0, 0, false, false, false,
636 handle_deprecated_attribute },
637 { "vector_size", 1, 1, false, true, false,
638 handle_vector_size_attribute },
639 { "visibility", 1, 1, false, false, false,
640 handle_visibility_attribute },
641 { "tls_model", 1, 1, true, false, false,
642 handle_tls_model_attribute },
643 { "nonnull", 0, -1, false, true, true,
644 handle_nonnull_attribute },
645 { "nothrow", 0, 0, true, false, false,
646 handle_nothrow_attribute },
647 { "may_alias", 0, 0, false, true, false, NULL },
648 { "cleanup", 1, 1, true, false, false,
649 handle_cleanup_attribute },
650 { "warn_unused_result", 0, 0, false, true, true,
651 handle_warn_unused_result_attribute },
652 { "sentinel", 0, 1, false, true, true,
653 handle_sentinel_attribute },
654 /* For internal use (marking of builtins) only. The name contains space
655 to prevent its usage in source code. */
656 { "type generic", 0, 0, false, true, true,
657 handle_type_generic_attribute },
658 { "alloc_size", 1, 2, false, true, true,
659 handle_alloc_size_attribute },
660 { "cold", 0, 0, true, false, false,
661 handle_cold_attribute },
662 { "hot", 0, 0, true, false, false,
663 handle_hot_attribute },
664 { NULL, 0, 0, false, false, false, NULL }
667 /* Give the specifications for the format attributes, used by C and all
670 const struct attribute_spec c_common_format_attribute_table[] =
672 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
673 { "format", 3, 3, false, true, true,
674 handle_format_attribute },
675 { "format_arg", 1, 1, false, true, true,
676 handle_format_arg_attribute },
677 { NULL, 0, 0, false, false, false, NULL }
680 /* Push current bindings for the function name VAR_DECLS. */
683 start_fname_decls (void)
686 tree saved = NULL_TREE;
688 for (ix = 0; fname_vars[ix].decl; ix++)
690 tree decl = *fname_vars[ix].decl;
694 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
695 *fname_vars[ix].decl = NULL_TREE;
698 if (saved || saved_function_name_decls)
699 /* Normally they'll have been NULL, so only push if we've got a
700 stack, or they are non-NULL. */
701 saved_function_name_decls = tree_cons (saved, NULL_TREE,
702 saved_function_name_decls);
705 /* Finish up the current bindings, adding them into the current function's
706 statement tree. This must be done _before_ finish_stmt_tree is called.
707 If there is no current function, we must be at file scope and no statements
708 are involved. Pop the previous bindings. */
711 finish_fname_decls (void)
714 tree stmts = NULL_TREE;
715 tree stack = saved_function_name_decls;
717 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
718 append_to_statement_list (TREE_VALUE (stack), &stmts);
722 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
724 if (TREE_CODE (*bodyp) == BIND_EXPR)
725 bodyp = &BIND_EXPR_BODY (*bodyp);
727 append_to_statement_list_force (*bodyp, &stmts);
731 for (ix = 0; fname_vars[ix].decl; ix++)
732 *fname_vars[ix].decl = NULL_TREE;
736 /* We had saved values, restore them. */
739 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
741 tree decl = TREE_PURPOSE (saved);
742 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
744 *fname_vars[ix].decl = decl;
746 stack = TREE_CHAIN (stack);
748 saved_function_name_decls = stack;
751 /* Return the text name of the current function, suitably prettified
752 by PRETTY_P. Return string must be freed by caller. */
755 fname_as_string (int pretty_p)
757 const char *name = "top level";
760 cpp_string cstr = { 0, 0 }, strname;
768 if (current_function_decl)
769 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
771 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
773 namep = XNEWVEC (char, len);
774 snprintf (namep, len, "\"%s\"", name);
775 strname.text = (unsigned char *) namep;
776 strname.len = len - 1;
778 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
781 return (const char *) cstr.text;
787 /* Expand DECL if it declares an entity not handled by the
791 c_expand_decl (tree decl)
793 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
795 /* Let the back-end know about this variable. */
796 if (!anon_aggr_type_p (TREE_TYPE (decl)))
797 emit_local_var (decl);
799 expand_anon_union_decl (decl, NULL_TREE,
800 DECL_ANON_UNION_ELEMS (decl));
809 /* Return the VAR_DECL for a const char array naming the current
810 function. If the VAR_DECL has not yet been created, create it
811 now. RID indicates how it should be formatted and IDENTIFIER_NODE
812 ID is its name (unfortunately C and C++ hold the RID values of
813 keywords in different places, so we can't derive RID from ID in
814 this language independent code. */
817 fname_decl (unsigned int rid, tree id)
820 tree decl = NULL_TREE;
822 for (ix = 0; fname_vars[ix].decl; ix++)
823 if (fname_vars[ix].rid == rid)
826 decl = *fname_vars[ix].decl;
829 /* If a tree is built here, it would normally have the lineno of
830 the current statement. Later this tree will be moved to the
831 beginning of the function and this line number will be wrong.
832 To avoid this problem set the lineno to 0 here; that prevents
833 it from appearing in the RTL. */
835 location_t saved_location = input_location;
836 #ifdef USE_MAPPED_LOCATION
837 input_location = UNKNOWN_LOCATION;
842 stmts = push_stmt_list ();
843 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
844 stmts = pop_stmt_list (stmts);
845 if (!IS_EMPTY_STMT (stmts))
846 saved_function_name_decls
847 = tree_cons (decl, stmts, saved_function_name_decls);
848 *fname_vars[ix].decl = decl;
849 input_location = saved_location;
851 if (!ix && !current_function_decl)
852 pedwarn ("%qD is not defined outside of function scope", decl);
857 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
860 fix_string_type (tree value)
862 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
863 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
864 int length = TREE_STRING_LENGTH (value);
866 tree e_type, i_type, a_type;
868 /* Compute the number of elements, for the array type. */
869 nchars = wide_flag ? length / wchar_bytes : length;
871 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
872 limit in C++98 Annex B is very large (65536) and is not normative,
873 so we do not diagnose it (warn_overlength_strings is forced off
874 in c_common_post_options). */
875 if (warn_overlength_strings)
877 const int nchars_max = flag_isoc99 ? 4095 : 509;
878 const int relevant_std = flag_isoc99 ? 99 : 90;
879 if (nchars - 1 > nchars_max)
880 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
881 separate the %d from the 'C'. 'ISO' should not be
882 translated, but it may be moved after 'C%d' in languages
883 where modifiers follow nouns. */
884 pedwarn ("string length %qd is greater than the length %qd "
885 "ISO C%d compilers are required to support",
886 nchars - 1, nchars_max, relevant_std);
889 /* Create the array type for the string constant. The ISO C++
890 standard says that a string literal has type `const char[N]' or
891 `const wchar_t[N]'. We use the same logic when invoked as a C
892 front-end with -Wwrite-strings.
893 ??? We should change the type of an expression depending on the
894 state of a warning flag. We should just be warning -- see how
895 this is handled in the C++ front-end for the deprecated implicit
896 conversion from string literals to `char*' or `wchar_t*'.
898 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
899 array type being the unqualified version of that type.
900 Therefore, if we are constructing an array of const char, we must
901 construct the matching unqualified array type first. The C front
902 end does not require this, but it does no harm, so we do it
904 e_type = wide_flag ? wchar_type_node : char_type_node;
905 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
906 a_type = build_array_type (e_type, i_type);
907 if (c_dialect_cxx() || warn_write_strings)
908 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
910 TREE_TYPE (value) = a_type;
911 TREE_CONSTANT (value) = 1;
912 TREE_INVARIANT (value) = 1;
913 TREE_READONLY (value) = 1;
914 TREE_STATIC (value) = 1;
918 /* Print a warning if a constant expression had overflow in folding.
919 Invoke this function on every expression that the language
920 requires to be a constant expression.
921 Note the ANSI C standard says it is erroneous for a
922 constant expression to overflow. */
925 constant_expression_warning (tree value)
927 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
928 || TREE_CODE (value) == FIXED_CST
929 || TREE_CODE (value) == VECTOR_CST
930 || TREE_CODE (value) == COMPLEX_CST)
931 && TREE_OVERFLOW (value)
934 pedwarn ("overflow in constant expression");
937 /* Print a warning if an expression had overflow in folding and its
940 Invoke this function on every expression that
941 (1) appears in the source code, and
942 (2) is a constant expression that overflowed, and
943 (3) is not already checked by convert_and_check;
944 however, do not invoke this function on operands of explicit casts
945 or when the expression is the result of an operator and any operand
946 already overflowed. */
949 overflow_warning (tree value)
951 if (skip_evaluation) return;
953 switch (TREE_CODE (value))
956 warning (OPT_Woverflow, "integer overflow in expression");
960 warning (OPT_Woverflow, "floating point overflow in expression");
964 warning (OPT_Woverflow, "fixed-point overflow in expression");
968 warning (OPT_Woverflow, "vector overflow in expression");
972 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
973 warning (OPT_Woverflow, "complex integer overflow in expression");
974 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
975 warning (OPT_Woverflow, "complex floating point overflow in expression");
984 /* Warn about use of a logical || / && operator being used in a
985 context where it is likely that the bitwise equivalent was intended
986 by the programmer. CODE is the TREE_CODE of the operator, ARG1
987 and ARG2 the arguments. */
990 warn_logical_operator (enum tree_code code, tree arg1, tree
995 case TRUTH_ANDIF_EXPR:
996 case TRUTH_ORIF_EXPR:
999 if (!TREE_NO_WARNING (arg1)
1000 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
1001 && !CONSTANT_CLASS_P (arg1)
1002 && TREE_CODE (arg2) == INTEGER_CST
1003 && !integer_zerop (arg2))
1005 warning (OPT_Wlogical_op,
1006 "logical %<%s%> with non-zero constant "
1007 "will always evaluate as true",
1008 ((code == TRUTH_ANDIF_EXPR)
1009 || (code == TRUTH_AND_EXPR)) ? "&&" : "||");
1010 TREE_NO_WARNING (arg1) = true;
1019 /* Print a warning about casts that might indicate violation
1020 of strict aliasing rules if -Wstrict-aliasing is used and
1021 strict aliasing mode is in effect. OTYPE is the original
1022 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1025 strict_aliasing_warning (tree otype, tree type, tree expr)
1027 if (!(flag_strict_aliasing && POINTER_TYPE_P (type)
1028 && POINTER_TYPE_P (otype) && !VOID_TYPE_P (TREE_TYPE (type))))
1031 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1032 && (DECL_P (TREE_OPERAND (expr, 0))
1033 || handled_component_p (TREE_OPERAND (expr, 0))))
1035 /* Casting the address of an object to non void pointer. Warn
1036 if the cast breaks type based aliasing. */
1037 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1039 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1040 "might break strict-aliasing rules");
1045 /* warn_strict_aliasing >= 3. This includes the default (3).
1046 Only warn if the cast is dereferenced immediately. */
1047 alias_set_type set1 =
1048 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1049 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1051 if (!alias_sets_conflict_p (set1, set2))
1053 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1054 "pointer will break strict-aliasing rules");
1057 else if (warn_strict_aliasing == 2
1058 && !alias_sets_must_conflict_p (set1, set2))
1060 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1061 "pointer might break strict-aliasing rules");
1067 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1069 /* At this level, warn for any conversions, even if an address is
1070 not taken in the same statement. This will likely produce many
1071 false positives, but could be useful to pinpoint problems that
1072 are not revealed at higher levels. */
1073 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1074 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1075 if (!COMPLETE_TYPE_P (type)
1076 || !alias_sets_must_conflict_p (set1, set2))
1078 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1079 "pointer might break strict-aliasing rules");
1087 /* Print a warning about if (); or if () .. else; constructs
1088 via the special empty statement node that we create. INNER_THEN
1089 and INNER_ELSE are the statement lists of the if and the else
1093 empty_if_body_warning (tree inner_then, tree inner_else)
1095 if (TREE_CODE (inner_then) == STATEMENT_LIST
1096 && STATEMENT_LIST_TAIL (inner_then))
1097 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1099 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1100 && STATEMENT_LIST_TAIL (inner_else))
1101 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1103 if (IS_EMPTY_STMT (inner_then) && !inner_else)
1104 warning (OPT_Wempty_body, "%Hsuggest braces around empty body "
1105 "in an %<if%> statement", EXPR_LOCUS (inner_then));
1107 else if (inner_else && IS_EMPTY_STMT (inner_else))
1108 warning (OPT_Wempty_body, "%Hsuggest braces around empty body "
1109 "in an %<else%> statement", EXPR_LOCUS (inner_else));
1112 /* Warn for unlikely, improbable, or stupid DECL declarations
1116 check_main_parameter_types (tree decl)
1121 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1122 args = TREE_CHAIN (args))
1124 tree type = args ? TREE_VALUE (args) : 0;
1126 if (type == void_type_node || type == error_mark_node )
1133 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1134 pedwarn ("first argument of %q+D should be %<int%>", decl);
1138 if (TREE_CODE (type) != POINTER_TYPE
1139 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1140 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1142 pedwarn ("second argument of %q+D should be %<char **%>",
1147 if (TREE_CODE (type) != POINTER_TYPE
1148 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1149 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1151 pedwarn ("third argument of %q+D should probably be "
1152 "%<char **%>", decl);
1157 /* It is intentional that this message does not mention the third
1158 argument because it's only mentioned in an appendix of the
1160 if (argct > 0 && (argct < 2 || argct > 3))
1161 pedwarn ("%q+D takes only zero or two arguments", decl);
1164 /* True if vector types T1 and T2 can be converted to each other
1165 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1166 can only be converted with -flax-vector-conversions yet that is not
1167 in effect, emit a note telling the user about that option if such
1168 a note has not previously been emitted. */
1170 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1172 static bool emitted_lax_note = false;
1173 bool convertible_lax;
1175 if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1176 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1180 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1181 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1182 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1183 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1184 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1186 if (!convertible_lax || flag_lax_vector_conversions)
1187 return convertible_lax;
1189 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1190 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2)))
1193 if (emit_lax_note && !emitted_lax_note)
1195 emitted_lax_note = true;
1196 inform ("use -flax-vector-conversions to permit "
1197 "conversions between vectors with differing "
1198 "element types or numbers of subparts");
1204 /* Warns if the conversion of EXPR to TYPE may alter a value.
1205 This is a helper function for warnings_for_convert_and_check. */
1208 conversion_warning (tree type, tree expr)
1210 bool give_warning = false;
1212 unsigned int formal_prec = TYPE_PRECISION (type);
1214 if (!warn_conversion && !warn_sign_conversion)
1217 if (TREE_CODE (expr) == REAL_CST || TREE_CODE (expr) == INTEGER_CST)
1219 /* Warn for real constant that is not an exact integer converted
1221 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1222 && TREE_CODE (type) == INTEGER_TYPE)
1224 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (TREE_TYPE (expr))))
1225 give_warning = true;
1227 /* Warn for an integer constant that does not fit into integer type. */
1228 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1229 && TREE_CODE (type) == INTEGER_TYPE
1230 && !int_fits_type_p (expr, type))
1232 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr)))
1233 warning (OPT_Wsign_conversion,
1234 "negative integer implicitly converted to unsigned type");
1235 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (TREE_TYPE (expr)))
1236 warning (OPT_Wsign_conversion,
1237 "conversion of unsigned constant value to negative integer");
1239 give_warning = true;
1241 else if (TREE_CODE (type) == REAL_TYPE)
1243 /* Warn for an integer constant that does not fit into real type. */
1244 if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE)
1246 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1247 if (!exact_real_truncate (TYPE_MODE (type), &a))
1248 give_warning = true;
1250 /* Warn for a real constant that does not fit into a smaller
1252 else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1253 && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1255 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1256 if (!exact_real_truncate (TYPE_MODE (type), &a))
1257 give_warning = true;
1262 warning (OPT_Wconversion,
1263 "conversion to %qT alters %qT constant value",
1264 type, TREE_TYPE (expr));
1266 else /* 'expr' is not a constant. */
1268 /* Warn for real types converted to integer types. */
1269 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1270 && TREE_CODE (type) == INTEGER_TYPE)
1271 give_warning = true;
1273 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1274 && TREE_CODE (type) == INTEGER_TYPE)
1276 /* Warn for integer types converted to smaller integer types. */
1277 if (formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1278 give_warning = true;
1280 /* When they are the same width but different signedness,
1281 then the value may change. */
1282 else if ((formal_prec == TYPE_PRECISION (TREE_TYPE (expr))
1283 && TYPE_UNSIGNED (TREE_TYPE (expr)) != TYPE_UNSIGNED (type))
1284 /* Even when converted to a bigger type, if the type is
1285 unsigned but expr is signed, then negative values
1287 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (TREE_TYPE (expr))))
1288 warning (OPT_Wsign_conversion,
1289 "conversion to %qT from %qT may change the sign of the result",
1290 type, TREE_TYPE (expr));
1293 /* Warn for integer types converted to real types if and only if
1294 all the range of values of the integer type cannot be
1295 represented by the real type. */
1296 else if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1297 && TREE_CODE (type) == REAL_TYPE)
1299 tree type_low_bound = TYPE_MIN_VALUE (TREE_TYPE (expr));
1300 tree type_high_bound = TYPE_MAX_VALUE (TREE_TYPE (expr));
1301 REAL_VALUE_TYPE real_low_bound = real_value_from_int_cst (0, type_low_bound);
1302 REAL_VALUE_TYPE real_high_bound = real_value_from_int_cst (0, type_high_bound);
1304 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1305 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1306 give_warning = true;
1309 /* Warn for real types converted to smaller real types. */
1310 else if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
1311 && TREE_CODE (type) == REAL_TYPE
1312 && formal_prec < TYPE_PRECISION (TREE_TYPE (expr)))
1313 give_warning = true;
1317 warning (OPT_Wconversion,
1318 "conversion to %qT from %qT may alter its value",
1319 type, TREE_TYPE (expr));
1323 /* Produce warnings after a conversion. RESULT is the result of
1324 converting EXPR to TYPE. This is a helper function for
1325 convert_and_check and cp_convert_and_check. */
1328 warnings_for_convert_and_check (tree type, tree expr, tree result)
1330 if (TREE_CODE (expr) == INTEGER_CST
1331 && (TREE_CODE (type) == INTEGER_TYPE
1332 || TREE_CODE (type) == ENUMERAL_TYPE)
1333 && !int_fits_type_p (expr, type))
1335 /* Do not diagnose overflow in a constant expression merely
1336 because a conversion overflowed. */
1337 if (TREE_OVERFLOW (result))
1338 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1340 if (TYPE_UNSIGNED (type))
1342 /* This detects cases like converting -129 or 256 to
1344 if (!int_fits_type_p (expr, c_common_signed_type (type)))
1345 warning (OPT_Woverflow,
1346 "large integer implicitly truncated to unsigned type");
1348 conversion_warning (type, expr);
1350 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
1351 warning (OPT_Woverflow,
1352 "overflow in implicit constant conversion");
1353 /* No warning for converting 0x80000000 to int. */
1355 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1356 || TYPE_PRECISION (TREE_TYPE (expr))
1357 != TYPE_PRECISION (type)))
1358 warning (OPT_Woverflow,
1359 "overflow in implicit constant conversion");
1362 conversion_warning (type, expr);
1364 else if ((TREE_CODE (result) == INTEGER_CST
1365 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
1366 warning (OPT_Woverflow,
1367 "overflow in implicit constant conversion");
1369 conversion_warning (type, expr);
1373 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1374 Invoke this function on every expression that is converted implicitly,
1375 i.e. because of language rules and not because of an explicit cast. */
1378 convert_and_check (tree type, tree expr)
1382 if (TREE_TYPE (expr) == type)
1385 result = convert (type, expr);
1387 if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
1388 warnings_for_convert_and_check (type, expr, result);
1393 /* A node in a list that describes references to variables (EXPR), which are
1394 either read accesses if WRITER is zero, or write accesses, in which case
1395 WRITER is the parent of EXPR. */
1402 /* Used to implement a cache the results of a call to verify_tree. We only
1403 use this for SAVE_EXPRs. */
1406 struct tlist_cache *next;
1407 struct tlist *cache_before_sp;
1408 struct tlist *cache_after_sp;
1412 /* Obstack to use when allocating tlist structures, and corresponding
1414 static struct obstack tlist_obstack;
1415 static char *tlist_firstobj = 0;
1417 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1419 static struct tlist *warned_ids;
1420 /* SAVE_EXPRs need special treatment. We process them only once and then
1421 cache the results. */
1422 static struct tlist_cache *save_expr_cache;
1424 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1425 static void merge_tlist (struct tlist **, struct tlist *, int);
1426 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1427 static int warning_candidate_p (tree);
1428 static void warn_for_collisions (struct tlist *);
1429 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1430 static struct tlist *new_tlist (struct tlist *, tree, tree);
1432 /* Create a new struct tlist and fill in its fields. */
1433 static struct tlist *
1434 new_tlist (struct tlist *next, tree t, tree writer)
1437 l = XOBNEW (&tlist_obstack, struct tlist);
1444 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1445 is nonnull, we ignore any node we find which has a writer equal to it. */
1448 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1452 struct tlist *next = add->next;
1455 if (!exclude_writer || add->writer != exclude_writer)
1456 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1461 /* Merge the nodes of ADD into TO. This merging process is done so that for
1462 each variable that already exists in TO, no new node is added; however if
1463 there is a write access recorded in ADD, and an occurrence on TO is only
1464 a read access, then the occurrence in TO will be modified to record the
1468 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1470 struct tlist **end = to;
1473 end = &(*end)->next;
1479 struct tlist *next = add->next;
1481 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1482 if (tmp2->expr == add->expr)
1486 tmp2->writer = add->writer;
1490 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1491 end = &(*end)->next;
1498 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1499 references in list LIST conflict with it, excluding reads if ONLY writers
1503 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1508 /* Avoid duplicate warnings. */
1509 for (tmp = warned_ids; tmp; tmp = tmp->next)
1510 if (tmp->expr == written)
1515 if (list->expr == written
1516 && list->writer != writer
1517 && (!only_writes || list->writer)
1518 && DECL_NAME (list->expr))
1520 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1521 warning (0, "operation on %qE may be undefined", list->expr);
1527 /* Given a list LIST of references to variables, find whether any of these
1528 can cause conflicts due to missing sequence points. */
1531 warn_for_collisions (struct tlist *list)
1535 for (tmp = list; tmp; tmp = tmp->next)
1538 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1542 /* Return nonzero if X is a tree that can be verified by the sequence point
1545 warning_candidate_p (tree x)
1547 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1550 /* Walk the tree X, and record accesses to variables. If X is written by the
1551 parent tree, WRITER is the parent.
1552 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1553 expression or its only operand forces a sequence point, then everything up
1554 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1556 Once we return, we will have emitted warnings if any subexpression before
1557 such a sequence point could be undefined. On a higher level, however, the
1558 sequence point may not be relevant, and we'll merge the two lists.
1560 Example: (b++, a) + b;
1561 The call that processes the COMPOUND_EXPR will store the increment of B
1562 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1563 processes the PLUS_EXPR will need to merge the two lists so that
1564 eventually, all accesses end up on the same list (and we'll warn about the
1565 unordered subexpressions b++ and b.
1567 A note on merging. If we modify the former example so that our expression
1570 care must be taken not simply to add all three expressions into the final
1571 PNO_SP list. The function merge_tlist takes care of that by merging the
1572 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1573 way, so that no more than one access to B is recorded. */
1576 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1579 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1580 enum tree_code code;
1581 enum tree_code_class cl;
1583 /* X may be NULL if it is the operand of an empty statement expression
1589 code = TREE_CODE (x);
1590 cl = TREE_CODE_CLASS (code);
1592 if (warning_candidate_p (x))
1594 *pno_sp = new_tlist (*pno_sp, x, writer);
1604 case TRUTH_ANDIF_EXPR:
1605 case TRUTH_ORIF_EXPR:
1606 tmp_before = tmp_nosp = tmp_list3 = 0;
1607 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1608 warn_for_collisions (tmp_nosp);
1609 merge_tlist (pbefore_sp, tmp_before, 0);
1610 merge_tlist (pbefore_sp, tmp_nosp, 0);
1611 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1612 merge_tlist (pbefore_sp, tmp_list3, 0);
1616 tmp_before = tmp_list2 = 0;
1617 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1618 warn_for_collisions (tmp_list2);
1619 merge_tlist (pbefore_sp, tmp_before, 0);
1620 merge_tlist (pbefore_sp, tmp_list2, 1);
1622 tmp_list3 = tmp_nosp = 0;
1623 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1624 warn_for_collisions (tmp_nosp);
1625 merge_tlist (pbefore_sp, tmp_list3, 0);
1627 tmp_list3 = tmp_list2 = 0;
1628 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1629 warn_for_collisions (tmp_list2);
1630 merge_tlist (pbefore_sp, tmp_list3, 0);
1631 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1632 two first, to avoid warning for (a ? b++ : b++). */
1633 merge_tlist (&tmp_nosp, tmp_list2, 0);
1634 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1637 case PREDECREMENT_EXPR:
1638 case PREINCREMENT_EXPR:
1639 case POSTDECREMENT_EXPR:
1640 case POSTINCREMENT_EXPR:
1641 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1645 tmp_before = tmp_nosp = tmp_list3 = 0;
1646 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1647 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1648 /* Expressions inside the LHS are not ordered wrt. the sequence points
1649 in the RHS. Example:
1651 Despite the fact that the modification of "a" is in the before_sp
1652 list (tmp_before), it conflicts with the use of "a" in the LHS.
1653 We can handle this by adding the contents of tmp_list3
1654 to those of tmp_before, and redoing the collision warnings for that
1656 add_tlist (&tmp_before, tmp_list3, x, 1);
1657 warn_for_collisions (tmp_before);
1658 /* Exclude the LHS itself here; we first have to merge it into the
1659 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1660 didn't exclude the LHS, we'd get it twice, once as a read and once
1662 add_tlist (pno_sp, tmp_list3, x, 0);
1663 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1665 merge_tlist (pbefore_sp, tmp_before, 0);
1666 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1667 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1668 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1672 /* We need to warn about conflicts among arguments and conflicts between
1673 args and the function address. Side effects of the function address,
1674 however, are not ordered by the sequence point of the call. */
1676 call_expr_arg_iterator iter;
1678 tmp_before = tmp_nosp = 0;
1679 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
1680 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
1682 tmp_list2 = tmp_list3 = 0;
1683 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
1684 merge_tlist (&tmp_list3, tmp_list2, 0);
1685 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1687 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1688 warn_for_collisions (tmp_before);
1689 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1694 /* Scan all the list, e.g. indices of multi dimensional array. */
1697 tmp_before = tmp_nosp = 0;
1698 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1699 merge_tlist (&tmp_nosp, tmp_before, 0);
1700 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1707 struct tlist_cache *t;
1708 for (t = save_expr_cache; t; t = t->next)
1714 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1715 t->next = save_expr_cache;
1717 save_expr_cache = t;
1719 tmp_before = tmp_nosp = 0;
1720 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1721 warn_for_collisions (tmp_nosp);
1726 struct tlist *t = tmp_nosp;
1728 merge_tlist (&tmp_list3, t, 0);
1730 t->cache_before_sp = tmp_before;
1731 t->cache_after_sp = tmp_list3;
1733 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1734 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1739 /* For other expressions, simply recurse on their operands.
1740 Manual tail recursion for unary expressions.
1741 Other non-expressions need not be processed. */
1742 if (cl == tcc_unary)
1744 x = TREE_OPERAND (x, 0);
1748 else if (IS_EXPR_CODE_CLASS (cl))
1751 int max = TREE_OPERAND_LENGTH (x);
1752 for (lp = 0; lp < max; lp++)
1754 tmp_before = tmp_nosp = 0;
1755 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1756 merge_tlist (&tmp_nosp, tmp_before, 0);
1757 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1764 /* Try to warn for undefined behavior in EXPR due to missing sequence
1768 verify_sequence_points (tree expr)
1770 struct tlist *before_sp = 0, *after_sp = 0;
1773 save_expr_cache = 0;
1774 if (tlist_firstobj == 0)
1776 gcc_obstack_init (&tlist_obstack);
1777 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1780 verify_tree (expr, &before_sp, &after_sp, 0);
1781 warn_for_collisions (after_sp);
1782 obstack_free (&tlist_obstack, tlist_firstobj);
1785 /* Validate the expression after `case' and apply default promotions. */
1788 check_case_value (tree value)
1790 if (value == NULL_TREE)
1793 /* ??? Can we ever get nops here for a valid case value? We
1795 STRIP_TYPE_NOPS (value);
1796 /* In C++, the following is allowed:
1799 switch (...) { case i: ... }
1801 So, we try to reduce the VALUE to a constant that way. */
1802 if (c_dialect_cxx ())
1804 value = decl_constant_value (value);
1805 STRIP_TYPE_NOPS (value);
1806 value = fold (value);
1809 if (TREE_CODE (value) == INTEGER_CST)
1810 /* Promote char or short to int. */
1811 value = perform_integral_promotions (value);
1812 else if (value != error_mark_node)
1814 error ("case label does not reduce to an integer constant");
1815 value = error_mark_node;
1818 constant_expression_warning (value);
1823 /* See if the case values LOW and HIGH are in the range of the original
1824 type (i.e. before the default conversion to int) of the switch testing
1826 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1827 the type before promoting it. CASE_LOW_P is a pointer to the lower
1828 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1829 if the case is not a case range.
1830 The caller has to make sure that we are not called with NULL for
1831 CASE_LOW_P (i.e. the default case).
1832 Returns true if the case label is in range of ORIG_TYPE (saturated or
1833 untouched) or false if the label is out of range. */
1836 check_case_bounds (tree type, tree orig_type,
1837 tree *case_low_p, tree *case_high_p)
1839 tree min_value, max_value;
1840 tree case_low = *case_low_p;
1841 tree case_high = case_high_p ? *case_high_p : case_low;
1843 /* If there was a problem with the original type, do nothing. */
1844 if (orig_type == error_mark_node)
1847 min_value = TYPE_MIN_VALUE (orig_type);
1848 max_value = TYPE_MAX_VALUE (orig_type);
1850 /* Case label is less than minimum for type. */
1851 if (tree_int_cst_compare (case_low, min_value) < 0
1852 && tree_int_cst_compare (case_high, min_value) < 0)
1854 warning (0, "case label value is less than minimum value for type");
1858 /* Case value is greater than maximum for type. */
1859 if (tree_int_cst_compare (case_low, max_value) > 0
1860 && tree_int_cst_compare (case_high, max_value) > 0)
1862 warning (0, "case label value exceeds maximum value for type");
1866 /* Saturate lower case label value to minimum. */
1867 if (tree_int_cst_compare (case_high, min_value) >= 0
1868 && tree_int_cst_compare (case_low, min_value) < 0)
1870 warning (0, "lower value in case label range"
1871 " less than minimum value for type");
1872 case_low = min_value;
1875 /* Saturate upper case label value to maximum. */
1876 if (tree_int_cst_compare (case_low, max_value) <= 0
1877 && tree_int_cst_compare (case_high, max_value) > 0)
1879 warning (0, "upper value in case label range"
1880 " exceeds maximum value for type");
1881 case_high = max_value;
1884 if (*case_low_p != case_low)
1885 *case_low_p = convert (type, case_low);
1886 if (case_high_p && *case_high_p != case_high)
1887 *case_high_p = convert (type, case_high);
1892 /* Return an integer type with BITS bits of precision,
1893 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1896 c_common_type_for_size (unsigned int bits, int unsignedp)
1898 if (bits == TYPE_PRECISION (integer_type_node))
1899 return unsignedp ? unsigned_type_node : integer_type_node;
1901 if (bits == TYPE_PRECISION (signed_char_type_node))
1902 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1904 if (bits == TYPE_PRECISION (short_integer_type_node))
1905 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1907 if (bits == TYPE_PRECISION (long_integer_type_node))
1908 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1910 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1911 return (unsignedp ? long_long_unsigned_type_node
1912 : long_long_integer_type_node);
1914 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1915 return (unsignedp ? widest_unsigned_literal_type_node
1916 : widest_integer_literal_type_node);
1918 if (bits <= TYPE_PRECISION (intQI_type_node))
1919 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1921 if (bits <= TYPE_PRECISION (intHI_type_node))
1922 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1924 if (bits <= TYPE_PRECISION (intSI_type_node))
1925 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1927 if (bits <= TYPE_PRECISION (intDI_type_node))
1928 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1933 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
1934 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
1935 and saturating if SATP is nonzero, otherwise not saturating. */
1938 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
1939 int unsignedp, int satp)
1941 enum machine_mode mode;
1943 mode = unsignedp ? UQQmode : QQmode;
1945 mode = unsignedp ? UHAmode : HAmode;
1947 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
1948 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
1951 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
1953 sorry ("GCC cannot support operators with integer types and "
1954 "fixed-point types that have too many integral and "
1955 "fractional bits together");
1959 return c_common_type_for_mode (mode, satp);
1962 /* Used for communication between c_common_type_for_mode and
1963 c_register_builtin_type. */
1964 static GTY(()) tree registered_builtin_types;
1966 /* Return a data type that has machine mode MODE.
1967 If the mode is an integer,
1968 then UNSIGNEDP selects between signed and unsigned types.
1969 If the mode is a fixed-point mode,
1970 then UNSIGNEDP selects between saturating and nonsaturating types. */
1973 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1977 if (mode == TYPE_MODE (integer_type_node))
1978 return unsignedp ? unsigned_type_node : integer_type_node;
1980 if (mode == TYPE_MODE (signed_char_type_node))
1981 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1983 if (mode == TYPE_MODE (short_integer_type_node))
1984 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1986 if (mode == TYPE_MODE (long_integer_type_node))
1987 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1989 if (mode == TYPE_MODE (long_long_integer_type_node))
1990 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1992 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1993 return unsignedp ? widest_unsigned_literal_type_node
1994 : widest_integer_literal_type_node;
1997 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2000 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2003 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2006 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2008 #if HOST_BITS_PER_WIDE_INT >= 64
2009 if (mode == TYPE_MODE (intTI_type_node))
2010 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2013 if (mode == TYPE_MODE (float_type_node))
2014 return float_type_node;
2016 if (mode == TYPE_MODE (double_type_node))
2017 return double_type_node;
2019 if (mode == TYPE_MODE (long_double_type_node))
2020 return long_double_type_node;
2022 if (mode == TYPE_MODE (void_type_node))
2023 return void_type_node;
2025 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2027 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2028 : make_signed_type (GET_MODE_PRECISION (mode)));
2030 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2032 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2033 : make_signed_type (GET_MODE_PRECISION (mode)));
2035 if (COMPLEX_MODE_P (mode))
2037 enum machine_mode inner_mode;
2040 if (mode == TYPE_MODE (complex_float_type_node))
2041 return complex_float_type_node;
2042 if (mode == TYPE_MODE (complex_double_type_node))
2043 return complex_double_type_node;
2044 if (mode == TYPE_MODE (complex_long_double_type_node))
2045 return complex_long_double_type_node;
2047 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2048 return complex_integer_type_node;
2050 inner_mode = GET_MODE_INNER (mode);
2051 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2052 if (inner_type != NULL_TREE)
2053 return build_complex_type (inner_type);
2055 else if (VECTOR_MODE_P (mode))
2057 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2058 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2059 if (inner_type != NULL_TREE)
2060 return build_vector_type_for_mode (inner_type, mode);
2063 if (mode == TYPE_MODE (dfloat32_type_node))
2064 return dfloat32_type_node;
2065 if (mode == TYPE_MODE (dfloat64_type_node))
2066 return dfloat64_type_node;
2067 if (mode == TYPE_MODE (dfloat128_type_node))
2068 return dfloat128_type_node;
2070 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2072 if (mode == TYPE_MODE (short_fract_type_node))
2073 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2074 if (mode == TYPE_MODE (fract_type_node))
2075 return unsignedp ? sat_fract_type_node : fract_type_node;
2076 if (mode == TYPE_MODE (long_fract_type_node))
2077 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2078 if (mode == TYPE_MODE (long_long_fract_type_node))
2079 return unsignedp ? sat_long_long_fract_type_node
2080 : long_long_fract_type_node;
2082 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2083 return unsignedp ? sat_unsigned_short_fract_type_node
2084 : unsigned_short_fract_type_node;
2085 if (mode == TYPE_MODE (unsigned_fract_type_node))
2086 return unsignedp ? sat_unsigned_fract_type_node
2087 : unsigned_fract_type_node;
2088 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2089 return unsignedp ? sat_unsigned_long_fract_type_node
2090 : unsigned_long_fract_type_node;
2091 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2092 return unsignedp ? sat_unsigned_long_long_fract_type_node
2093 : unsigned_long_long_fract_type_node;
2095 if (mode == TYPE_MODE (short_accum_type_node))
2096 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2097 if (mode == TYPE_MODE (accum_type_node))
2098 return unsignedp ? sat_accum_type_node : accum_type_node;
2099 if (mode == TYPE_MODE (long_accum_type_node))
2100 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2101 if (mode == TYPE_MODE (long_long_accum_type_node))
2102 return unsignedp ? sat_long_long_accum_type_node
2103 : long_long_accum_type_node;
2105 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2106 return unsignedp ? sat_unsigned_short_accum_type_node
2107 : unsigned_short_accum_type_node;
2108 if (mode == TYPE_MODE (unsigned_accum_type_node))
2109 return unsignedp ? sat_unsigned_accum_type_node
2110 : unsigned_accum_type_node;
2111 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2112 return unsignedp ? sat_unsigned_long_accum_type_node
2113 : unsigned_long_accum_type_node;
2114 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2115 return unsignedp ? sat_unsigned_long_long_accum_type_node
2116 : unsigned_long_long_accum_type_node;
2119 return unsignedp ? sat_qq_type_node : qq_type_node;
2121 return unsignedp ? sat_hq_type_node : hq_type_node;
2123 return unsignedp ? sat_sq_type_node : sq_type_node;
2125 return unsignedp ? sat_dq_type_node : dq_type_node;
2127 return unsignedp ? sat_tq_type_node : tq_type_node;
2129 if (mode == UQQmode)
2130 return unsignedp ? sat_uqq_type_node : uqq_type_node;
2131 if (mode == UHQmode)
2132 return unsignedp ? sat_uhq_type_node : uhq_type_node;
2133 if (mode == USQmode)
2134 return unsignedp ? sat_usq_type_node : usq_type_node;
2135 if (mode == UDQmode)
2136 return unsignedp ? sat_udq_type_node : udq_type_node;
2137 if (mode == UTQmode)
2138 return unsignedp ? sat_utq_type_node : utq_type_node;
2141 return unsignedp ? sat_ha_type_node : ha_type_node;
2143 return unsignedp ? sat_sa_type_node : sa_type_node;
2145 return unsignedp ? sat_da_type_node : da_type_node;
2147 return unsignedp ? sat_ta_type_node : ta_type_node;
2149 if (mode == UHAmode)
2150 return unsignedp ? sat_uha_type_node : uha_type_node;
2151 if (mode == USAmode)
2152 return unsignedp ? sat_usa_type_node : usa_type_node;
2153 if (mode == UDAmode)
2154 return unsignedp ? sat_uda_type_node : uda_type_node;
2155 if (mode == UTAmode)
2156 return unsignedp ? sat_uta_type_node : uta_type_node;
2159 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2160 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2161 return TREE_VALUE (t);
2167 c_common_unsigned_type (tree type)
2169 return c_common_signed_or_unsigned_type (1, type);
2172 /* Return a signed type the same as TYPE in other respects. */
2175 c_common_signed_type (tree type)
2177 return c_common_signed_or_unsigned_type (0, type);
2180 /* Return a type the same as TYPE except unsigned or
2181 signed according to UNSIGNEDP. */
2184 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2188 /* This block of code emulates the behavior of the old
2189 c_common_unsigned_type. In particular, it returns
2190 long_unsigned_type_node if passed a long, even when a int would
2191 have the same size. This is necessary for warnings to work
2192 correctly in archs where sizeof(int) == sizeof(long) */
2194 type1 = TYPE_MAIN_VARIANT (type);
2195 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2196 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2197 if (type1 == integer_type_node || type1 == unsigned_type_node)
2198 return unsignedp ? unsigned_type_node : integer_type_node;
2199 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2200 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2201 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2202 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2203 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
2204 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2205 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
2206 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
2207 #if HOST_BITS_PER_WIDE_INT >= 64
2208 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2209 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2211 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2212 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2213 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2214 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2215 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2216 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2217 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2218 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2220 #define C_COMMON_FIXED_TYPES(SAT,NAME) \
2221 if (type1 == SAT ## short_ ## NAME ## _type_node \
2222 || type1 == SAT ## unsigned_short_ ## NAME ## _type_node) \
2223 return unsignedp ? SAT ## unsigned_short_ ## NAME ## _type_node \
2224 : SAT ## short_ ## NAME ## _type_node; \
2225 if (type1 == SAT ## NAME ## _type_node \
2226 || type1 == SAT ## unsigned_ ## NAME ## _type_node) \
2227 return unsignedp ? SAT ## unsigned_ ## NAME ## _type_node \
2228 : SAT ## NAME ## _type_node; \
2229 if (type1 == SAT ## long_ ## NAME ## _type_node \
2230 || type1 == SAT ## unsigned_long_ ## NAME ## _type_node) \
2231 return unsignedp ? SAT ## unsigned_long_ ## NAME ## _type_node \
2232 : SAT ## long_ ## NAME ## _type_node; \
2233 if (type1 == SAT ## long_long_ ## NAME ## _type_node \
2234 || type1 == SAT ## unsigned_long_long_ ## NAME ## _type_node) \
2235 return unsignedp ? SAT ## unsigned_long_long_ ## NAME ## _type_node \
2236 : SAT ## long_long_ ## NAME ## _type_node;
2238 #define C_COMMON_FIXED_MODE_TYPES(SAT,NAME) \
2239 if (type1 == SAT ## NAME ## _type_node \
2240 || type1 == SAT ## u ## NAME ## _type_node) \
2241 return unsignedp ? SAT ## u ## NAME ## _type_node \
2242 : SAT ## NAME ## _type_node;
2244 C_COMMON_FIXED_TYPES (, fract);
2245 C_COMMON_FIXED_TYPES (sat_, fract);
2246 C_COMMON_FIXED_TYPES (, accum);
2247 C_COMMON_FIXED_TYPES (sat_, accum);
2249 C_COMMON_FIXED_MODE_TYPES (, qq);
2250 C_COMMON_FIXED_MODE_TYPES (, hq);
2251 C_COMMON_FIXED_MODE_TYPES (, sq);
2252 C_COMMON_FIXED_MODE_TYPES (, dq);
2253 C_COMMON_FIXED_MODE_TYPES (, tq);
2254 C_COMMON_FIXED_MODE_TYPES (sat_, qq);
2255 C_COMMON_FIXED_MODE_TYPES (sat_, hq);
2256 C_COMMON_FIXED_MODE_TYPES (sat_, sq);
2257 C_COMMON_FIXED_MODE_TYPES (sat_, dq);
2258 C_COMMON_FIXED_MODE_TYPES (sat_, tq);
2259 C_COMMON_FIXED_MODE_TYPES (, ha);
2260 C_COMMON_FIXED_MODE_TYPES (, sa);
2261 C_COMMON_FIXED_MODE_TYPES (, da);
2262 C_COMMON_FIXED_MODE_TYPES (, ta);
2263 C_COMMON_FIXED_MODE_TYPES (sat_, ha);
2264 C_COMMON_FIXED_MODE_TYPES (sat_, sa);
2265 C_COMMON_FIXED_MODE_TYPES (sat_, da);
2266 C_COMMON_FIXED_MODE_TYPES (sat_, ta);
2268 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2269 the precision; they have precision set to match their range, but
2270 may use a wider mode to match an ABI. If we change modes, we may
2271 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2272 the precision as well, so as to yield correct results for
2273 bit-field types. C++ does not have these separate bit-field
2274 types, and producing a signed or unsigned variant of an
2275 ENUMERAL_TYPE may cause other problems as well. */
2277 if (!INTEGRAL_TYPE_P (type)
2278 || TYPE_UNSIGNED (type) == unsignedp)
2281 #define TYPE_OK(node) \
2282 (TYPE_MODE (type) == TYPE_MODE (node) \
2283 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
2284 if (TYPE_OK (signed_char_type_node))
2285 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2286 if (TYPE_OK (integer_type_node))
2287 return unsignedp ? unsigned_type_node : integer_type_node;
2288 if (TYPE_OK (short_integer_type_node))
2289 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2290 if (TYPE_OK (long_integer_type_node))
2291 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2292 if (TYPE_OK (long_long_integer_type_node))
2293 return (unsignedp ? long_long_unsigned_type_node
2294 : long_long_integer_type_node);
2295 if (TYPE_OK (widest_integer_literal_type_node))
2296 return (unsignedp ? widest_unsigned_literal_type_node
2297 : widest_integer_literal_type_node);
2299 #if HOST_BITS_PER_WIDE_INT >= 64
2300 if (TYPE_OK (intTI_type_node))
2301 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2303 if (TYPE_OK (intDI_type_node))
2304 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2305 if (TYPE_OK (intSI_type_node))
2306 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2307 if (TYPE_OK (intHI_type_node))
2308 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2309 if (TYPE_OK (intQI_type_node))
2310 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2313 if (c_dialect_cxx ())
2316 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2319 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2322 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2324 /* Extended integer types of the same width as a standard type have
2325 lesser rank, so those of the same width as int promote to int or
2326 unsigned int and are valid for printf formats expecting int or
2327 unsigned int. To avoid such special cases, avoid creating
2328 extended integer types for bit-fields if a standard integer type
2330 if (width == TYPE_PRECISION (integer_type_node))
2331 return unsignedp ? unsigned_type_node : integer_type_node;
2332 if (width == TYPE_PRECISION (signed_char_type_node))
2333 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2334 if (width == TYPE_PRECISION (short_integer_type_node))
2335 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2336 if (width == TYPE_PRECISION (long_integer_type_node))
2337 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2338 if (width == TYPE_PRECISION (long_long_integer_type_node))
2339 return (unsignedp ? long_long_unsigned_type_node
2340 : long_long_integer_type_node);
2341 return build_nonstandard_integer_type (width, unsignedp);
2344 /* The C version of the register_builtin_type langhook. */
2347 c_register_builtin_type (tree type, const char* name)
2351 decl = build_decl (TYPE_DECL, get_identifier (name), type);
2352 DECL_ARTIFICIAL (decl) = 1;
2353 if (!TYPE_NAME (type))
2354 TYPE_NAME (type) = decl;
2357 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2361 /* Return the minimum number of bits needed to represent VALUE in a
2362 signed or unsigned type, UNSIGNEDP says which. */
2365 min_precision (tree value, int unsignedp)
2369 /* If the value is negative, compute its negative minus 1. The latter
2370 adjustment is because the absolute value of the largest negative value
2371 is one larger than the largest positive value. This is equivalent to
2372 a bit-wise negation, so use that operation instead. */
2374 if (tree_int_cst_sgn (value) < 0)
2375 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2377 /* Return the number of bits needed, taking into account the fact
2378 that we need one more bit for a signed than unsigned type. */
2380 if (integer_zerop (value))
2383 log = tree_floor_log2 (value);
2385 return log + 1 + !unsignedp;
2388 /* Print an error message for invalid operands to arith operation
2389 CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */
2392 binary_op_error (enum tree_code code, tree type0, tree type1)
2399 opname = "+"; break;
2401 opname = "-"; break;
2403 opname = "*"; break;
2405 opname = "max"; break;
2407 opname = "min"; break;
2409 opname = "=="; break;
2411 opname = "!="; break;
2413 opname = "<="; break;
2415 opname = ">="; break;
2417 opname = "<"; break;
2419 opname = ">"; break;
2421 opname = "<<"; break;
2423 opname = ">>"; break;
2424 case TRUNC_MOD_EXPR:
2425 case FLOOR_MOD_EXPR:
2426 opname = "%"; break;
2427 case TRUNC_DIV_EXPR:
2428 case FLOOR_DIV_EXPR:
2429 opname = "/"; break;
2431 opname = "&"; break;
2433 opname = "|"; break;
2434 case TRUTH_ANDIF_EXPR:
2435 opname = "&&"; break;
2436 case TRUTH_ORIF_EXPR:
2437 opname = "||"; break;
2439 opname = "^"; break;
2443 error ("invalid operands to binary %s (have %qT and %qT)", opname,
2447 /* Subroutine of build_binary_op, used for comparison operations.
2448 See if the operands have both been converted from subword integer types
2449 and, if so, perhaps change them both back to their original type.
2450 This function is also responsible for converting the two operands
2451 to the proper common type for comparison.
2453 The arguments of this function are all pointers to local variables
2454 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2455 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2457 If this function returns nonzero, it means that the comparison has
2458 a constant value. What this function returns is an expression for
2462 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2463 enum tree_code *rescode_ptr)
2466 tree op0 = *op0_ptr;
2467 tree op1 = *op1_ptr;
2468 int unsignedp0, unsignedp1;
2470 tree primop0, primop1;
2471 enum tree_code code = *rescode_ptr;
2473 /* Throw away any conversions to wider types
2474 already present in the operands. */
2476 primop0 = get_narrower (op0, &unsignedp0);
2477 primop1 = get_narrower (op1, &unsignedp1);
2479 /* Handle the case that OP0 does not *contain* a conversion
2480 but it *requires* conversion to FINAL_TYPE. */
2482 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2483 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2484 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2485 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2487 /* If one of the operands must be floated, we cannot optimize. */
2488 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2489 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2491 /* If first arg is constant, swap the args (changing operation
2492 so value is preserved), for canonicalization. Don't do this if
2493 the second arg is 0. */
2495 if (TREE_CONSTANT (primop0)
2496 && !integer_zerop (primop1) && !real_zerop (primop1)
2497 && !fixed_zerop (primop1))
2500 int temi = unsignedp0;
2508 unsignedp0 = unsignedp1;
2531 *rescode_ptr = code;
2534 /* If comparing an integer against a constant more bits wide,
2535 maybe we can deduce a value of 1 or 0 independent of the data.
2536 Or else truncate the constant now
2537 rather than extend the variable at run time.
2539 This is only interesting if the constant is the wider arg.
2540 Also, it is not safe if the constant is unsigned and the
2541 variable arg is signed, since in this case the variable
2542 would be sign-extended and then regarded as unsigned.
2543 Our technique fails in this case because the lowest/highest
2544 possible unsigned results don't follow naturally from the
2545 lowest/highest possible values of the variable operand.
2546 For just EQ_EXPR and NE_EXPR there is another technique that
2547 could be used: see if the constant can be faithfully represented
2548 in the other operand's type, by truncating it and reextending it
2549 and see if that preserves the constant's value. */
2551 if (!real1 && !real2
2552 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
2553 && TREE_CODE (primop1) == INTEGER_CST
2554 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2556 int min_gt, max_gt, min_lt, max_lt;
2557 tree maxval, minval;
2558 /* 1 if comparison is nominally unsigned. */
2559 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2562 type = c_common_signed_or_unsigned_type (unsignedp0,
2563 TREE_TYPE (primop0));
2565 maxval = TYPE_MAX_VALUE (type);
2566 minval = TYPE_MIN_VALUE (type);
2568 if (unsignedp && !unsignedp0)
2569 *restype_ptr = c_common_signed_type (*restype_ptr);
2571 if (TREE_TYPE (primop1) != *restype_ptr)
2573 /* Convert primop1 to target type, but do not introduce
2574 additional overflow. We know primop1 is an int_cst. */
2575 primop1 = force_fit_type_double (*restype_ptr,
2576 TREE_INT_CST_LOW (primop1),
2577 TREE_INT_CST_HIGH (primop1), 0,
2578 TREE_OVERFLOW (primop1));
2580 if (type != *restype_ptr)
2582 minval = convert (*restype_ptr, minval);
2583 maxval = convert (*restype_ptr, maxval);
2586 if (unsignedp && unsignedp0)
2588 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2589 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2590 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2591 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2595 min_gt = INT_CST_LT (primop1, minval);
2596 max_gt = INT_CST_LT (primop1, maxval);
2597 min_lt = INT_CST_LT (minval, primop1);
2598 max_lt = INT_CST_LT (maxval, primop1);
2602 /* This used to be a switch, but Genix compiler can't handle that. */
2603 if (code == NE_EXPR)
2605 if (max_lt || min_gt)
2606 val = truthvalue_true_node;
2608 else if (code == EQ_EXPR)
2610 if (max_lt || min_gt)
2611 val = truthvalue_false_node;
2613 else if (code == LT_EXPR)
2616 val = truthvalue_true_node;
2618 val = truthvalue_false_node;
2620 else if (code == GT_EXPR)
2623 val = truthvalue_true_node;
2625 val = truthvalue_false_node;
2627 else if (code == LE_EXPR)
2630 val = truthvalue_true_node;
2632 val = truthvalue_false_node;
2634 else if (code == GE_EXPR)
2637 val = truthvalue_true_node;
2639 val = truthvalue_false_node;
2642 /* If primop0 was sign-extended and unsigned comparison specd,
2643 we did a signed comparison above using the signed type bounds.
2644 But the comparison we output must be unsigned.
2646 Also, for inequalities, VAL is no good; but if the signed
2647 comparison had *any* fixed result, it follows that the
2648 unsigned comparison just tests the sign in reverse
2649 (positive values are LE, negative ones GE).
2650 So we can generate an unsigned comparison
2651 against an extreme value of the signed type. */
2653 if (unsignedp && !unsignedp0)
2660 primop1 = TYPE_MIN_VALUE (type);
2666 primop1 = TYPE_MAX_VALUE (type);
2673 type = c_common_unsigned_type (type);
2676 if (TREE_CODE (primop0) != INTEGER_CST)
2678 if (val == truthvalue_false_node)
2679 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
2680 if (val == truthvalue_true_node)
2681 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
2686 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2687 if (TREE_SIDE_EFFECTS (primop0))
2688 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2692 /* Value is not predetermined, but do the comparison
2693 in the type of the operand that is not constant.
2694 TYPE is already properly set. */
2697 /* If either arg is decimal float and the other is float, find the
2698 proper common type to use for comparison. */
2699 else if (real1 && real2
2700 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2701 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2702 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2704 else if (real1 && real2
2705 && (TYPE_PRECISION (TREE_TYPE (primop0))
2706 == TYPE_PRECISION (TREE_TYPE (primop1))))
2707 type = TREE_TYPE (primop0);
2709 /* If args' natural types are both narrower than nominal type
2710 and both extend in the same manner, compare them
2711 in the type of the wider arg.
2712 Otherwise must actually extend both to the nominal
2713 common type lest different ways of extending
2715 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2717 else if (unsignedp0 == unsignedp1 && real1 == real2
2718 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2719 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2721 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2722 type = c_common_signed_or_unsigned_type (unsignedp0
2723 || TYPE_UNSIGNED (*restype_ptr),
2725 /* Make sure shorter operand is extended the right way
2726 to match the longer operand. */
2728 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2729 TREE_TYPE (primop0)),
2732 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2733 TREE_TYPE (primop1)),
2738 /* Here we must do the comparison on the nominal type
2739 using the args exactly as we received them. */
2740 type = *restype_ptr;
2744 if (!real1 && !real2 && integer_zerop (primop1)
2745 && TYPE_UNSIGNED (*restype_ptr))
2751 /* All unsigned values are >= 0, so we warn. However,
2752 if OP0 is a constant that is >= 0, the signedness of
2753 the comparison isn't an issue, so suppress the
2755 if (warn_type_limits && !in_system_header
2756 && !(TREE_CODE (primop0) == INTEGER_CST
2757 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2759 warning (OPT_Wtype_limits,
2760 "comparison of unsigned expression >= 0 is always true");
2761 value = truthvalue_true_node;
2765 if (warn_type_limits && !in_system_header
2766 && !(TREE_CODE (primop0) == INTEGER_CST
2767 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2769 warning (OPT_Wtype_limits,
2770 "comparison of unsigned expression < 0 is always false");
2771 value = truthvalue_false_node;
2780 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2781 if (TREE_SIDE_EFFECTS (primop0))
2782 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2789 *op0_ptr = convert (type, primop0);
2790 *op1_ptr = convert (type, primop1);
2792 *restype_ptr = truthvalue_type_node;
2797 /* Return a tree for the sum or difference (RESULTCODE says which)
2798 of pointer PTROP and integer INTOP. */
2801 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2805 /* The result is a pointer of the same type that is being added. */
2806 tree result_type = TREE_TYPE (ptrop);
2808 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2810 if (pedantic || warn_pointer_arith)
2811 pedwarn ("pointer of type %<void *%> used in arithmetic");
2812 size_exp = integer_one_node;
2814 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2816 if (pedantic || warn_pointer_arith)
2817 pedwarn ("pointer to a function used in arithmetic");
2818 size_exp = integer_one_node;
2820 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2822 if (pedantic || warn_pointer_arith)
2823 pedwarn ("pointer to member function used in arithmetic");
2824 size_exp = integer_one_node;
2827 size_exp = size_in_bytes (TREE_TYPE (result_type));
2829 /* We are manipulating pointer values, so we don't need to warn
2830 about relying on undefined signed overflow. We disable the
2831 warning here because we use integer types so fold won't know that
2832 they are really pointers. */
2833 fold_defer_overflow_warnings ();
2835 /* If what we are about to multiply by the size of the elements
2836 contains a constant term, apply distributive law
2837 and multiply that constant term separately.
2838 This helps produce common subexpressions. */
2839 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2840 && !TREE_CONSTANT (intop)
2841 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2842 && TREE_CONSTANT (size_exp)
2843 /* If the constant comes from pointer subtraction,
2844 skip this optimization--it would cause an error. */
2845 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2846 /* If the constant is unsigned, and smaller than the pointer size,
2847 then we must skip this optimization. This is because it could cause
2848 an overflow error if the constant is negative but INTOP is not. */
2849 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2850 || (TYPE_PRECISION (TREE_TYPE (intop))
2851 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2853 enum tree_code subcode = resultcode;
2854 tree int_type = TREE_TYPE (intop);
2855 if (TREE_CODE (intop) == MINUS_EXPR)
2856 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2857 /* Convert both subexpression types to the type of intop,
2858 because weird cases involving pointer arithmetic
2859 can result in a sum or difference with different type args. */
2860 ptrop = build_binary_op (subcode, ptrop,
2861 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2862 intop = convert (int_type, TREE_OPERAND (intop, 0));
2865 /* Convert the integer argument to a type the same size as sizetype
2866 so the multiply won't overflow spuriously. */
2867 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2868 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2869 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2870 TYPE_UNSIGNED (sizetype)), intop);
2872 /* Replace the integer argument with a suitable product by the object size.
2873 Do this multiplication as signed, then convert to the appropriate
2874 type for the pointer operation. */
2875 intop = convert (sizetype,
2876 build_binary_op (MULT_EXPR, intop,
2877 convert (TREE_TYPE (intop), size_exp), 1));
2879 /* Create the sum or difference. */
2880 if (resultcode == MINUS_EXPR)
2881 intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
2883 ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
2885 fold_undefer_and_ignore_overflow_warnings ();
2890 /* Return whether EXPR is a declaration whose address can never be
2894 decl_with_nonnull_addr_p (const_tree expr)
2896 return (DECL_P (expr)
2897 && (TREE_CODE (expr) == PARM_DECL
2898 || TREE_CODE (expr) == LABEL_DECL
2899 || !DECL_WEAK (expr)));
2902 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2903 or for an `if' or `while' statement or ?..: exp. It should already
2904 have been validated to be of suitable type; otherwise, a bad
2905 diagnostic may result.
2907 This preparation consists of taking the ordinary
2908 representation of an expression expr and producing a valid tree
2909 boolean expression describing whether expr is nonzero. We could
2910 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2911 but we optimize comparisons, &&, ||, and !.
2913 The resulting type should always be `truthvalue_type_node'. */
2916 c_common_truthvalue_conversion (tree expr)
2918 switch (TREE_CODE (expr))
2920 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2921 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2922 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2923 case ORDERED_EXPR: case UNORDERED_EXPR:
2924 if (TREE_TYPE (expr) == truthvalue_type_node)
2926 return build2 (TREE_CODE (expr), truthvalue_type_node,
2927 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2929 case TRUTH_ANDIF_EXPR:
2930 case TRUTH_ORIF_EXPR:
2931 case TRUTH_AND_EXPR:
2933 case TRUTH_XOR_EXPR:
2934 if (TREE_TYPE (expr) == truthvalue_type_node)
2936 return build2 (TREE_CODE (expr), truthvalue_type_node,
2937 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2938 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2940 case TRUTH_NOT_EXPR:
2941 if (TREE_TYPE (expr) == truthvalue_type_node)
2943 return build1 (TREE_CODE (expr), truthvalue_type_node,
2944 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2950 return integer_zerop (expr) ? truthvalue_false_node
2951 : truthvalue_true_node;
2954 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2955 ? truthvalue_true_node
2956 : truthvalue_false_node;
2959 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
2960 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
2961 ? truthvalue_true_node
2962 : truthvalue_false_node;
2965 expr = build_unary_op (ADDR_EXPR, expr, 0);
2970 tree inner = TREE_OPERAND (expr, 0);
2971 if (decl_with_nonnull_addr_p (inner))
2973 /* Common Ada/Pascal programmer's mistake. */
2974 warning (OPT_Waddress,
2975 "the address of %qD will always evaluate as %<true%>",
2977 return truthvalue_true_node;
2980 /* If we still have a decl, it is possible for its address to
2981 be NULL, so we cannot optimize. */
2984 gcc_assert (DECL_WEAK (inner));
2988 if (TREE_SIDE_EFFECTS (inner))
2989 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2990 inner, truthvalue_true_node);
2992 return truthvalue_true_node;
2996 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2997 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2998 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2999 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
3005 /* These don't change whether an object is nonzero or zero. */
3006 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
3010 /* These don't change whether an object is zero or nonzero, but
3011 we can't ignore them if their second arg has side-effects. */
3012 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3013 return build2 (COMPOUND_EXPR, truthvalue_type_node,
3014 TREE_OPERAND (expr, 1),
3015 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
3017 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
3020 /* Distribute the conversion into the arms of a COND_EXPR. */
3021 return fold_build3 (COND_EXPR, truthvalue_type_node,
3022 TREE_OPERAND (expr, 0),
3023 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
3024 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
3028 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3029 since that affects how `default_conversion' will behave. */
3030 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3031 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3033 /* If this is widening the argument, we can ignore it. */
3034 if (TYPE_PRECISION (TREE_TYPE (expr))
3035 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3036 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
3040 if (!TREE_NO_WARNING (expr)
3041 && warn_parentheses)
3043 warning (OPT_Wparentheses,
3044 "suggest parentheses around assignment used as truth value");
3045 TREE_NO_WARNING (expr) = 1;
3053 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3055 tree t = save_expr (expr);
3056 return (build_binary_op
3057 ((TREE_SIDE_EFFECTS (expr)
3058 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3059 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
3060 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
3064 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3066 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3068 (TREE_TYPE (expr))));
3069 return build_binary_op (NE_EXPR, expr, fixed_zero_node, 1);
3072 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3075 static void def_builtin_1 (enum built_in_function fncode,
3077 enum built_in_class fnclass,
3078 tree fntype, tree libtype,
3079 bool both_p, bool fallback_p, bool nonansi_p,
3080 tree fnattrs, bool implicit_p);
3082 /* Make a variant type in the proper way for C/C++, propagating qualifiers
3083 down to the element type of an array. */
3086 c_build_qualified_type (tree type, int type_quals)
3088 if (type == error_mark_node)
3091 if (TREE_CODE (type) == ARRAY_TYPE)
3094 tree element_type = c_build_qualified_type (TREE_TYPE (type),
3097 /* See if we already have an identically qualified type. */
3098 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
3100 if (TYPE_QUALS (strip_array_types (t)) == type_quals
3101 && TYPE_NAME (t) == TYPE_NAME (type)
3102 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
3103 && attribute_list_equal (TYPE_ATTRIBUTES (t),
3104 TYPE_ATTRIBUTES (type)))
3109 tree domain = TYPE_DOMAIN (type);
3111 t = build_variant_type_copy (type);
3112 TREE_TYPE (t) = element_type;
3114 if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
3115 || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
3116 SET_TYPE_STRUCTURAL_EQUALITY (t);
3117 else if (TYPE_CANONICAL (element_type) != element_type
3118 || (domain && TYPE_CANONICAL (domain) != domain))
3120 tree unqualified_canon
3121 = build_array_type (TYPE_CANONICAL (element_type),
3122 domain? TYPE_CANONICAL (domain)
3125 = c_build_qualified_type (unqualified_canon, type_quals);
3128 TYPE_CANONICAL (t) = t;
3133 /* A restrict-qualified pointer type must be a pointer to object or
3134 incomplete type. Note that the use of POINTER_TYPE_P also allows
3135 REFERENCE_TYPEs, which is appropriate for C++. */
3136 if ((type_quals & TYPE_QUAL_RESTRICT)
3137 && (!POINTER_TYPE_P (type)
3138 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
3140 error ("invalid use of %<restrict%>");
3141 type_quals &= ~TYPE_QUAL_RESTRICT;
3144 return build_qualified_type (type, type_quals);
3147 /* Apply the TYPE_QUALS to the new DECL. */
3150 c_apply_type_quals_to_decl (int type_quals, tree decl)
3152 tree type = TREE_TYPE (decl);
3154 if (type == error_mark_node)
3157 if (((type_quals & TYPE_QUAL_CONST)
3158 || (type && TREE_CODE (type) == REFERENCE_TYPE))
3159 /* An object declared 'const' is only readonly after it is
3160 initialized. We don't have any way of expressing this currently,
3161 so we need to be conservative and unset TREE_READONLY for types
3162 with constructors. Otherwise aliasing code will ignore stores in
3163 an inline constructor. */
3164 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3165 TREE_READONLY (decl) = 1;
3166 if (type_quals & TYPE_QUAL_VOLATILE)
3168 TREE_SIDE_EFFECTS (decl) = 1;
3169 TREE_THIS_VOLATILE (decl) = 1;
3171 if (type_quals & TYPE_QUAL_RESTRICT)
3173 while (type && TREE_CODE (type) == ARRAY_TYPE)
3174 /* Allow 'restrict' on arrays of pointers.
3175 FIXME currently we just ignore it. */
3176 type = TREE_TYPE (type);
3178 || !POINTER_TYPE_P (type)
3179 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3180 error ("invalid use of %<restrict%>");
3181 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3182 /* Indicate we need to make a unique alias set for this pointer.
3183 We can't do it here because it might be pointing to an
3185 DECL_POINTER_ALIAS_SET (decl) = -2;
3189 /* Hash function for the problem of multiple type definitions in
3190 different files. This must hash all types that will compare
3191 equal via comptypes to the same value. In practice it hashes
3192 on some of the simple stuff and leaves the details to comptypes. */
3195 c_type_hash (const void *p)
3199 const_tree const t = (const_tree) p;
3201 switch (TREE_CODE (t))
3203 /* For pointers, hash on pointee type plus some swizzling. */
3205 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3206 /* Hash on number of elements and total size. */
3209 t2 = TYPE_VALUES (t);
3213 t2 = TYPE_FIELDS (t);
3215 case QUAL_UNION_TYPE:
3217 t2 = TYPE_FIELDS (t);
3221 t2 = TYPE_FIELDS (t);
3226 for (; t2; t2 = TREE_CHAIN (t2))
3228 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3229 return ((size << 24) | (i << shift));
3232 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3234 /* Return the typed-based alias set for T, which may be an expression
3235 or a type. Return -1 if we don't do anything special. */
3238 c_common_get_alias_set (tree t)
3243 /* Permit type-punning when accessing a union, provided the access
3244 is directly through the union. For example, this code does not
3245 permit taking the address of a union member and then storing
3246 through it. Even the type-punning allowed here is a GCC
3247 extension, albeit a common and useful one; the C standard says
3248 that such accesses have implementation-defined behavior. */
3250 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3251 u = TREE_OPERAND (u, 0))
3252 if (TREE_CODE (u) == COMPONENT_REF
3253 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3256 /* That's all the expressions we handle specially. */
3260 /* The C standard guarantees that any object may be accessed via an
3261 lvalue that has character type. */
3262 if (t == char_type_node
3263 || t == signed_char_type_node
3264 || t == unsigned_char_type_node)
3267 /* If it has the may_alias attribute, it can alias anything. */
3268 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
3271 /* The C standard specifically allows aliasing between signed and
3272 unsigned variants of the same type. We treat the signed
3273 variant as canonical. */
3274 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3276 tree t1 = c_common_signed_type (t);
3278 /* t1 == t can happen for boolean nodes which are always unsigned. */
3280 return get_alias_set (t1);
3282 else if (POINTER_TYPE_P (t))
3286 /* Unfortunately, there is no canonical form of a pointer type.
3287 In particular, if we have `typedef int I', then `int *', and
3288 `I *' are different types. So, we have to pick a canonical
3289 representative. We do this below.
3291 Technically, this approach is actually more conservative that
3292 it needs to be. In particular, `const int *' and `int *'
3293 should be in different alias sets, according to the C and C++
3294 standard, since their types are not the same, and so,
3295 technically, an `int **' and `const int **' cannot point at
3298 But, the standard is wrong. In particular, this code is
3303 const int* const* cipp = ipp;
3305 And, it doesn't make sense for that to be legal unless you
3306 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3307 the pointed-to types. This issue has been reported to the
3309 t1 = build_type_no_quals (t);
3311 return get_alias_set (t1);
3314 /* Handle the case of multiple type nodes referring to "the same" type,
3315 which occurs with IMA. These share an alias set. FIXME: Currently only
3316 C90 is handled. (In C99 type compatibility is not transitive, which
3317 complicates things mightily. The alias set splay trees can theoretically
3318 represent this, but insertion is tricky when you consider all the
3319 different orders things might arrive in.) */
3321 if (c_language != clk_c || flag_isoc99)
3324 /* Save time if there's only one input file. */
3325 if (num_in_fnames == 1)
3328 /* Pointers need special handling if they point to any type that
3329 needs special handling (below). */
3330 if (TREE_CODE (t) == POINTER_TYPE)
3333 /* Find bottom type under any nested POINTERs. */
3334 for (t2 = TREE_TYPE (t);
3335 TREE_CODE (t2) == POINTER_TYPE;
3336 t2 = TREE_TYPE (t2))
3338 if (TREE_CODE (t2) != RECORD_TYPE
3339 && TREE_CODE (t2) != ENUMERAL_TYPE
3340 && TREE_CODE (t2) != QUAL_UNION_TYPE
3341 && TREE_CODE (t2) != UNION_TYPE)
3343 if (TYPE_SIZE (t2) == 0)
3346 /* These are the only cases that need special handling. */
3347 if (TREE_CODE (t) != RECORD_TYPE
3348 && TREE_CODE (t) != ENUMERAL_TYPE
3349 && TREE_CODE (t) != QUAL_UNION_TYPE
3350 && TREE_CODE (t) != UNION_TYPE
3351 && TREE_CODE (t) != POINTER_TYPE)
3354 if (TYPE_SIZE (t) == 0)
3357 /* Look up t in hash table. Only one of the compatible types within each
3358 alias set is recorded in the table. */
3359 if (!type_hash_table)
3360 type_hash_table = htab_create_ggc (1021, c_type_hash,
3361 (htab_eq) lang_hooks.types_compatible_p,
3363 slot = htab_find_slot (type_hash_table, t, INSERT);
3366 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3367 return TYPE_ALIAS_SET ((tree)*slot);
3370 /* Our caller will assign and record (in t) a new alias set; all we need
3371 to do is remember t in the hash table. */
3377 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3378 second parameter indicates which OPERATOR is being applied. The COMPLAIN
3379 flag controls whether we should diagnose possibly ill-formed
3380 constructs or not. */
3383 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3385 const char *op_name;
3387 enum tree_code type_code = TREE_CODE (type);
3389 op_name = is_sizeof ? "sizeof" : "__alignof__";
3391 if (type_code == FUNCTION_TYPE)
3395 if (complain && (pedantic || warn_pointer_arith))
3396 pedwarn ("invalid application of %<sizeof%> to a function type");
3397 value = size_one_node;
3400 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3402 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3404 if (type_code == VOID_TYPE
3405 && complain && (pedantic || warn_pointer_arith))
3406 pedwarn ("invalid application of %qs to a void type", op_name);
3407 value = size_one_node;
3409 else if (!COMPLETE_TYPE_P (type))
3412 error ("invalid application of %qs to incomplete type %qT ",
3414 value = size_zero_node;
3419 /* Convert in case a char is more than one unit. */
3420 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3421 size_int (TYPE_PRECISION (char_type_node)
3424 value = size_int (TYPE_ALIGN_UNIT (type));
3427 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3428 TYPE_IS_SIZETYPE means that certain things (like overflow) will
3429 never happen. However, this node should really have type
3430 `size_t', which is just a typedef for an ordinary integer type. */
3431 value = fold_convert (size_type_node, value);
3432 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3437 /* Implement the __alignof keyword: Return the minimum required
3438 alignment of EXPR, measured in bytes. For VAR_DECLs,
3439 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3440 from an "aligned" __attribute__ specification). */
3443 c_alignof_expr (tree expr)
3447 if (VAR_OR_FUNCTION_DECL_P (expr))
3448 t = size_int (DECL_ALIGN_UNIT (expr));
3450 else if (TREE_CODE (expr) == COMPONENT_REF
3451 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3453 error ("%<__alignof%> applied to a bit-field");
3456 else if (TREE_CODE (expr) == COMPONENT_REF
3457 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3458 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3460 else if (TREE_CODE (expr) == INDIRECT_REF)
3462 tree t = TREE_OPERAND (expr, 0);
3464 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3466 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3467 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3471 t = TREE_OPERAND (t, 0);
3472 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3473 if (thisalign > bestalign)
3474 best = t, bestalign = thisalign;
3476 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3479 return c_alignof (TREE_TYPE (expr));
3481 return fold_convert (size_type_node, t);
3484 /* Handle C and C++ default attributes. */
3486 enum built_in_attribute
3488 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3489 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3490 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3491 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3492 #include "builtin-attrs.def"
3493 #undef DEF_ATTR_NULL_TREE
3495 #undef DEF_ATTR_IDENT
3496 #undef DEF_ATTR_TREE_LIST
3500 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3502 static void c_init_attributes (void);
3506 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3507 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3508 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3509 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3510 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3511 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3512 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3513 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3514 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3515 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3516 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3517 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3518 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3519 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3520 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3522 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3523 #include "builtin-types.def"
3524 #undef DEF_PRIMITIVE_TYPE
3525 #undef DEF_FUNCTION_TYPE_0
3526 #undef DEF_FUNCTION_TYPE_1
3527 #undef DEF_FUNCTION_TYPE_2
3528 #undef DEF_FUNCTION_TYPE_3
3529 #undef DEF_FUNCTION_TYPE_4
3530 #undef DEF_FUNCTION_TYPE_5
3531 #undef DEF_FUNCTION_TYPE_6
3532 #undef DEF_FUNCTION_TYPE_7
3533 #undef DEF_FUNCTION_TYPE_VAR_0
3534 #undef DEF_FUNCTION_TYPE_VAR_1
3535 #undef DEF_FUNCTION_TYPE_VAR_2
3536 #undef DEF_FUNCTION_TYPE_VAR_3
3537 #undef DEF_FUNCTION_TYPE_VAR_4
3538 #undef DEF_FUNCTION_TYPE_VAR_5
3539 #undef DEF_POINTER_TYPE
3543 typedef enum c_builtin_type builtin_type;
3545 /* A temporary array for c_common_nodes_and_builtins. Used in
3546 communication with def_fn_type. */
3547 static tree builtin_types[(int) BT_LAST + 1];
3549 /* A helper function for c_common_nodes_and_builtins. Build function type
3550 for DEF with return type RET and N arguments. If VAR is true, then the
3551 function should be variadic after those N arguments.
3553 Takes special care not to ICE if any of the types involved are
3554 error_mark_node, which indicates that said type is not in fact available
3555 (see builtin_type_for_size). In which case the function type as a whole
3556 should be error_mark_node. */
3559 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3561 tree args = NULL, t;
3566 for (i = 0; i < n; ++i)
3568 builtin_type a = va_arg (list, builtin_type);
3569 t = builtin_types[a];
3570 if (t == error_mark_node)
3572 args = tree_cons (NULL_TREE, t, args);
3576 args = nreverse (args);
3578 args = chainon (args, void_list_node);
3580 t = builtin_types[ret];
3581 if (t == error_mark_node)
3583 t = build_function_type (t, args);
3586 builtin_types[def] = t;
3589 /* Build builtin functions common to both C and C++ language
3593 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3595 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3596 builtin_types[ENUM] = VALUE;
3597 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3598 def_fn_type (ENUM, RETURN, 0, 0);
3599 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3600 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3601 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3602 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3603 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3604 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3605 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3606 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3607 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3608 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3609 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3611 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3612 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3614 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3615 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3616 def_fn_type (ENUM, RETURN, 1, 0);
3617 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3618 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3619 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3620 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3621 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3622 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3623 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3624 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3625 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3626 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3627 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3628 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3630 #include "builtin-types.def"
3632 #undef DEF_PRIMITIVE_TYPE
3633 #undef DEF_FUNCTION_TYPE_1
3634 #undef DEF_FUNCTION_TYPE_2
3635 #undef DEF_FUNCTION_TYPE_3
3636 #undef DEF_FUNCTION_TYPE_4
3637 #undef DEF_FUNCTION_TYPE_5
3638 #undef DEF_FUNCTION_TYPE_6
3639 #undef DEF_FUNCTION_TYPE_VAR_0
3640 #undef DEF_FUNCTION_TYPE_VAR_1
3641 #undef DEF_FUNCTION_TYPE_VAR_2
3642 #undef DEF_FUNCTION_TYPE_VAR_3
3643 #undef DEF_FUNCTION_TYPE_VAR_4
3644 #undef DEF_FUNCTION_TYPE_VAR_5
3645 #undef DEF_POINTER_TYPE
3646 builtin_types[(int) BT_LAST] = NULL_TREE;
3648 c_init_attributes ();
3650 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3651 NONANSI_P, ATTRS, IMPLICIT, COND) \
3653 def_builtin_1 (ENUM, NAME, CLASS, \
3654 builtin_types[(int) TYPE], \
3655 builtin_types[(int) LIBTYPE], \
3656 BOTH_P, FALLBACK_P, NONANSI_P, \
3657 built_in_attributes[(int) ATTRS], IMPLICIT);
3658 #include "builtins.def"
3661 targetm.init_builtins ();
3663 build_common_builtin_nodes ();
3669 /* Build tree nodes and builtin functions common to both C and C++ language
3673 c_common_nodes_and_builtins (void)
3675 int wchar_type_size;
3676 tree array_domain_type;
3677 tree va_list_ref_type_node;
3678 tree va_list_arg_type_node;
3680 /* Define `int' and `char' first so that dbx will output them first. */
3681 record_builtin_type (RID_INT, NULL, integer_type_node);
3682 record_builtin_type (RID_CHAR, "char", char_type_node);
3684 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
3685 "unsigned long", "long long unsigned" and "unsigned short" were in C++
3686 but not C. Are the conditionals here needed? */
3687 if (c_dialect_cxx ())
3688 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3689 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3690 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3691 record_builtin_type (RID_MAX, "long unsigned int",
3692 long_unsigned_type_node);
3693 if (c_dialect_cxx ())
3694 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3695 record_builtin_type (RID_MAX, "long long int",
3696 long_long_integer_type_node);
3697 record_builtin_type (RID_MAX, "long long unsigned int",
3698 long_long_unsigned_type_node);
3699 if (c_dialect_cxx ())
3700 record_builtin_type (RID_MAX, "long long unsigned",
3701 long_long_unsigned_type_node);
3702 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3703 record_builtin_type (RID_MAX, "short unsigned int",
3704 short_unsigned_type_node);
3705 if (c_dialect_cxx ())
3706 record_builtin_type (RID_MAX, "unsigned short",
3707 short_unsigned_type_node);
3709 /* Define both `signed char' and `unsigned char'. */
3710 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3711 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3713 /* These are types that c_common_type_for_size and
3714 c_common_type_for_mode use. */
3715 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3717 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3719 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3721 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3723 #if HOST_BITS_PER_WIDE_INT >= 64
3724 if (targetm.scalar_mode_supported_p (TImode))
3725 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3726 get_identifier ("__int128_t"),
3729 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3730 unsigned_intQI_type_node));
3731 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3732 unsigned_intHI_type_node));
3733 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3734 unsigned_intSI_type_node));
3735 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3736 unsigned_intDI_type_node));
3737 #if HOST_BITS_PER_WIDE_INT >= 64
3738 if (targetm.scalar_mode_supported_p (TImode))
3739 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3740 get_identifier ("__uint128_t"),
3741 unsigned_intTI_type_node));
3744 /* Create the widest literal types. */
3745 widest_integer_literal_type_node
3746 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3747 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3748 widest_integer_literal_type_node));
3750 widest_unsigned_literal_type_node
3751 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3752 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3753 widest_unsigned_literal_type_node));
3755 /* `unsigned long' is the standard type for sizeof.
3756 Note that stddef.h uses `unsigned long',
3757 and this must agree, even if long and int are the same size. */
3759 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3760 signed_size_type_node = c_common_signed_type (size_type_node);
3761 set_sizetype (size_type_node);
3764 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3766 build_common_tree_nodes_2 (flag_short_double);
3768 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3769 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3770 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3772 /* Only supported decimal floating point extension if the target
3773 actually supports underlying modes. */
3774 if (targetm.scalar_mode_supported_p (SDmode)
3775 && targetm.scalar_mode_supported_p (DDmode)
3776 && targetm.scalar_mode_supported_p (TDmode))
3778 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3779 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3780 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3783 if (targetm.fixed_point_supported_p ())
3785 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
3786 record_builtin_type (RID_FRACT, NULL, fract_type_node);
3787 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
3788 record_builtin_type (RID_MAX, "long long _Fract",
3789 long_long_fract_type_node);
3790 record_builtin_type (RID_MAX, "unsigned short _Fract",
3791 unsigned_short_fract_type_node);
3792 record_builtin_type (RID_MAX, "unsigned _Fract",
3793 unsigned_fract_type_node);
3794 record_builtin_type (RID_MAX, "unsigned long _Fract",
3795 unsigned_long_fract_type_node);
3796 record_builtin_type (RID_MAX, "unsigned long long _Fract",
3797 unsigned_long_long_fract_type_node);
3798 record_builtin_type (RID_MAX, "_Sat short _Fract",
3799 sat_short_fract_type_node);
3800 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
3801 record_builtin_type (RID_MAX, "_Sat long _Fract",
3802 sat_long_fract_type_node);
3803 record_builtin_type (RID_MAX, "_Sat long long _Fract",
3804 sat_long_long_fract_type_node);
3805 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
3806 sat_unsigned_short_fract_type_node);
3807 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
3808 sat_unsigned_fract_type_node);
3809 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
3810 sat_unsigned_long_fract_type_node);
3811 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
3812 sat_unsigned_long_long_fract_type_node);
3813 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
3814 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
3815 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
3816 record_builtin_type (RID_MAX, "long long _Accum",
3817 long_long_accum_type_node);
3818 record_builtin_type (RID_MAX, "unsigned short _Accum",
3819 unsigned_short_accum_type_node);
3820 record_builtin_type (RID_MAX, "unsigned _Accum",
3821 unsigned_accum_type_node);
3822 record_builtin_type (RID_MAX, "unsigned long _Accum",
3823 unsigned_long_accum_type_node);
3824 record_builtin_type (RID_MAX, "unsigned long long _Accum",
3825 unsigned_long_long_accum_type_node);
3826 record_builtin_type (RID_MAX, "_Sat short _Accum",
3827 sat_short_accum_type_node);
3828 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
3829 record_builtin_type (RID_MAX, "_Sat long _Accum",
3830 sat_long_accum_type_node);
3831 record_builtin_type (RID_MAX, "_Sat long long _Accum",
3832 sat_long_long_accum_type_node);
3833 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
3834 sat_unsigned_short_accum_type_node);
3835 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
3836 sat_unsigned_accum_type_node);
3837 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
3838 sat_unsigned_long_accum_type_node);
3839 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
3840 sat_unsigned_long_long_accum_type_node);
3844 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3845 get_identifier ("complex int"),
3846 complex_integer_type_node));
3847 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3848 get_identifier ("complex float"),
3849 complex_float_type_node));
3850 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3851 get_identifier ("complex double"),
3852 complex_double_type_node));
3853 lang_hooks.decls.pushdecl
3854 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3855 complex_long_double_type_node));
3857 if (c_dialect_cxx ())
3858 /* For C++, make fileptr_type_node a distinct void * type until
3859 FILE type is defined. */
3860 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3862 record_builtin_type (RID_VOID, NULL, void_type_node);
3864 /* Set the TYPE_NAME for any variants that were built before
3865 record_builtin_type gave names to the built-in types. */
3867 tree void_name = TYPE_NAME (void_type_node);
3868 TYPE_NAME (void_type_node) = NULL_TREE;
3869 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
3871 TYPE_NAME (void_type_node) = void_name;
3874 /* This node must not be shared. */
3875 void_zero_node = make_node (INTEGER_CST);
3876 TREE_TYPE (void_zero_node) = void_type_node;
3878 void_list_node = build_void_list_node ();
3880 /* Make a type to be the domain of a few array types
3881 whose domains don't really matter.
3882 200 is small enough that it always fits in size_t
3883 and large enough that it can hold most function names for the
3884 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3885 array_domain_type = build_index_type (size_int (200));
3887 /* Make a type for arrays of characters.
3888 With luck nothing will ever really depend on the length of this
3890 char_array_type_node
3891 = build_array_type (char_type_node, array_domain_type);
3893 /* Likewise for arrays of ints. */
3895 = build_array_type (integer_type_node, array_domain_type);
3897 string_type_node = build_pointer_type (char_type_node);
3898 const_string_type_node
3899 = build_pointer_type (build_qualified_type
3900 (char_type_node, TYPE_QUAL_CONST));
3902 /* This is special for C++ so functions can be overloaded. */
3903 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3904 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3905 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3906 if (c_dialect_cxx ())
3908 if (TYPE_UNSIGNED (wchar_type_node))
3909 wchar_type_node = make_unsigned_type (wchar_type_size);
3911 wchar_type_node = make_signed_type (wchar_type_size);
3912 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3916 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3917 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3920 /* This is for wide string constants. */
3921 wchar_array_type_node
3922 = build_array_type (wchar_type_node, array_domain_type);
3925 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3928 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3930 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3932 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3934 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3935 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3937 lang_hooks.decls.pushdecl
3938 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3939 va_list_type_node));
3941 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3943 va_list_arg_type_node = va_list_ref_type_node =
3944 build_pointer_type (TREE_TYPE (va_list_type_node));
3948 va_list_arg_type_node = va_list_type_node;
3949 va_list_ref_type_node = build_reference_type (va_list_type_node);
3952 if (!flag_preprocess_only)
3953 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
3955 main_identifier_node = get_identifier ("main");
3957 /* Create the built-in __null node. It is important that this is
3959 null_node = make_node (INTEGER_CST);
3960 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3962 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3963 memset (builtin_types, 0, sizeof (builtin_types));
3966 /* Look up the function in built_in_decls that corresponds to DECL
3967 and set ASMSPEC as its user assembler name. DECL must be a
3968 function decl that declares a builtin. */
3971 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3974 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3975 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3978 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3979 set_user_assembler_name (builtin, asmspec);
3980 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3981 init_block_move_fn (asmspec);
3982 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3983 init_block_clear_fn (asmspec);
3986 /* The number of named compound-literals generated thus far. */
3987 static GTY(()) int compound_literal_number;
3989 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3992 set_compound_literal_name (tree decl)
3995 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3996 compound_literal_number);
3997 compound_literal_number++;
3998 DECL_NAME (decl) = get_identifier (name);
4002 build_va_arg (tree expr, tree type)
4004 return build1 (VA_ARG_EXPR, type, expr);
4008 /* Linked list of disabled built-in functions. */
4010 typedef struct disabled_builtin
4013 struct disabled_builtin *next;
4015 static disabled_builtin *disabled_builtins = NULL;
4017 static bool builtin_function_disabled_p (const char *);
4019 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4020 begins with "__builtin_", give an error. */
4023 disable_builtin_function (const char *name)
4025 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4026 error ("cannot disable built-in function %qs", name);
4029 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4030 new_disabled_builtin->name = name;
4031 new_disabled_builtin->next = disabled_builtins;
4032 disabled_builtins = new_disabled_builtin;
4037 /* Return true if the built-in function NAME has been disabled, false
4041 builtin_function_disabled_p (const char *name)
4043 disabled_builtin *p;
4044 for (p = disabled_builtins; p != NULL; p = p->next)
4046 if (strcmp (name, p->name) == 0)
4053 /* Worker for DEF_BUILTIN.
4054 Possibly define a builtin function with one or two names.
4055 Does not declare a non-__builtin_ function if flag_no_builtin, or if
4056 nonansi_p and flag_no_nonansi_builtin. */
4059 def_builtin_1 (enum built_in_function fncode,
4061 enum built_in_class fnclass,
4062 tree fntype, tree libtype,
4063 bool both_p, bool fallback_p, bool nonansi_p,
4064 tree fnattrs, bool implicit_p)
4067 const char *libname;
4069 if (fntype == error_mark_node)
4072 gcc_assert ((!both_p && !fallback_p)
4073 || !strncmp (name, "__builtin_",
4074 strlen ("__builtin_")));
4076 libname = name + strlen ("__builtin_");
4077 decl = add_builtin_function (name, fntype, fncode, fnclass,
4078 (fallback_p ? libname : NULL),
4081 && !flag_no_builtin && !builtin_function_disabled_p (libname)
4082 && !(nonansi_p && flag_no_nonansi_builtin))
4083 add_builtin_function (libname, libtype, fncode, fnclass,
4086 built_in_decls[(int) fncode] = decl;
4088 implicit_built_in_decls[(int) fncode] = decl;
4091 /* Nonzero if the type T promotes to int. This is (nearly) the
4092 integral promotions defined in ISO C99 6.3.1.1/2. */
4095 c_promoting_integer_type_p (const_tree t)
4097 switch (TREE_CODE (t))
4100 return (TYPE_MAIN_VARIANT (t) == char_type_node
4101 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
4102 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
4103 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
4104 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
4105 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
4108 /* ??? Technically all enumerations not larger than an int
4109 promote to an int. But this is used along code paths
4110 that only want to notice a size change. */
4111 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
4121 /* Return 1 if PARMS specifies a fixed number of parameters
4122 and none of their types is affected by default promotions. */
4125 self_promoting_args_p (const_tree parms)
4128 for (t = parms; t; t = TREE_CHAIN (t))
4130 tree type = TREE_VALUE (t);
4132 if (type == error_mark_node)
4135 if (TREE_CHAIN (t) == 0 && type != void_type_node)
4141 if (TYPE_MAIN_VARIANT (type) == float_type_node)
4144 if (c_promoting_integer_type_p (type))
4150 /* Recursively examines the array elements of TYPE, until a non-array
4151 element type is found. */
4154 strip_array_types (tree type)
4156 while (TREE_CODE (type) == ARRAY_TYPE)
4157 type = TREE_TYPE (type);
4162 /* Recursively remove any '*' or '&' operator from TYPE. */
4164 strip_pointer_operator (tree t)
4166 while (POINTER_TYPE_P (t))
4171 /* Recursively remove pointer or array type from TYPE. */
4173 strip_pointer_or_array_types (tree t)
4175 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
4180 /* Used to compare case labels. K1 and K2 are actually tree nodes
4181 representing case labels, or NULL_TREE for a `default' label.
4182 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4183 K2, and 0 if K1 and K2 are equal. */
4186 case_compare (splay_tree_key k1, splay_tree_key k2)
4188 /* Consider a NULL key (such as arises with a `default' label) to be
4189 smaller than anything else. */
4195 return tree_int_cst_compare ((tree) k1, (tree) k2);
4198 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4199 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4200 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4201 case label was declared using the usual C/C++ syntax, rather than
4202 the GNU case range extension. CASES is a tree containing all the
4203 case ranges processed so far; COND is the condition for the
4204 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
4205 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
4208 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
4209 tree low_value, tree high_value)
4214 splay_tree_node node;
4216 /* Create the LABEL_DECL itself. */
4217 label = create_artificial_label ();
4219 /* If there was an error processing the switch condition, bail now
4220 before we get more confused. */
4221 if (!cond || cond == error_mark_node)
4224 if ((low_value && TREE_TYPE (low_value)
4225 && POINTER_TYPE_P (TREE_TYPE (low_value)))
4226 || (high_value && TREE_TYPE (high_value)
4227 && POINTER_TYPE_P (TREE_TYPE (high_value))))
4229 error ("pointers are not permitted as case values");
4233 /* Case ranges are a GNU extension. */
4234 if (high_value && pedantic)
4235 pedwarn ("range expressions in switch statements are non-standard");
4237 type = TREE_TYPE (cond);
4240 low_value = check_case_value (low_value);
4241 low_value = convert_and_check (type, low_value);
4242 if (low_value == error_mark_node)
4247 high_value = check_case_value (high_value);
4248 high_value = convert_and_check (type, high_value);
4249 if (high_value == error_mark_node)
4253 if (low_value && high_value)
4255 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4256 really a case range, even though it was written that way.
4257 Remove the HIGH_VALUE to simplify later processing. */
4258 if (tree_int_cst_equal (low_value, high_value))
4259 high_value = NULL_TREE;
4260 else if (!tree_int_cst_lt (low_value, high_value))
4261 warning (0, "empty range specified");
4264 /* See if the case is in range of the type of the original testing
4265 expression. If both low_value and high_value are out of range,
4266 don't insert the case label and return NULL_TREE. */
4268 && !check_case_bounds (type, orig_type,
4269 &low_value, high_value ? &high_value : NULL))
4272 /* Look up the LOW_VALUE in the table of case labels we already
4274 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4275 /* If there was not an exact match, check for overlapping ranges.
4276 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4277 that's a `default' label and the only overlap is an exact match. */
4278 if (!node && (low_value || high_value))
4280 splay_tree_node low_bound;
4281 splay_tree_node high_bound;
4283 /* Even though there wasn't an exact match, there might be an
4284 overlap between this case range and another case range.
4285 Since we've (inductively) not allowed any overlapping case
4286 ranges, we simply need to find the greatest low case label
4287 that is smaller that LOW_VALUE, and the smallest low case
4288 label that is greater than LOW_VALUE. If there is an overlap
4289 it will occur in one of these two ranges. */
4290 low_bound = splay_tree_predecessor (cases,
4291 (splay_tree_key) low_value);
4292 high_bound = splay_tree_successor (cases,
4293 (splay_tree_key) low_value);
4295 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4296 the LOW_VALUE, so there is no need to check unless the
4297 LOW_BOUND is in fact itself a case range. */
4299 && CASE_HIGH ((tree) low_bound->value)
4300 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4303 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4304 range is bigger than the low end of the current range, so we
4305 are only interested if the current range is a real range, and
4306 not an ordinary case label. */
4309 && (tree_int_cst_compare ((tree) high_bound->key,
4314 /* If there was an overlap, issue an error. */
4317 tree duplicate = CASE_LABEL ((tree) node->value);
4321 error ("duplicate (or overlapping) case value");
4322 error ("%Jthis is the first entry overlapping that value", duplicate);
4326 error ("duplicate case value") ;
4327 error ("%Jpreviously used here", duplicate);
4331 error ("multiple default labels in one switch");
4332 error ("%Jthis is the first default label", duplicate);
4337 /* Add a CASE_LABEL to the statement-tree. */
4338 case_label = add_stmt (build_case_label (low_value, high_value, label));
4339 /* Register this case label in the splay tree. */
4340 splay_tree_insert (cases,
4341 (splay_tree_key) low_value,
4342 (splay_tree_value) case_label);
4347 /* Add a label so that the back-end doesn't think that the beginning of
4348 the switch is unreachable. Note that we do not add a case label, as
4349 that just leads to duplicates and thence to failure later on. */
4352 tree t = create_artificial_label ();
4353 add_stmt (build_stmt (LABEL_EXPR, t));
4355 return error_mark_node;
4358 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4359 Used to verify that case values match up with enumerator values. */
4362 match_case_to_enum_1 (tree key, tree type, tree label)
4364 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4366 /* ??? Not working too hard to print the double-word value.
4367 Should perhaps be done with %lwd in the diagnostic routines? */
4368 if (TREE_INT_CST_HIGH (key) == 0)
4369 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4370 TREE_INT_CST_LOW (key));
4371 else if (!TYPE_UNSIGNED (type)
4372 && TREE_INT_CST_HIGH (key) == -1
4373 && TREE_INT_CST_LOW (key) != 0)
4374 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4375 -TREE_INT_CST_LOW (key));
4377 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4378 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
4380 if (TYPE_NAME (type) == 0)
4381 warning (0, "%Jcase value %qs not in enumerated type",
4382 CASE_LABEL (label), buf);
4384 warning (0, "%Jcase value %qs not in enumerated type %qT",
4385 CASE_LABEL (label), buf, type);
4388 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4389 Used to verify that case values match up with enumerator values. */
4392 match_case_to_enum (splay_tree_node node, void *data)
4394 tree label = (tree) node->value;
4395 tree type = (tree) data;
4397 /* Skip default case. */
4398 if (!CASE_LOW (label))
4401 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4402 when we did our enum->case scan. Reset our scratch bit after. */
4403 if (!CASE_LOW_SEEN (label))
4404 match_case_to_enum_1 (CASE_LOW (label), type, label);
4406 CASE_LOW_SEEN (label) = 0;
4408 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
4409 not set, that means that CASE_HIGH did not appear when we did our
4410 enum->case scan. Reset our scratch bit after. */
4411 if (CASE_HIGH (label))
4413 if (!CASE_HIGH_SEEN (label))
4414 match_case_to_enum_1 (CASE_HIGH (label), type, label);
4416 CASE_HIGH_SEEN (label) = 0;
4422 /* Handle -Wswitch*. Called from the front end after parsing the
4423 switch construct. */
4424 /* ??? Should probably be somewhere generic, since other languages
4425 besides C and C++ would want this. At the moment, however, C/C++
4426 are the only tree-ssa languages that support enumerations at all,
4427 so the point is moot. */
4430 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4431 tree type, tree cond)
4433 splay_tree_node default_node;
4434 splay_tree_node node;
4437 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4440 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4442 warning (OPT_Wswitch_default, "%Hswitch missing default case",
4445 /* From here on, we only care about about enumerated types. */
4446 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4449 /* If the switch expression was an enumerated type, check that
4450 exactly all enumeration literals are covered by the cases.
4451 The check is made when -Wswitch was specified and there is no
4452 default case, or when -Wswitch-enum was specified. */
4454 if (!warn_switch_enum
4455 && !(warn_switch && !default_node))
4458 /* Clearing COND if it is not an integer constant simplifies
4459 the tests inside the loop below. */
4460 if (TREE_CODE (cond) != INTEGER_CST)
4463 /* The time complexity here is O(N*lg(N)) worst case, but for the
4464 common case of monotonically increasing enumerators, it is
4465 O(N), since the nature of the splay tree will keep the next
4466 element adjacent to the root at all times. */
4468 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4470 tree value = TREE_VALUE (chain);
4471 node = splay_tree_lookup (cases, (splay_tree_key) value);
4474 /* Mark the CASE_LOW part of the case entry as seen. */
4475 tree label = (tree) node->value;
4476 CASE_LOW_SEEN (label) = 1;
4480 /* Even though there wasn't an exact match, there might be a
4481 case range which includes the enumator's value. */
4482 node = splay_tree_predecessor (cases, (splay_tree_key) value);
4483 if (node && CASE_HIGH ((tree) node->value))
4485 tree label = (tree) node->value;
4486 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4489 /* If we match the upper bound exactly, mark the CASE_HIGH
4490 part of the case entry as seen. */
4492 CASE_HIGH_SEEN (label) = 1;
4497 /* We've now determined that this enumerated literal isn't
4498 handled by the case labels of the switch statement. */
4500 /* If the switch expression is a constant, we only really care
4501 about whether that constant is handled by the switch. */
4502 if (cond && tree_int_cst_compare (cond, value))
4505 warning (0, "%Henumeration value %qE not handled in switch",
4506 &switch_location, TREE_PURPOSE (chain));
4509 /* Warn if there are case expressions that don't correspond to
4510 enumerators. This can occur since C and C++ don't enforce
4511 type-checking of assignments to enumeration variables.
4513 The time complexity here is now always O(N) worst case, since
4514 we should have marked both the lower bound and upper bound of
4515 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4516 above. This scan also resets those fields. */
4517 splay_tree_foreach (cases, match_case_to_enum, type);
4520 /* Finish an expression taking the address of LABEL (an
4521 IDENTIFIER_NODE). Returns an expression for the address. */
4524 finish_label_address_expr (tree label)
4529 pedwarn ("taking the address of a label is non-standard");
4531 if (label == error_mark_node)
4532 return error_mark_node;
4534 label = lookup_label (label);
4535 if (label == NULL_TREE)
4536 result = null_pointer_node;
4539 TREE_USED (label) = 1;
4540 result = build1 (ADDR_EXPR, ptr_type_node, label);
4541 /* The current function in not necessarily uninlinable.
4542 Computed gotos are incompatible with inlining, but the value
4543 here could be used only in a diagnostic, for example. */
4549 /* Hook used by expand_expr to expand language-specific tree codes. */
4550 /* The only things that should go here are bits needed to expand
4551 constant initializers. Everything else should be handled by the
4552 gimplification routines. */
4555 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4556 int modifier /* Actually enum_modifier. */,
4559 switch (TREE_CODE (exp))
4561 case COMPOUND_LITERAL_EXPR:
4563 /* Initialize the anonymous variable declared in the compound
4564 literal, then return the variable. */
4565 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4566 emit_local_var (decl);
4567 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4575 /* Hook used by staticp to handle language-specific tree codes. */
4578 c_staticp (tree exp)
4580 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4581 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4586 /* Given a boolean expression ARG, return a tree representing an increment
4587 or decrement (as indicated by CODE) of ARG. The front end must check for
4588 invalid cases (e.g., decrement in C++). */
4590 boolean_increment (enum tree_code code, tree arg)
4593 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
4595 arg = stabilize_reference (arg);
4598 case PREINCREMENT_EXPR:
4599 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4601 case POSTINCREMENT_EXPR:
4602 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4603 arg = save_expr (arg);
4604 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4605 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4607 case PREDECREMENT_EXPR:
4608 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4609 invert_truthvalue (arg));
4611 case POSTDECREMENT_EXPR:
4612 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4613 invert_truthvalue (arg));
4614 arg = save_expr (arg);
4615 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4616 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4621 TREE_SIDE_EFFECTS (val) = 1;
4625 /* Built-in macros for stddef.h, that require macros defined in this
4628 c_stddef_cpp_builtins(void)
4630 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4631 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4632 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4633 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4634 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4635 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4639 c_init_attributes (void)
4641 /* Fill in the built_in_attributes array. */
4642 #define DEF_ATTR_NULL_TREE(ENUM) \
4643 built_in_attributes[(int) ENUM] = NULL_TREE;
4644 #define DEF_ATTR_INT(ENUM, VALUE) \
4645 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4646 #define DEF_ATTR_IDENT(ENUM, STRING) \
4647 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4648 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4649 built_in_attributes[(int) ENUM] \
4650 = tree_cons (built_in_attributes[(int) PURPOSE], \
4651 built_in_attributes[(int) VALUE], \
4652 built_in_attributes[(int) CHAIN]);
4653 #include "builtin-attrs.def"
4654 #undef DEF_ATTR_NULL_TREE
4656 #undef DEF_ATTR_IDENT
4657 #undef DEF_ATTR_TREE_LIST
4660 /* Attribute handlers common to C front ends. */
4662 /* Handle a "packed" attribute; arguments as in
4663 struct attribute_spec.handler. */
4666 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4667 int flags, bool *no_add_attrs)
4671 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4672 *node = build_variant_type_copy (*node);
4673 TYPE_PACKED (*node) = 1;
4675 else if (TREE_CODE (*node) == FIELD_DECL)
4677 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4678 warning (OPT_Wattributes,
4679 "%qE attribute ignored for field of type %qT",
4680 name, TREE_TYPE (*node));
4682 DECL_PACKED (*node) = 1;
4684 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4685 used for DECL_REGISTER. It wouldn't mean anything anyway.
4686 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4687 that changes what the typedef is typing. */
4690 warning (OPT_Wattributes, "%qE attribute ignored", name);
4691 *no_add_attrs = true;
4697 /* Handle a "nocommon" attribute; arguments as in
4698 struct attribute_spec.handler. */
4701 handle_nocommon_attribute (tree *node, tree name,
4702 tree ARG_UNUSED (args),
4703 int ARG_UNUSED (flags), bool *no_add_attrs)
4705 if (TREE_CODE (*node) == VAR_DECL)
4706 DECL_COMMON (*node) = 0;
4709 warning (OPT_Wattributes, "%qE attribute ignored", name);
4710 *no_add_attrs = true;
4716 /* Handle a "common" attribute; arguments as in
4717 struct attribute_spec.handler. */
4720 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4721 int ARG_UNUSED (flags), bool *no_add_attrs)
4723 if (TREE_CODE (*node) == VAR_DECL)
4724 DECL_COMMON (*node) = 1;
4727 warning (OPT_Wattributes, "%qE attribute ignored", name);
4728 *no_add_attrs = true;
4734 /* Handle a "noreturn" attribute; arguments as in
4735 struct attribute_spec.handler. */
4738 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4739 int ARG_UNUSED (flags), bool *no_add_attrs)
4741 tree type = TREE_TYPE (*node);
4743 /* See FIXME comment in c_common_attribute_table. */
4744 if (TREE_CODE (*node) == FUNCTION_DECL)
4745 TREE_THIS_VOLATILE (*node) = 1;
4746 else if (TREE_CODE (type) == POINTER_TYPE
4747 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4749 = build_pointer_type
4750 (build_type_variant (TREE_TYPE (type),
4751 TYPE_READONLY (TREE_TYPE (type)), 1));
4754 warning (OPT_Wattributes, "%qE attribute ignored", name);
4755 *no_add_attrs = true;
4761 /* Handle a "hot" and attribute; arguments as in
4762 struct attribute_spec.handler. */
4765 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4766 int ARG_UNUSED (flags), bool *no_add_attrs)
4768 if (TREE_CODE (*node) == FUNCTION_DECL)
4770 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
4772 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4774 *no_add_attrs = true;
4776 /* Do nothing else, just set the attribute. We'll get at
4777 it later with lookup_attribute. */
4781 warning (OPT_Wattributes, "%qE attribute ignored", name);
4782 *no_add_attrs = true;
4787 /* Handle a "cold" and attribute; arguments as in
4788 struct attribute_spec.handler. */
4791 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4792 int ARG_UNUSED (flags), bool *no_add_attrs)
4794 if (TREE_CODE (*node) == FUNCTION_DECL)
4796 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
4798 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
4800 *no_add_attrs = true;
4802 /* Do nothing else, just set the attribute. We'll get at
4803 it later with lookup_attribute. */
4807 warning (OPT_Wattributes, "%qE attribute ignored", name);
4808 *no_add_attrs = true;
4814 /* Handle a "noinline" attribute; arguments as in
4815 struct attribute_spec.handler. */
4818 handle_noinline_attribute (tree *node, tree name,
4819 tree ARG_UNUSED (args),
4820 int ARG_UNUSED (flags), bool *no_add_attrs)
4822 if (TREE_CODE (*node) == FUNCTION_DECL)
4823 DECL_UNINLINABLE (*node) = 1;
4826 warning (OPT_Wattributes, "%qE attribute ignored", name);
4827 *no_add_attrs = true;
4833 /* Handle a "always_inline" attribute; arguments as in
4834 struct attribute_spec.handler. */
4837 handle_always_inline_attribute (tree *node, tree name,
4838 tree ARG_UNUSED (args),
4839 int ARG_UNUSED (flags),
4842 if (TREE_CODE (*node) == FUNCTION_DECL)
4844 /* Set the attribute and mark it for disregarding inline
4846 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
4850 warning (OPT_Wattributes, "%qE attribute ignored", name);
4851 *no_add_attrs = true;
4857 /* Handle a "gnu_inline" attribute; arguments as in
4858 struct attribute_spec.handler. */
4861 handle_gnu_inline_attribute (tree *node, tree name,
4862 tree ARG_UNUSED (args),
4863 int ARG_UNUSED (flags),
4866 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4868 /* Do nothing else, just set the attribute. We'll get at
4869 it later with lookup_attribute. */
4873 warning (OPT_Wattributes, "%qE attribute ignored", name);
4874 *no_add_attrs = true;
4880 /* Handle a "flatten" attribute; arguments as in
4881 struct attribute_spec.handler. */
4884 handle_flatten_attribute (tree *node, tree name,
4885 tree args ATTRIBUTE_UNUSED,
4886 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4888 if (TREE_CODE (*node) == FUNCTION_DECL)
4889 /* Do nothing else, just set the attribute. We'll get at
4890 it later with lookup_attribute. */
4894 warning (OPT_Wattributes, "%qE attribute ignored", name);
4895 *no_add_attrs = true;
4902 /* Handle a "used" attribute; arguments as in
4903 struct attribute_spec.handler. */
4906 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4907 int ARG_UNUSED (flags), bool *no_add_attrs)
4911 if (TREE_CODE (node) == FUNCTION_DECL
4912 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4914 TREE_USED (node) = 1;
4915 DECL_PRESERVE_P (node) = 1;
4919 warning (OPT_Wattributes, "%qE attribute ignored", name);
4920 *no_add_attrs = true;
4926 /* Handle a "unused" attribute; arguments as in
4927 struct attribute_spec.handler. */
4930 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4931 int flags, bool *no_add_attrs)
4937 if (TREE_CODE (decl) == PARM_DECL
4938 || TREE_CODE (decl) == VAR_DECL
4939 || TREE_CODE (decl) == FUNCTION_DECL
4940 || TREE_CODE (decl) == LABEL_DECL
4941 || TREE_CODE (decl) == TYPE_DECL)
4942 TREE_USED (decl) = 1;
4945 warning (OPT_Wattributes, "%qE attribute ignored", name);
4946 *no_add_attrs = true;
4951 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4952 *node = build_variant_type_copy (*node);
4953 TREE_USED (*node) = 1;
4959 /* Handle a "externally_visible" attribute; arguments as in
4960 struct attribute_spec.handler. */
4963 handle_externally_visible_attribute (tree *pnode, tree name,
4964 tree ARG_UNUSED (args),
4965 int ARG_UNUSED (flags),
4970 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4972 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4973 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4975 warning (OPT_Wattributes,
4976 "%qE attribute have effect only on public objects", name);
4977 *no_add_attrs = true;
4982 warning (OPT_Wattributes, "%qE attribute ignored", name);
4983 *no_add_attrs = true;
4989 /* Handle a "const" attribute; arguments as in
4990 struct attribute_spec.handler. */
4993 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4994 int ARG_UNUSED (flags), bool *no_add_attrs)
4996 tree type = TREE_TYPE (*node);
4998 /* See FIXME comment on noreturn in c_common_attribute_table. */
4999 if (TREE_CODE (*node) == FUNCTION_DECL)
5000 TREE_READONLY (*node) = 1;
5001 else if (TREE_CODE (type) == POINTER_TYPE
5002 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5004 = build_pointer_type
5005 (build_type_variant (TREE_TYPE (type), 1,
5006 TREE_THIS_VOLATILE (TREE_TYPE (type))));
5009 warning (OPT_Wattributes, "%qE attribute ignored", name);
5010 *no_add_attrs = true;
5016 /* Handle a "transparent_union" attribute; arguments as in
5017 struct attribute_spec.handler. */
5020 handle_transparent_union_attribute (tree *node, tree name,
5021 tree ARG_UNUSED (args), int flags,
5026 *no_add_attrs = true;
5030 if (TREE_CODE (*node) != TYPE_DECL)
5032 node = &TREE_TYPE (*node);
5035 else if (TYPE_P (*node))
5040 if (TREE_CODE (type) == UNION_TYPE)
5042 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5043 the code in finish_struct. */
5044 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5046 if (TYPE_FIELDS (type) == NULL_TREE
5047 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
5050 /* A type variant isn't good enough, since we don't a cast
5051 to such a type removed as a no-op. */
5052 *node = type = build_duplicate_type (type);
5055 TYPE_TRANSPARENT_UNION (type) = 1;
5060 warning (OPT_Wattributes, "%qE attribute ignored", name);
5064 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
5065 get the requested priority for a constructor or destructor,
5066 possibly issuing diagnostics for invalid or reserved
5069 static priority_type
5070 get_priority (tree args, bool is_destructor)
5076 return DEFAULT_INIT_PRIORITY;
5078 if (!SUPPORTS_INIT_PRIORITY)
5081 error ("destructor priorities are not supported");
5083 error ("constructor priorities are not supported");
5084 return DEFAULT_INIT_PRIORITY;
5087 arg = TREE_VALUE (args);
5088 if (!host_integerp (arg, /*pos=*/0)
5089 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
5092 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
5093 if (pri < 0 || pri > MAX_INIT_PRIORITY)
5096 if (pri <= MAX_RESERVED_INIT_PRIORITY)
5100 "destructor priorities from 0 to %d are reserved "
5101 "for the implementation",
5102 MAX_RESERVED_INIT_PRIORITY);
5105 "constructor priorities from 0 to %d are reserved "
5106 "for the implementation",
5107 MAX_RESERVED_INIT_PRIORITY);
5113 error ("destructor priorities must be integers from 0 to %d inclusive",
5116 error ("constructor priorities must be integers from 0 to %d inclusive",
5118 return DEFAULT_INIT_PRIORITY;
5121 /* Handle a "constructor" attribute; arguments as in
5122 struct attribute_spec.handler. */
5125 handle_constructor_attribute (tree *node, tree name, tree args,
5126 int ARG_UNUSED (flags),
5130 tree type = TREE_TYPE (decl);
5132 if (TREE_CODE (decl) == FUNCTION_DECL
5133 && TREE_CODE (type) == FUNCTION_TYPE
5134 && decl_function_context (decl) == 0)
5136 priority_type priority;
5137 DECL_STATIC_CONSTRUCTOR (decl) = 1;
5138 priority = get_priority (args, /*is_destructor=*/false);
5139 SET_DECL_INIT_PRIORITY (decl, priority);
5140 TREE_USED (decl) = 1;
5144 warning (OPT_Wattributes, "%qE attribute ignored", name);
5145 *no_add_attrs = true;
5151 /* Handle a "destructor" attribute; arguments as in
5152 struct attribute_spec.handler. */
5155 handle_destructor_attribute (tree *node, tree name, tree args,
5156 int ARG_UNUSED (flags),
5160 tree type = TREE_TYPE (decl);
5162 if (TREE_CODE (decl) == FUNCTION_DECL
5163 && TREE_CODE (type) == FUNCTION_TYPE
5164 && decl_function_context (decl) == 0)
5166 priority_type priority;
5167 DECL_STATIC_DESTRUCTOR (decl) = 1;
5168 priority = get_priority (args, /*is_destructor=*/true);
5169 SET_DECL_FINI_PRIORITY (decl, priority);
5170 TREE_USED (decl) = 1;
5174 warning (OPT_Wattributes, "%qE attribute ignored", name);
5175 *no_add_attrs = true;
5181 /* Handle a "mode" attribute; arguments as in
5182 struct attribute_spec.handler. */
5185 handle_mode_attribute (tree *node, tree name, tree args,
5186 int ARG_UNUSED (flags), bool *no_add_attrs)
5190 *no_add_attrs = true;
5192 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5193 warning (OPT_Wattributes, "%qE attribute ignored", name);
5197 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5198 int len = strlen (p);
5199 enum machine_mode mode = VOIDmode;
5203 if (len > 4 && p[0] == '_' && p[1] == '_'
5204 && p[len - 1] == '_' && p[len - 2] == '_')
5206 char *newp = (char *) alloca (len - 1);
5208 strcpy (newp, &p[2]);
5209 newp[len - 4] = '\0';
5213 /* Change this type to have a type with the specified mode.
5214 First check for the special modes. */
5215 if (!strcmp (p, "byte"))
5217 else if (!strcmp (p, "word"))
5219 else if (!strcmp (p, "pointer"))
5221 else if (!strcmp (p, "libgcc_cmp_return"))
5222 mode = targetm.libgcc_cmp_return_mode ();
5223 else if (!strcmp (p, "libgcc_shift_count"))
5224 mode = targetm.libgcc_shift_count_mode ();
5226 for (j = 0; j < NUM_MACHINE_MODES; j++)
5227 if (!strcmp (p, GET_MODE_NAME (j)))
5229 mode = (enum machine_mode) j;
5233 if (mode == VOIDmode)
5235 error ("unknown machine mode %qs", p);
5240 switch (GET_MODE_CLASS (mode))
5243 case MODE_PARTIAL_INT:
5245 case MODE_DECIMAL_FLOAT:
5250 valid_mode = targetm.scalar_mode_supported_p (mode);
5253 case MODE_COMPLEX_INT:
5254 case MODE_COMPLEX_FLOAT:
5255 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5258 case MODE_VECTOR_INT:
5259 case MODE_VECTOR_FLOAT:
5260 case MODE_VECTOR_FRACT:
5261 case MODE_VECTOR_UFRACT:
5262 case MODE_VECTOR_ACCUM:
5263 case MODE_VECTOR_UACCUM:
5264 warning (OPT_Wattributes, "specifying vector types with "
5265 "__attribute__ ((mode)) is deprecated");
5266 warning (OPT_Wattributes,
5267 "use __attribute__ ((vector_size)) instead");
5268 valid_mode = vector_mode_valid_p (mode);
5276 error ("unable to emulate %qs", p);
5280 if (POINTER_TYPE_P (type))
5282 tree (*fn)(tree, enum machine_mode, bool);
5284 if (!targetm.valid_pointer_mode (mode))
5286 error ("invalid pointer mode %qs", p);
5290 if (TREE_CODE (type) == POINTER_TYPE)
5291 fn = build_pointer_type_for_mode;
5293 fn = build_reference_type_for_mode;
5294 typefm = fn (TREE_TYPE (type), mode, false);
5298 /* For fixed-point modes, we need to test if the signness of type
5299 and the machine mode are consistent. */
5300 if (ALL_FIXED_POINT_MODE_P (mode)
5301 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
5303 error ("signness of type and machine mode %qs don't match", p);
5306 /* For fixed-point modes, we need to pass saturating info. */
5307 typefm = lang_hooks.types.type_for_mode (mode,
5308 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
5309 : TYPE_UNSIGNED (type));
5312 if (typefm == NULL_TREE)
5314 error ("no data type for mode %qs", p);
5317 else if (TREE_CODE (type) == ENUMERAL_TYPE)
5319 /* For enumeral types, copy the precision from the integer
5320 type returned above. If not an INTEGER_TYPE, we can't use
5321 this mode for this type. */
5322 if (TREE_CODE (typefm) != INTEGER_TYPE)
5324 error ("cannot use mode %qs for enumeral types", p);
5328 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5330 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5335 /* We cannot build a type variant, as there's code that assumes
5336 that TYPE_MAIN_VARIANT has the same mode. This includes the
5337 debug generators. Instead, create a subrange type. This
5338 results in all of the enumeral values being emitted only once
5339 in the original, and the subtype gets them by reference. */
5340 if (TYPE_UNSIGNED (type))
5341 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5343 typefm = make_signed_type (TYPE_PRECISION (typefm));
5344 TREE_TYPE (typefm) = type;
5347 else if (VECTOR_MODE_P (mode)
5348 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5349 : TREE_CODE (type) != TREE_CODE (typefm))
5351 error ("mode %qs applied to inappropriate type", p);
5361 /* Handle a "section" attribute; arguments as in
5362 struct attribute_spec.handler. */
5365 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5366 int ARG_UNUSED (flags), bool *no_add_attrs)
5370 if (targetm.have_named_sections)
5372 user_defined_section_attribute = true;
5374 if ((TREE_CODE (decl) == FUNCTION_DECL
5375 || TREE_CODE (decl) == VAR_DECL)
5376 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5378 if (TREE_CODE (decl) == VAR_DECL
5379 && current_function_decl != NULL_TREE
5380 && !TREE_STATIC (decl))
5382 error ("%Jsection attribute cannot be specified for "
5383 "local variables", decl);
5384 *no_add_attrs = true;
5387 /* The decl may have already been given a section attribute
5388 from a previous declaration. Ensure they match. */
5389 else if (DECL_SECTION_NAME (decl) != NULL_TREE
5390 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5391 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5393 error ("section of %q+D conflicts with previous declaration",
5395 *no_add_attrs = true;
5398 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5402 error ("section attribute not allowed for %q+D", *node);
5403 *no_add_attrs = true;
5408 error ("%Jsection attributes are not supported for this target", *node);
5409 *no_add_attrs = true;
5415 /* Handle a "aligned" attribute; arguments as in
5416 struct attribute_spec.handler. */
5419 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5420 int flags, bool *no_add_attrs)
5422 tree decl = NULL_TREE;
5425 tree align_expr = (args ? TREE_VALUE (args)
5426 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5432 type = &TREE_TYPE (decl);
5433 is_type = TREE_CODE (*node) == TYPE_DECL;
5435 else if (TYPE_P (*node))
5436 type = node, is_type = 1;
5438 if (TREE_CODE (align_expr) != INTEGER_CST)
5440 error ("requested alignment is not a constant");
5441 *no_add_attrs = true;
5443 else if ((i = tree_log2 (align_expr)) == -1)
5445 error ("requested alignment is not a power of 2");
5446 *no_add_attrs = true;
5448 else if (i > HOST_BITS_PER_INT - 2)
5450 error ("requested alignment is too large");
5451 *no_add_attrs = true;
5455 /* If we have a TYPE_DECL, then copy the type, so that we
5456 don't accidentally modify a builtin type. See pushdecl. */
5457 if (decl && TREE_TYPE (decl) != error_mark_node
5458 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5460 tree tt = TREE_TYPE (decl);
5461 *type = build_variant_type_copy (*type);
5462 DECL_ORIGINAL_TYPE (decl) = tt;
5463 TYPE_NAME (*type) = decl;
5464 TREE_USED (*type) = TREE_USED (decl);
5465 TREE_TYPE (decl) = *type;
5467 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5468 *type = build_variant_type_copy (*type);
5470 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5471 TYPE_USER_ALIGN (*type) = 1;
5473 else if (! VAR_OR_FUNCTION_DECL_P (decl)
5474 && TREE_CODE (decl) != FIELD_DECL)
5476 error ("alignment may not be specified for %q+D", decl);
5477 *no_add_attrs = true;
5479 else if (TREE_CODE (decl) == FUNCTION_DECL
5480 && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
5482 if (DECL_USER_ALIGN (decl))
5483 error ("alignment for %q+D was previously specified as %d "
5484 "and may not be decreased", decl,
5485 DECL_ALIGN (decl) / BITS_PER_UNIT);
5487 error ("alignment for %q+D must be at least %d", decl,
5488 DECL_ALIGN (decl) / BITS_PER_UNIT);
5489 *no_add_attrs = true;
5493 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5494 DECL_USER_ALIGN (decl) = 1;
5500 /* Handle a "weak" attribute; arguments as in
5501 struct attribute_spec.handler. */
5504 handle_weak_attribute (tree *node, tree name,
5505 tree ARG_UNUSED (args),
5506 int ARG_UNUSED (flags),
5507 bool * ARG_UNUSED (no_add_attrs))
5509 if (TREE_CODE (*node) == FUNCTION_DECL
5510 || TREE_CODE (*node) == VAR_DECL)
5511 declare_weak (*node);
5513 warning (OPT_Wattributes, "%qE attribute ignored", name);
5519 /* Handle an "alias" attribute; arguments as in
5520 struct attribute_spec.handler. */
5523 handle_alias_attribute (tree *node, tree name, tree args,
5524 int ARG_UNUSED (flags), bool *no_add_attrs)
5528 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5529 || (TREE_CODE (decl) != FUNCTION_DECL
5530 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
5531 /* A static variable declaration is always a tentative definition,
5532 but the alias is a non-tentative definition which overrides. */
5533 || (TREE_CODE (decl) != FUNCTION_DECL
5534 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
5536 error ("%q+D defined both normally and as an alias", decl);
5537 *no_add_attrs = true;
5540 /* Note that the very first time we process a nested declaration,
5541 decl_function_context will not be set. Indeed, *would* never
5542 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
5543 we do below. After such frobbery, pushdecl would set the context.
5544 In any case, this is never what we want. */
5545 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
5549 id = TREE_VALUE (args);
5550 if (TREE_CODE (id) != STRING_CST)
5552 error ("alias argument not a string");
5553 *no_add_attrs = true;
5556 id = get_identifier (TREE_STRING_POINTER (id));
5557 /* This counts as a use of the object pointed to. */
5560 if (TREE_CODE (decl) == FUNCTION_DECL)
5561 DECL_INITIAL (decl) = error_mark_node;
5564 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
5565 DECL_EXTERNAL (decl) = 1;
5567 DECL_EXTERNAL (decl) = 0;
5568 TREE_STATIC (decl) = 1;
5573 warning (OPT_Wattributes, "%qE attribute ignored", name);
5574 *no_add_attrs = true;
5580 /* Handle a "weakref" attribute; arguments as in struct
5581 attribute_spec.handler. */
5584 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5585 int flags, bool *no_add_attrs)
5587 tree attr = NULL_TREE;
5589 /* We must ignore the attribute when it is associated with
5590 local-scoped decls, since attribute alias is ignored and many
5591 such symbols do not even have a DECL_WEAK field. */
5592 if (decl_function_context (*node) || current_function_decl)
5594 warning (OPT_Wattributes, "%qE attribute ignored", name);
5595 *no_add_attrs = true;
5599 /* The idea here is that `weakref("name")' mutates into `weakref,
5600 alias("name")', and weakref without arguments, in turn,
5601 implicitly adds weak. */
5605 attr = tree_cons (get_identifier ("alias"), args, attr);
5606 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
5608 *no_add_attrs = true;
5610 decl_attributes (node, attr, flags);
5614 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
5615 error ("%Jweakref attribute must appear before alias attribute",
5618 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
5619 and that isn't supported; and because it wants to add it to
5620 the list of weak decls, which isn't helpful. */
5621 DECL_WEAK (*node) = 1;
5627 /* Handle an "visibility" attribute; arguments as in
5628 struct attribute_spec.handler. */
5631 handle_visibility_attribute (tree *node, tree name, tree args,
5632 int ARG_UNUSED (flags),
5633 bool *ARG_UNUSED (no_add_attrs))
5636 tree id = TREE_VALUE (args);
5637 enum symbol_visibility vis;
5641 if (TREE_CODE (*node) == ENUMERAL_TYPE)
5643 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
5645 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
5649 else if (TYPE_FIELDS (*node))
5651 error ("%qE attribute ignored because %qT is already defined",
5656 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
5658 warning (OPT_Wattributes, "%qE attribute ignored", name);
5662 if (TREE_CODE (id) != STRING_CST)
5664 error ("visibility argument not a string");
5668 /* If this is a type, set the visibility on the type decl. */
5671 decl = TYPE_NAME (decl);
5674 if (TREE_CODE (decl) == IDENTIFIER_NODE)
5676 warning (OPT_Wattributes, "%qE attribute ignored on types",
5682 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
5683 vis = VISIBILITY_DEFAULT;
5684 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
5685 vis = VISIBILITY_INTERNAL;
5686 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
5687 vis = VISIBILITY_HIDDEN;
5688 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
5689 vis = VISIBILITY_PROTECTED;
5692 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
5693 vis = VISIBILITY_DEFAULT;
5696 if (DECL_VISIBILITY_SPECIFIED (decl)
5697 && vis != DECL_VISIBILITY (decl))
5699 tree attributes = (TYPE_P (*node)
5700 ? TYPE_ATTRIBUTES (*node)
5701 : DECL_ATTRIBUTES (decl));
5702 if (lookup_attribute ("visibility", attributes))
5703 error ("%qD redeclared with different visibility", decl);
5704 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5705 && lookup_attribute ("dllimport", attributes))
5706 error ("%qD was declared %qs which implies default visibility",
5708 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5709 && lookup_attribute ("dllexport", attributes))
5710 error ("%qD was declared %qs which implies default visibility",
5714 DECL_VISIBILITY (decl) = vis;
5715 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5717 /* Go ahead and attach the attribute to the node as well. This is needed
5718 so we can determine whether we have VISIBILITY_DEFAULT because the
5719 visibility was not specified, or because it was explicitly overridden
5720 from the containing scope. */
5725 /* Determine the ELF symbol visibility for DECL, which is either a
5726 variable or a function. It is an error to use this function if a
5727 definition of DECL is not available in this translation unit.
5728 Returns true if the final visibility has been determined by this
5729 function; false if the caller is free to make additional
5733 c_determine_visibility (tree decl)
5735 gcc_assert (TREE_CODE (decl) == VAR_DECL
5736 || TREE_CODE (decl) == FUNCTION_DECL);
5738 /* If the user explicitly specified the visibility with an
5739 attribute, honor that. DECL_VISIBILITY will have been set during
5740 the processing of the attribute. We check for an explicit
5741 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5742 to distinguish the use of an attribute from the use of a "#pragma
5743 GCC visibility push(...)"; in the latter case we still want other
5744 considerations to be able to overrule the #pragma. */
5745 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
5746 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5747 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
5748 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
5751 /* Set default visibility to whatever the user supplied with
5752 visibility_specified depending on #pragma GCC visibility. */
5753 if (!DECL_VISIBILITY_SPECIFIED (decl))
5755 DECL_VISIBILITY (decl) = default_visibility;
5756 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5761 /* Handle an "tls_model" attribute; arguments as in
5762 struct attribute_spec.handler. */
5765 handle_tls_model_attribute (tree *node, tree name, tree args,
5766 int ARG_UNUSED (flags), bool *no_add_attrs)
5770 enum tls_model kind;
5772 *no_add_attrs = true;
5774 if (!DECL_THREAD_LOCAL_P (decl))
5776 warning (OPT_Wattributes, "%qE attribute ignored", name);
5780 kind = DECL_TLS_MODEL (decl);
5781 id = TREE_VALUE (args);
5782 if (TREE_CODE (id) != STRING_CST)
5784 error ("tls_model argument not a string");
5788 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5789 kind = TLS_MODEL_LOCAL_EXEC;
5790 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5791 kind = TLS_MODEL_INITIAL_EXEC;
5792 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5793 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5794 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5795 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5797 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5799 DECL_TLS_MODEL (decl) = kind;
5803 /* Handle a "no_instrument_function" attribute; arguments as in
5804 struct attribute_spec.handler. */
5807 handle_no_instrument_function_attribute (tree *node, tree name,
5808 tree ARG_UNUSED (args),
5809 int ARG_UNUSED (flags),
5814 if (TREE_CODE (decl) != FUNCTION_DECL)
5816 error ("%J%qE attribute applies only to functions", decl, name);
5817 *no_add_attrs = true;
5819 else if (DECL_INITIAL (decl))
5821 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5822 *no_add_attrs = true;
5825 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5830 /* Handle a "malloc" attribute; arguments as in
5831 struct attribute_spec.handler. */
5834 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5835 int ARG_UNUSED (flags), bool *no_add_attrs)
5837 if (TREE_CODE (*node) == FUNCTION_DECL
5838 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5839 DECL_IS_MALLOC (*node) = 1;
5842 warning (OPT_Wattributes, "%qE attribute ignored", name);
5843 *no_add_attrs = true;
5849 /* Handle a "alloc_size" attribute; arguments as in
5850 struct attribute_spec.handler. */
5853 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5854 int ARG_UNUSED (flags), bool *no_add_attrs)
5856 tree params = TYPE_ARG_TYPES (*node);
5857 unsigned arg_count = 0;
5859 for (; TREE_CHAIN (params); params = TREE_CHAIN (params))
5862 for (; args; args = TREE_CHAIN (args))
5864 tree position = TREE_VALUE (args);
5866 if (TREE_CODE (position) != INTEGER_CST
5867 || TREE_INT_CST_HIGH (position)
5868 || TREE_INT_CST_LOW (position) < 1
5869 || TREE_INT_CST_LOW (position) > arg_count )
5871 warning (OPT_Wattributes,
5872 "alloc_size parameter outside range");
5873 *no_add_attrs = true;
5880 /* Handle a "returns_twice" attribute; arguments as in
5881 struct attribute_spec.handler. */
5884 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5885 int ARG_UNUSED (flags), bool *no_add_attrs)
5887 if (TREE_CODE (*node) == FUNCTION_DECL)
5888 DECL_IS_RETURNS_TWICE (*node) = 1;
5891 warning (OPT_Wattributes, "%qE attribute ignored", name);
5892 *no_add_attrs = true;
5898 /* Handle a "no_limit_stack" attribute; arguments as in
5899 struct attribute_spec.handler. */
5902 handle_no_limit_stack_attribute (tree *node, tree name,
5903 tree ARG_UNUSED (args),
5904 int ARG_UNUSED (flags),
5909 if (TREE_CODE (decl) != FUNCTION_DECL)
5911 error ("%J%qE attribute applies only to functions", decl, name);
5912 *no_add_attrs = true;
5914 else if (DECL_INITIAL (decl))
5916 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5917 *no_add_attrs = true;
5920 DECL_NO_LIMIT_STACK (decl) = 1;
5925 /* Handle a "pure" attribute; arguments as in
5926 struct attribute_spec.handler. */
5929 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5930 int ARG_UNUSED (flags), bool *no_add_attrs)
5932 if (TREE_CODE (*node) == FUNCTION_DECL)
5933 DECL_IS_PURE (*node) = 1;
5934 /* ??? TODO: Support types. */
5937 warning (OPT_Wattributes, "%qE attribute ignored", name);
5938 *no_add_attrs = true;
5944 /* Handle a "no vops" attribute; arguments as in
5945 struct attribute_spec.handler. */
5948 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5949 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5950 bool *ARG_UNUSED (no_add_attrs))
5952 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5953 DECL_IS_NOVOPS (*node) = 1;
5957 /* Handle a "deprecated" attribute; arguments as in
5958 struct attribute_spec.handler. */
5961 handle_deprecated_attribute (tree *node, tree name,
5962 tree ARG_UNUSED (args), int flags,
5965 tree type = NULL_TREE;
5967 tree what = NULL_TREE;
5972 type = TREE_TYPE (decl);
5974 if (TREE_CODE (decl) == TYPE_DECL
5975 || TREE_CODE (decl) == PARM_DECL
5976 || TREE_CODE (decl) == VAR_DECL
5977 || TREE_CODE (decl) == FUNCTION_DECL
5978 || TREE_CODE (decl) == FIELD_DECL)
5979 TREE_DEPRECATED (decl) = 1;
5983 else if (TYPE_P (*node))
5985 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5986 *node = build_variant_type_copy (*node);
5987 TREE_DEPRECATED (*node) = 1;
5995 *no_add_attrs = true;
5996 if (type && TYPE_NAME (type))
5998 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5999 what = TYPE_NAME (*node);
6000 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6001 && DECL_NAME (TYPE_NAME (type)))
6002 what = DECL_NAME (TYPE_NAME (type));
6005 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
6007 warning (OPT_Wattributes, "%qE attribute ignored", name);
6013 /* Handle a "vector_size" attribute; arguments as in
6014 struct attribute_spec.handler. */
6017 handle_vector_size_attribute (tree *node, tree name, tree args,
6018 int ARG_UNUSED (flags),
6021 unsigned HOST_WIDE_INT vecsize, nunits;
6022 enum machine_mode orig_mode;
6023 tree type = *node, new_type, size;
6025 *no_add_attrs = true;
6027 size = TREE_VALUE (args);
6029 if (!host_integerp (size, 1))
6031 warning (OPT_Wattributes, "%qE attribute ignored", name);
6035 /* Get the vector size (in bytes). */
6036 vecsize = tree_low_cst (size, 1);
6038 /* We need to provide for vector pointers, vector arrays, and
6039 functions returning vectors. For example:
6041 __attribute__((vector_size(16))) short *foo;
6043 In this case, the mode is SI, but the type being modified is
6044 HI, so we need to look further. */
6046 while (POINTER_TYPE_P (type)
6047 || TREE_CODE (type) == FUNCTION_TYPE
6048 || TREE_CODE (type) == METHOD_TYPE
6049 || TREE_CODE (type) == ARRAY_TYPE)
6050 type = TREE_TYPE (type);
6052 /* Get the mode of the type being modified. */
6053 orig_mode = TYPE_MODE (type);
6055 if (TREE_CODE (type) == RECORD_TYPE
6056 || TREE_CODE (type) == UNION_TYPE
6057 || TREE_CODE (type) == VECTOR_TYPE
6058 || (!SCALAR_FLOAT_MODE_P (orig_mode)
6059 && GET_MODE_CLASS (orig_mode) != MODE_INT
6060 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
6061 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
6063 error ("invalid vector type for attribute %qE", name);
6067 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
6069 error ("vector size not an integral multiple of component size");
6075 error ("zero vector size");
6079 /* Calculate how many units fit in the vector. */
6080 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6081 if (nunits & (nunits - 1))
6083 error ("number of components of the vector not a power of two");
6087 new_type = build_vector_type (type, nunits);
6089 /* Build back pointers if needed. */
6090 *node = reconstruct_complex_type (*node, new_type);
6095 /* Handle the "nonnull" attribute. */
6097 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
6098 tree args, int ARG_UNUSED (flags),
6102 unsigned HOST_WIDE_INT attr_arg_num;
6104 /* If no arguments are specified, all pointer arguments should be
6105 non-null. Verify a full prototype is given so that the arguments
6106 will have the correct types when we actually check them later. */
6109 if (!TYPE_ARG_TYPES (type))
6111 error ("nonnull attribute without arguments on a non-prototype");
6112 *no_add_attrs = true;
6117 /* Argument list specified. Verify that each argument number references
6118 a pointer argument. */
6119 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6122 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
6124 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
6126 error ("nonnull argument has invalid operand number (argument %lu)",
6127 (unsigned long) attr_arg_num);
6128 *no_add_attrs = true;
6132 argument = TYPE_ARG_TYPES (type);
6135 for (ck_num = 1; ; ck_num++)
6137 if (!argument || ck_num == arg_num)
6139 argument = TREE_CHAIN (argument);
6143 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6145 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6146 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6147 *no_add_attrs = true;
6151 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6153 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6154 (unsigned long) attr_arg_num, (unsigned long) arg_num);
6155 *no_add_attrs = true;
6164 /* Check the argument list of a function call for null in argument slots
6165 that are marked as requiring a non-null pointer argument. The NARGS
6166 arguments are passed in the array ARGARRAY.
6170 check_function_nonnull (tree attrs, int nargs, tree *argarray)
6175 for (a = attrs; a; a = TREE_CHAIN (a))
6177 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6179 args = TREE_VALUE (a);
6181 /* Walk the argument list. If we encounter an argument number we
6182 should check for non-null, do it. If the attribute has no args,
6183 then every pointer argument is checked (in which case the check
6184 for pointer type is done in check_nonnull_arg). */
6185 for (i = 0; i < nargs; i++)
6187 if (!args || nonnull_check_p (args, i + 1))
6188 check_function_arguments_recurse (check_nonnull_arg, NULL,
6196 /* Check that the Nth argument of a function call (counting backwards
6197 from the end) is a (pointer)0. The NARGS arguments are passed in the
6201 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
6203 tree attr = lookup_attribute ("sentinel", attrs);
6211 /* Skip over the named arguments. */
6212 while (typelist && len < nargs)
6214 typelist = TREE_CHAIN (typelist);
6218 if (TREE_VALUE (attr))
6220 tree p = TREE_VALUE (TREE_VALUE (attr));
6221 pos = TREE_INT_CST_LOW (p);
6224 /* The sentinel must be one of the varargs, i.e.
6225 in position >= the number of fixed arguments. */
6226 if ((nargs - 1 - pos) < len)
6228 warning (OPT_Wformat,
6229 "not enough variable arguments to fit a sentinel");
6233 /* Validate the sentinel. */
6234 sentinel = argarray[nargs - 1 - pos];
6235 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
6236 || !integer_zerop (sentinel))
6237 /* Although __null (in C++) is only an integer we allow it
6238 nevertheless, as we are guaranteed that it's exactly
6239 as wide as a pointer, and we don't want to force
6240 users to cast the NULL they have written there.
6241 We warn with -Wstrict-null-sentinel, though. */
6242 && (warn_strict_null_sentinel || null_node != sentinel))
6243 warning (OPT_Wformat, "missing sentinel in function call");
6247 /* Helper for check_function_nonnull; given a list of operands which
6248 must be non-null in ARGS, determine if operand PARAM_NUM should be
6252 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6254 unsigned HOST_WIDE_INT arg_num = 0;
6256 for (; args; args = TREE_CHAIN (args))
6258 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6262 if (arg_num == param_num)
6268 /* Check that the function argument PARAM (which is operand number
6269 PARAM_NUM) is non-null. This is called by check_function_nonnull
6270 via check_function_arguments_recurse. */
6273 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6274 unsigned HOST_WIDE_INT param_num)
6276 /* Just skip checking the argument if it's not a pointer. This can
6277 happen if the "nonnull" attribute was given without an operand
6278 list (which means to check every pointer argument). */
6280 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6283 if (integer_zerop (param))
6284 warning (OPT_Wnonnull, "null argument where non-null required "
6285 "(argument %lu)", (unsigned long) param_num);
6288 /* Helper for nonnull attribute handling; fetch the operand number
6289 from the attribute argument list. */
6292 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6294 /* Verify the arg number is a constant. */
6295 if (TREE_CODE (arg_num_expr) != INTEGER_CST
6296 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6299 *valp = TREE_INT_CST_LOW (arg_num_expr);
6303 /* Handle a "nothrow" attribute; arguments as in
6304 struct attribute_spec.handler. */
6307 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6308 int ARG_UNUSED (flags), bool *no_add_attrs)
6310 if (TREE_CODE (*node) == FUNCTION_DECL)
6311 TREE_NOTHROW (*node) = 1;
6312 /* ??? TODO: Support types. */
6315 warning (OPT_Wattributes, "%qE attribute ignored", name);
6316 *no_add_attrs = true;
6322 /* Handle a "cleanup" attribute; arguments as in
6323 struct attribute_spec.handler. */
6326 handle_cleanup_attribute (tree *node, tree name, tree args,
6327 int ARG_UNUSED (flags), bool *no_add_attrs)
6330 tree cleanup_id, cleanup_decl;
6332 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6333 for global destructors in C++. This requires infrastructure that
6334 we don't have generically at the moment. It's also not a feature
6335 we'd be missing too much, since we do have attribute constructor. */
6336 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6338 warning (OPT_Wattributes, "%qE attribute ignored", name);
6339 *no_add_attrs = true;
6343 /* Verify that the argument is a function in scope. */
6344 /* ??? We could support pointers to functions here as well, if
6345 that was considered desirable. */
6346 cleanup_id = TREE_VALUE (args);
6347 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6349 error ("cleanup argument not an identifier");
6350 *no_add_attrs = true;
6353 cleanup_decl = lookup_name (cleanup_id);
6354 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6356 error ("cleanup argument not a function");
6357 *no_add_attrs = true;
6361 /* That the function has proper type is checked with the
6362 eventual call to build_function_call. */
6367 /* Handle a "warn_unused_result" attribute. No special handling. */
6370 handle_warn_unused_result_attribute (tree *node, tree name,
6371 tree ARG_UNUSED (args),
6372 int ARG_UNUSED (flags), bool *no_add_attrs)
6374 /* Ignore the attribute for functions not returning any value. */
6375 if (VOID_TYPE_P (TREE_TYPE (*node)))
6377 warning (OPT_Wattributes, "%qE attribute ignored", name);
6378 *no_add_attrs = true;
6384 /* Handle a "sentinel" attribute. */
6387 handle_sentinel_attribute (tree *node, tree name, tree args,
6388 int ARG_UNUSED (flags), bool *no_add_attrs)
6390 tree params = TYPE_ARG_TYPES (*node);
6394 warning (OPT_Wattributes,
6395 "%qE attribute requires prototypes with named arguments", name);
6396 *no_add_attrs = true;
6400 while (TREE_CHAIN (params))
6401 params = TREE_CHAIN (params);
6403 if (VOID_TYPE_P (TREE_VALUE (params)))
6405 warning (OPT_Wattributes,
6406 "%qE attribute only applies to variadic functions", name);
6407 *no_add_attrs = true;
6413 tree position = TREE_VALUE (args);
6415 if (TREE_CODE (position) != INTEGER_CST)
6417 warning (OPT_Wattributes,
6418 "requested position is not an integer constant");
6419 *no_add_attrs = true;
6423 if (tree_int_cst_lt (position, integer_zero_node))
6425 warning (OPT_Wattributes,
6426 "requested position is less than zero");
6427 *no_add_attrs = true;
6435 /* Handle a "type_generic" attribute. */
6438 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6439 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6440 bool * ARG_UNUSED (no_add_attrs))
6442 /* Ensure we have a function type, with no arguments. */
6443 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE && ! TYPE_ARG_TYPES (*node));
6448 /* Check for valid arguments being passed to a function.
6449 ATTRS is a list of attributes. There are NARGS arguments in the array
6450 ARGARRAY. TYPELIST is the list of argument types for the function.
6453 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
6455 /* Check for null being passed in a pointer argument that must be
6456 non-null. We also need to do this if format checking is enabled. */
6459 check_function_nonnull (attrs, nargs, argarray);
6461 /* Check for errors in format strings. */
6463 if (warn_format || warn_missing_format_attribute)
6464 check_function_format (attrs, nargs, argarray);
6467 check_function_sentinel (attrs, nargs, argarray, typelist);
6470 /* Generic argument checking recursion routine. PARAM is the argument to
6471 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6472 once the argument is resolved. CTX is context for the callback. */
6474 check_function_arguments_recurse (void (*callback)
6475 (void *, tree, unsigned HOST_WIDE_INT),
6476 void *ctx, tree param,
6477 unsigned HOST_WIDE_INT param_num)
6479 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
6480 && (TYPE_PRECISION (TREE_TYPE (param))
6481 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
6483 /* Strip coercion. */
6484 check_function_arguments_recurse (callback, ctx,
6485 TREE_OPERAND (param, 0), param_num);
6489 if (TREE_CODE (param) == CALL_EXPR)
6491 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
6493 bool found_format_arg = false;
6495 /* See if this is a call to a known internationalization function
6496 that modifies a format arg. Such a function may have multiple
6497 format_arg attributes (for example, ngettext). */
6499 for (attrs = TYPE_ATTRIBUTES (type);
6501 attrs = TREE_CHAIN (attrs))
6502 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
6505 tree format_num_expr;
6508 call_expr_arg_iterator iter;
6510 /* Extract the argument number, which was previously checked
6512 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
6514 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
6515 && !TREE_INT_CST_HIGH (format_num_expr));
6517 format_num = TREE_INT_CST_LOW (format_num_expr);
6519 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
6521 inner_arg = next_call_expr_arg (&iter), i++)
6522 if (i == format_num)
6524 check_function_arguments_recurse (callback, ctx,
6525 inner_arg, param_num);
6526 found_format_arg = true;
6531 /* If we found a format_arg attribute and did a recursive check,
6532 we are done with checking this argument. Otherwise, we continue
6533 and this will be considered a non-literal. */
6534 if (found_format_arg)
6538 if (TREE_CODE (param) == COND_EXPR)
6540 /* Check both halves of the conditional expression. */
6541 check_function_arguments_recurse (callback, ctx,
6542 TREE_OPERAND (param, 1), param_num);
6543 check_function_arguments_recurse (callback, ctx,
6544 TREE_OPERAND (param, 2), param_num);
6548 (*callback) (ctx, param, param_num);
6551 /* Function to help qsort sort FIELD_DECLs by name order. */
6554 field_decl_cmp (const void *x_p, const void *y_p)
6556 const tree *const x = (const tree *const) x_p;
6557 const tree *const y = (const tree *const) y_p;
6559 if (DECL_NAME (*x) == DECL_NAME (*y))
6560 /* A nontype is "greater" than a type. */
6561 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6562 if (DECL_NAME (*x) == NULL_TREE)
6564 if (DECL_NAME (*y) == NULL_TREE)
6566 if (DECL_NAME (*x) < DECL_NAME (*y))
6572 gt_pointer_operator new_value;
6576 /* This routine compares two fields like field_decl_cmp but using the
6577 pointer operator in resort_data. */
6580 resort_field_decl_cmp (const void *x_p, const void *y_p)
6582 const tree *const x = (const tree *const) x_p;
6583 const tree *const y = (const tree *const) y_p;
6585 if (DECL_NAME (*x) == DECL_NAME (*y))
6586 /* A nontype is "greater" than a type. */
6587 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
6588 if (DECL_NAME (*x) == NULL_TREE)
6590 if (DECL_NAME (*y) == NULL_TREE)
6593 tree d1 = DECL_NAME (*x);
6594 tree d2 = DECL_NAME (*y);
6595 resort_data.new_value (&d1, resort_data.cookie);
6596 resort_data.new_value (&d2, resort_data.cookie);
6603 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
6606 resort_sorted_fields (void *obj,
6607 void * ARG_UNUSED (orig_obj),
6608 gt_pointer_operator new_value,
6611 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
6612 resort_data.new_value = new_value;
6613 resort_data.cookie = cookie;
6614 qsort (&sf->elts[0], sf->len, sizeof (tree),
6615 resort_field_decl_cmp);
6618 /* Subroutine of c_parse_error.
6619 Return the result of concatenating LHS and RHS. RHS is really
6620 a string literal, its first character is indicated by RHS_START and
6621 RHS_SIZE is its length (including the terminating NUL character).
6623 The caller is responsible for deleting the returned pointer. */
6626 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
6628 const int lhs_size = strlen (lhs);
6629 char *result = XNEWVEC (char, lhs_size + rhs_size);
6630 strncpy (result, lhs, lhs_size);
6631 strncpy (result + lhs_size, rhs_start, rhs_size);
6635 /* Issue the error given by GMSGID, indicating that it occurred before
6636 TOKEN, which had the associated VALUE. */
6639 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
6641 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6643 char *message = NULL;
6645 if (token == CPP_EOF)
6646 message = catenate_messages (gmsgid, " at end of input");
6647 else if (token == CPP_CHAR || token == CPP_WCHAR)
6649 unsigned int val = TREE_INT_CST_LOW (value);
6650 const char *const ell = (token == CPP_CHAR) ? "" : "L";
6651 if (val <= UCHAR_MAX && ISGRAPH (val))
6652 message = catenate_messages (gmsgid, " before %s'%c'");
6654 message = catenate_messages (gmsgid, " before %s'\\x%x'");
6656 error (message, ell, val);
6660 else if (token == CPP_STRING || token == CPP_WSTRING)
6661 message = catenate_messages (gmsgid, " before string constant");
6662 else if (token == CPP_NUMBER)
6663 message = catenate_messages (gmsgid, " before numeric constant");
6664 else if (token == CPP_NAME)
6666 message = catenate_messages (gmsgid, " before %qE");
6667 error (message, value);
6671 else if (token == CPP_PRAGMA)
6672 message = catenate_messages (gmsgid, " before %<#pragma%>");
6673 else if (token == CPP_PRAGMA_EOL)
6674 message = catenate_messages (gmsgid, " before end of line");
6675 else if (token < N_TTYPES)
6677 message = catenate_messages (gmsgid, " before %qs token");
6678 error (message, cpp_type2name (token));
6690 #undef catenate_messages
6693 /* Walk a gimplified function and warn for functions whose return value is
6694 ignored and attribute((warn_unused_result)) is set. This is done before
6695 inlining, so we don't have to worry about that. */
6698 c_warn_unused_result (tree *top_p)
6701 tree_stmt_iterator i;
6704 switch (TREE_CODE (t))
6706 case STATEMENT_LIST:
6707 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
6708 c_warn_unused_result (tsi_stmt_ptr (i));
6712 c_warn_unused_result (&COND_EXPR_THEN (t));
6713 c_warn_unused_result (&COND_EXPR_ELSE (t));
6716 c_warn_unused_result (&BIND_EXPR_BODY (t));
6718 case TRY_FINALLY_EXPR:
6719 case TRY_CATCH_EXPR:
6720 c_warn_unused_result (&TREE_OPERAND (t, 0));
6721 c_warn_unused_result (&TREE_OPERAND (t, 1));
6724 c_warn_unused_result (&CATCH_BODY (t));
6726 case EH_FILTER_EXPR:
6727 c_warn_unused_result (&EH_FILTER_FAILURE (t));
6734 /* This is a naked call, as opposed to a CALL_EXPR nested inside
6735 a MODIFY_EXPR. All calls whose value is ignored should be
6736 represented like this. Look for the attribute. */
6737 fdecl = get_callee_fndecl (t);
6739 ftype = TREE_TYPE (fdecl);
6742 ftype = TREE_TYPE (CALL_EXPR_FN (t));
6743 /* Look past pointer-to-function to the function type itself. */
6744 ftype = TREE_TYPE (ftype);
6747 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
6750 warning (0, "%Hignoring return value of %qD, "
6751 "declared with attribute warn_unused_result",
6752 EXPR_LOCUS (t), fdecl);
6754 warning (0, "%Hignoring return value of function "
6755 "declared with attribute warn_unused_result",
6761 /* Not a container, not a call, or a call whose value is used. */
6766 /* Convert a character from the host to the target execution character
6767 set. cpplib handles this, mostly. */
6770 c_common_to_target_charset (HOST_WIDE_INT c)
6772 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6773 zero-extended under -fno-signed-char. cpplib insists that characters
6774 and character constants are always unsigned. Hence we must convert
6776 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6778 uc = cpp_host_to_exec_charset (parse_in, uc);
6780 if (flag_signed_char)
6781 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6782 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6787 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6788 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6789 NULL, at the bottom; much like the traditional rendering of offsetof as a
6790 macro. Returns the folded and properly cast result. */
6793 fold_offsetof_1 (tree expr, tree stop_ref)
6795 enum tree_code code = PLUS_EXPR;
6798 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6799 return size_zero_node;
6801 switch (TREE_CODE (expr))
6807 error ("cannot apply %<offsetof%> to static data member %qD", expr);
6808 return error_mark_node;
6811 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6812 return error_mark_node;
6815 gcc_assert (integer_zerop (expr));
6816 return size_zero_node;
6820 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6821 gcc_assert (base == error_mark_node || base == size_zero_node);
6825 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6826 if (base == error_mark_node)
6829 t = TREE_OPERAND (expr, 1);
6830 if (DECL_C_BIT_FIELD (t))
6832 error ("attempt to take address of bit-field structure "
6834 return error_mark_node;
6836 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6837 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6842 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6843 if (base == error_mark_node)
6846 t = TREE_OPERAND (expr, 1);
6847 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6850 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6852 t = convert (sizetype, t);
6853 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6857 /* Handle static members of volatile structs. */
6858 t = TREE_OPERAND (expr, 1);
6859 gcc_assert (TREE_CODE (t) == VAR_DECL);
6860 return fold_offsetof_1 (t, stop_ref);
6866 return size_binop (code, base, off);
6870 fold_offsetof (tree expr, tree stop_ref)
6872 /* Convert back from the internal sizetype to size_t. */
6873 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6876 /* Print an error message for an invalid lvalue. USE says
6877 how the lvalue is being used and so selects the error message. */
6880 lvalue_error (enum lvalue_use use)
6885 error ("lvalue required as left operand of assignment");
6888 error ("lvalue required as increment operand");
6891 error ("lvalue required as decrement operand");
6894 error ("lvalue required as unary %<&%> operand");
6897 error ("lvalue required in asm statement");
6904 /* *PTYPE is an incomplete array. Complete it with a domain based on
6905 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6906 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6907 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6910 complete_array_type (tree *ptype, tree initial_value, bool do_default)
6912 tree maxindex, type, main_type, elt, unqual_elt;
6913 int failure = 0, quals;
6914 hashval_t hashcode = 0;
6916 maxindex = size_zero_node;
6919 if (TREE_CODE (initial_value) == STRING_CST)
6922 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6923 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6925 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6927 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6929 if (VEC_empty (constructor_elt, v))
6933 maxindex = integer_minus_one_node;
6938 unsigned HOST_WIDE_INT cnt;
6939 constructor_elt *ce;
6941 if (VEC_index (constructor_elt, v, 0)->index)
6942 maxindex = fold_convert (sizetype,
6943 VEC_index (constructor_elt,
6945 curindex = maxindex;
6948 VEC_iterate (constructor_elt, v, cnt, ce);
6952 curindex = fold_convert (sizetype, ce->index);
6954 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6956 if (tree_int_cst_lt (maxindex, curindex))
6957 maxindex = curindex;
6963 /* Make an error message unless that happened already. */
6964 if (initial_value != error_mark_node)
6976 elt = TREE_TYPE (type);
6977 quals = TYPE_QUALS (strip_array_types (elt));
6981 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6983 /* Using build_distinct_type_copy and modifying things afterward instead
6984 of using build_array_type to create a new type preserves all of the
6985 TYPE_LANG_FLAG_? bits that the front end may have set. */
6986 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6987 TREE_TYPE (main_type) = unqual_elt;
6988 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6989 layout_type (main_type);
6991 /* Make sure we have the canonical MAIN_TYPE. */
6992 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
6993 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
6995 main_type = type_hash_canon (hashcode, main_type);
7000 type = c_build_qualified_type (main_type, quals);
7007 /* Used to help initialize the builtin-types.def table. When a type of
7008 the correct size doesn't exist, use error_mark_node instead of NULL.
7009 The later results in segfaults even when a decl using the type doesn't
7013 builtin_type_for_size (int size, bool unsignedp)
7015 tree type = lang_hooks.types.type_for_size (size, unsignedp);
7016 return type ? type : error_mark_node;
7019 /* A helper function for resolve_overloaded_builtin in resolving the
7020 overloaded __sync_ builtins. Returns a positive power of 2 if the
7021 first operand of PARAMS is a pointer to a supported data type.
7022 Returns 0 if an error is encountered. */
7025 sync_resolve_size (tree function, tree params)
7032 error ("too few arguments to function %qE", function);
7036 type = TREE_TYPE (TREE_VALUE (params));
7037 if (TREE_CODE (type) != POINTER_TYPE)
7040 type = TREE_TYPE (type);
7041 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
7044 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7045 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
7049 error ("incompatible type for argument %d of %qE", 1, function);
7053 /* A helper function for resolve_overloaded_builtin. Adds casts to
7054 PARAMS to make arguments match up with those of FUNCTION. Drops
7055 the variadic arguments at the end. Returns false if some error
7056 was encountered; true on success. */
7059 sync_resolve_params (tree orig_function, tree function, tree params)
7061 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
7065 /* We've declared the implementation functions to use "volatile void *"
7066 as the pointer parameter, so we shouldn't get any complaints from the
7067 call to check_function_arguments what ever type the user used. */
7068 arg_types = TREE_CHAIN (arg_types);
7069 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7072 /* For the rest of the values, we need to cast these to FTYPE, so that we
7073 don't get warnings for passing pointer types, etc. */
7074 while (arg_types != void_list_node)
7078 params = TREE_CHAIN (params);
7081 error ("too few arguments to function %qE", orig_function);
7085 /* ??? Ideally for the first conversion we'd use convert_for_assignment
7086 so that we get warnings for anything that doesn't match the pointer
7087 type. This isn't portable across the C and C++ front ends atm. */
7088 val = TREE_VALUE (params);
7089 val = convert (ptype, val);
7090 val = convert (TREE_VALUE (arg_types), val);
7091 TREE_VALUE (params) = val;
7093 arg_types = TREE_CHAIN (arg_types);
7097 /* The definition of these primitives is variadic, with the remaining
7098 being "an optional list of variables protected by the memory barrier".
7099 No clue what that's supposed to mean, precisely, but we consider all
7100 call-clobbered variables to be protected so we're safe. */
7101 TREE_CHAIN (params) = NULL;
7106 /* A helper function for resolve_overloaded_builtin. Adds a cast to
7107 RESULT to make it match the type of the first pointer argument in
7111 sync_resolve_return (tree params, tree result)
7113 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7114 ptype = TYPE_MAIN_VARIANT (ptype);
7115 return convert (ptype, result);
7118 /* Some builtin functions are placeholders for other expressions. This
7119 function should be called immediately after parsing the call expression
7120 before surrounding code has committed to the type of the expression.
7122 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7123 PARAMS is the argument list for the call. The return value is non-null
7124 when expansion is complete, and null if normal processing should
7128 resolve_overloaded_builtin (tree function, tree params)
7130 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
7131 switch (DECL_BUILT_IN_CLASS (function))
7133 case BUILT_IN_NORMAL:
7136 if (targetm.resolve_overloaded_builtin)
7137 return targetm.resolve_overloaded_builtin (function, params);
7144 /* Handle BUILT_IN_NORMAL here. */
7147 case BUILT_IN_FETCH_AND_ADD_N:
7148 case BUILT_IN_FETCH_AND_SUB_N:
7149 case BUILT_IN_FETCH_AND_OR_N:
7150 case BUILT_IN_FETCH_AND_AND_N:
7151 case BUILT_IN_FETCH_AND_XOR_N:
7152 case BUILT_IN_FETCH_AND_NAND_N:
7153 case BUILT_IN_ADD_AND_FETCH_N:
7154 case BUILT_IN_SUB_AND_FETCH_N:
7155 case BUILT_IN_OR_AND_FETCH_N:
7156 case BUILT_IN_AND_AND_FETCH_N:
7157 case BUILT_IN_XOR_AND_FETCH_N:
7158 case BUILT_IN_NAND_AND_FETCH_N:
7159 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
7160 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
7161 case BUILT_IN_LOCK_TEST_AND_SET_N:
7162 case BUILT_IN_LOCK_RELEASE_N:
7164 int n = sync_resolve_size (function, params);
7165 tree new_function, result;
7168 return error_mark_node;
7170 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
7171 if (!sync_resolve_params (function, new_function, params))
7172 return error_mark_node;
7174 result = build_function_call (new_function, params);
7175 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
7176 && orig_code != BUILT_IN_LOCK_RELEASE_N)
7177 result = sync_resolve_return (params, result);
7187 /* Ignoring their sign, return true if two scalar types are the same. */
7189 same_scalar_type_ignoring_signedness (tree t1, tree t2)
7191 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
7193 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
7194 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
7195 || c2 == FIXED_POINT_TYPE));
7197 /* Equality works here because c_common_signed_type uses
7198 TYPE_MAIN_VARIANT. */
7199 return c_common_signed_type (t1)
7200 == c_common_signed_type (t2);
7203 /* Check for missing format attributes on function pointers. LTYPE is
7204 the new type or left-hand side type. RTYPE is the old type or
7205 right-hand side type. Returns TRUE if LTYPE is missing the desired
7209 check_missing_format_attribute (tree ltype, tree rtype)
7211 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
7214 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
7215 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
7220 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
7221 if (is_attribute_p ("format", TREE_PURPOSE (la)))
7229 /* Subscripting with type char is likely to lose on a machine where
7230 chars are signed. So warn on any machine, but optionally. Don't
7231 warn for unsigned char since that type is safe. Don't warn for
7232 signed char because anyone who uses that must have done so
7233 deliberately. Furthermore, we reduce the false positive load by
7234 warning only for non-constant value of type char. */
7237 warn_array_subscript_with_type_char (tree index)
7239 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
7240 && TREE_CODE (index) != INTEGER_CST)
7241 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
7244 /* Implement -Wparentheses for the unexpected C precedence rules, to
7245 cover cases like x + y << z which readers are likely to
7246 misinterpret. We have seen an expression in which CODE is a binary
7247 operator used to combine expressions headed by CODE_LEFT and
7248 CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
7249 means that that side of the expression was not formed using a
7250 binary operator, or it was enclosed in parentheses. */
7253 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
7254 enum tree_code code_right)
7256 if (!warn_parentheses)
7259 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
7261 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7262 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7263 warning (OPT_Wparentheses,
7264 "suggest parentheses around + or - inside shift");
7267 if (code == TRUTH_ORIF_EXPR)
7269 if (code_left == TRUTH_ANDIF_EXPR
7270 || code_right == TRUTH_ANDIF_EXPR)
7271 warning (OPT_Wparentheses,
7272 "suggest parentheses around && within ||");
7275 if (code == BIT_IOR_EXPR)
7277 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
7278 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7279 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
7280 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7281 warning (OPT_Wparentheses,
7282 "suggest parentheses around arithmetic in operand of |");
7283 /* Check cases like x|y==z */
7284 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7285 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7286 warning (OPT_Wparentheses,
7287 "suggest parentheses around comparison in operand of |");
7290 if (code == BIT_XOR_EXPR)
7292 if (code_left == BIT_AND_EXPR
7293 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
7294 || code_right == BIT_AND_EXPR
7295 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7296 warning (OPT_Wparentheses,
7297 "suggest parentheses around arithmetic in operand of ^");
7298 /* Check cases like x^y==z */
7299 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7300 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7301 warning (OPT_Wparentheses,
7302 "suggest parentheses around comparison in operand of ^");
7305 if (code == BIT_AND_EXPR)
7307 if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
7308 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
7309 warning (OPT_Wparentheses,
7310 "suggest parentheses around + or - in operand of &");
7311 /* Check cases like x&y==z */
7312 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7313 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7314 warning (OPT_Wparentheses,
7315 "suggest parentheses around comparison in operand of &");
7318 if (code == EQ_EXPR || code == NE_EXPR)
7320 if (TREE_CODE_CLASS (code_left) == tcc_comparison
7321 || TREE_CODE_CLASS (code_right) == tcc_comparison)
7322 warning (OPT_Wparentheses,
7323 "suggest parentheses around comparison in operand of %s",
7324 code == EQ_EXPR ? "==" : "!=");
7326 else if (TREE_CODE_CLASS (code) == tcc_comparison)
7328 if ((TREE_CODE_CLASS (code_left) == tcc_comparison
7329 && code_left != NE_EXPR && code_left != EQ_EXPR)
7330 || (TREE_CODE_CLASS (code_right) == tcc_comparison
7331 && code_right != NE_EXPR && code_right != EQ_EXPR))
7332 warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
7333 "have their mathematical meaning");
7337 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
7340 warn_for_unused_label (tree label)
7342 if (!TREE_USED (label))
7344 if (DECL_INITIAL (label))
7345 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
7347 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
7351 #ifndef TARGET_HAS_TARGETCM
7352 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
7355 /* Warn for division by zero according to the value of DIVISOR. */
7358 warn_for_div_by_zero (tree divisor)
7360 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
7361 about division by zero. Do not issue a warning if DIVISOR has a
7362 floating-point type, since we consider 0.0/0.0 a valid way of
7363 generating a NaN. */
7364 if (skip_evaluation == 0
7365 && (integer_zerop (divisor) || fixed_zerop (divisor)))
7366 warning (OPT_Wdiv_by_zero, "division by zero");
7369 #include "gt-c-common.h"