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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
36 #include "diagnostic.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
45 #include "tree-iterator.h"
48 cpp_reader *parse_in; /* Declared in c-pragma.h. */
50 /* We let tm.h override the types used here, to handle trivial differences
51 such as the choice of unsigned int or long unsigned int for size_t.
52 When machines start needing nontrivial differences in the size type,
53 it would be best to do something here to figure out automatically
54 from other information what type to use. */
57 #define SIZE_TYPE "long unsigned int"
61 #define PID_TYPE "int"
65 #define WCHAR_TYPE "int"
68 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
69 #define MODIFIED_WCHAR_TYPE \
70 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
73 #define PTRDIFF_TYPE "long int"
77 #define WINT_TYPE "unsigned int"
81 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
83 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
89 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
91 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
92 ? "long unsigned int" \
93 : "long long unsigned int"))
96 /* The following symbols are subsumed in the c_global_trees array, and
97 listed here individually for documentation purposes.
99 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
101 tree short_integer_type_node;
102 tree long_integer_type_node;
103 tree long_long_integer_type_node;
105 tree short_unsigned_type_node;
106 tree long_unsigned_type_node;
107 tree long_long_unsigned_type_node;
109 tree truthvalue_type_node;
110 tree truthvalue_false_node;
111 tree truthvalue_true_node;
113 tree ptrdiff_type_node;
115 tree unsigned_char_type_node;
116 tree signed_char_type_node;
117 tree wchar_type_node;
118 tree signed_wchar_type_node;
119 tree unsigned_wchar_type_node;
121 tree float_type_node;
122 tree double_type_node;
123 tree long_double_type_node;
125 tree complex_integer_type_node;
126 tree complex_float_type_node;
127 tree complex_double_type_node;
128 tree complex_long_double_type_node;
130 tree intQI_type_node;
131 tree intHI_type_node;
132 tree intSI_type_node;
133 tree intDI_type_node;
134 tree intTI_type_node;
136 tree unsigned_intQI_type_node;
137 tree unsigned_intHI_type_node;
138 tree unsigned_intSI_type_node;
139 tree unsigned_intDI_type_node;
140 tree unsigned_intTI_type_node;
142 tree widest_integer_literal_type_node;
143 tree widest_unsigned_literal_type_node;
145 Nodes for types `void *' and `const void *'.
147 tree ptr_type_node, const_ptr_type_node;
149 Nodes for types `char *' and `const char *'.
151 tree string_type_node, const_string_type_node;
153 Type `char[SOMENUMBER]'.
154 Used when an array of char is needed and the size is irrelevant.
156 tree char_array_type_node;
158 Type `int[SOMENUMBER]' or something like it.
159 Used when an array of int needed and the size is irrelevant.
161 tree int_array_type_node;
163 Type `wchar_t[SOMENUMBER]' or something like it.
164 Used when a wide string literal is created.
166 tree wchar_array_type_node;
168 Type `int ()' -- used for implicit declaration of functions.
170 tree default_function_type;
172 A VOID_TYPE node, packaged in a TREE_LIST.
176 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
177 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
178 VAR_DECLS, but C++ does.)
180 tree function_name_decl_node;
181 tree pretty_function_name_decl_node;
182 tree c99_function_name_decl_node;
184 Stack of nested function name VAR_DECLs.
186 tree saved_function_name_decls;
190 tree c_global_trees[CTI_MAX];
192 /* TRUE if a code represents a statement. The front end init
193 langhook should take care of initialization of this array. */
195 bool statement_code_p[MAX_TREE_CODES];
197 /* Switches common to the C front ends. */
199 /* Nonzero if prepreprocessing only. */
201 int flag_preprocess_only;
203 /* Nonzero means don't output line number information. */
205 char flag_no_line_commands;
207 /* Nonzero causes -E output not to be done, but directives such as
208 #define that have side effects are still obeyed. */
212 /* Nonzero means dump macros in some fashion. */
214 char flag_dump_macros;
216 /* Nonzero means pass #include lines through to the output. */
218 char flag_dump_includes;
220 /* Nonzero means process PCH files while preprocessing. */
222 bool flag_pch_preprocess;
224 /* The file name to which we should write a precompiled header, or
225 NULL if no header will be written in this compile. */
227 const char *pch_file;
229 /* Nonzero if an ISO standard was selected. It rejects macros in the
233 /* Nonzero if -undef was given. It suppresses target built-in macros
237 /* Nonzero means don't recognize the non-ANSI builtin functions. */
241 /* Nonzero means don't recognize the non-ANSI builtin functions.
244 int flag_no_nonansi_builtin;
246 /* Nonzero means give `double' the same size as `float'. */
248 int flag_short_double;
250 /* Nonzero means give `wchar_t' the same size as `short'. */
252 int flag_short_wchar;
254 /* Nonzero means allow Microsoft extensions without warnings or errors. */
255 int flag_ms_extensions;
257 /* Nonzero means don't recognize the keyword `asm'. */
261 /* Nonzero means give string constants the type `const char *', as mandated
264 int flag_const_strings;
266 /* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
268 int flag_signed_bitfields = 1;
269 int explicit_flag_signed_bitfields;
271 /* Nonzero means warn about deprecated conversion from string constant to
274 int warn_write_strings;
276 /* Warn about #pragma directives that are not recognized. */
278 int warn_unknown_pragmas; /* Tri state variable. */
280 /* Warn about format/argument anomalies in calls to formatted I/O functions
281 (*printf, *scanf, strftime, strfmon, etc.). */
285 /* Zero means that faster, ...NonNil variants of objc_msgSend...
286 calls will be used in ObjC; passing nil receivers to such calls
287 will most likely result in crashes. */
288 int flag_nil_receivers = 1;
290 /* Nonzero means that we will allow new ObjC exception syntax (@throw,
291 @try, etc.) in source code. */
292 int flag_objc_exceptions = 0;
294 /* Nonzero means that we generate NeXT setjmp based exceptions. */
295 int flag_objc_sjlj_exceptions = -1;
297 /* Nonzero means that code generation will be altered to support
298 "zero-link" execution. This currently affects ObjC only, but may
299 affect other languages in the future. */
300 int flag_zero_link = 0;
302 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
303 unit. It will inform the ObjC runtime that class definition(s) herein
304 contained are to replace one(s) previously loaded. */
305 int flag_replace_objc_classes = 0;
307 /* C/ObjC language option variables. */
310 /* Nonzero means allow type mismatches in conditional expressions;
311 just make their values `void'. */
313 int flag_cond_mismatch;
315 /* Nonzero means enable C89 Amendment 1 features. */
319 /* Nonzero means use the ISO C99 dialect of C. */
323 /* Nonzero means that we have builtin functions, and main is an int. */
327 /* Warn if main is suspicious. */
332 /* ObjC language option variables. */
335 /* Open and close the file for outputting class declarations, if
338 int flag_gen_declaration;
340 /* Generate code for GNU or NeXT runtime environment. */
342 #ifdef NEXT_OBJC_RUNTIME
343 int flag_next_runtime = 1;
345 int flag_next_runtime = 0;
348 /* Tells the compiler that this is a special run. Do not perform any
349 compiling, instead we are to test some platform dependent features
350 and output a C header file with appropriate definitions. */
352 int print_struct_values;
354 /* ???. Undocumented. */
356 const char *constant_string_class_name;
359 /* C++ language option variables. */
362 /* Nonzero means don't recognize any extension keywords. */
364 int flag_no_gnu_keywords;
366 /* Nonzero means do emit exported implementations of functions even if
367 they can be inlined. */
369 int flag_implement_inlines = 1;
371 /* Nonzero means that implicit instantiations will be emitted if needed. */
373 int flag_implicit_templates = 1;
375 /* Nonzero means that implicit instantiations of inline templates will be
376 emitted if needed, even if instantiations of non-inline templates
379 int flag_implicit_inline_templates = 1;
381 /* Nonzero means generate separate instantiation control files and
382 juggle them at link time. */
384 int flag_use_repository;
386 /* Nonzero if we want to issue diagnostics that the standard says are not
389 int flag_optional_diags = 1;
391 /* Nonzero means we should attempt to elide constructors when possible. */
393 int flag_elide_constructors = 1;
395 /* Nonzero means that member functions defined in class scope are
396 inline by default. */
398 int flag_default_inline = 1;
400 /* Controls whether compiler generates 'type descriptor' that give
401 run-time type information. */
405 /* Nonzero if we want to conserve space in the .o files. We do this
406 by putting uninitialized data and runtime initialized data into
407 .common instead of .data at the expense of not flagging multiple
410 int flag_conserve_space;
412 /* Nonzero if we want to obey access control semantics. */
414 int flag_access_control = 1;
416 /* Nonzero if we want to check the return value of new and avoid calling
417 constructors if it is a null pointer. */
421 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
422 initialization variables.
423 0: Old rules, set by -fno-for-scope.
424 2: New ISO rules, set by -ffor-scope.
425 1: Try to implement new ISO rules, but with backup compatibility
426 (and warnings). This is the default, for now. */
428 int flag_new_for_scope = 1;
430 /* Nonzero if we want to emit defined symbols with common-like linkage as
431 weak symbols where possible, in order to conform to C++ semantics.
432 Otherwise, emit them as local symbols. */
436 /* 0 means we want the preprocessor to not emit line directives for
437 the current working directory. 1 means we want it to do it. -1
438 means we should decide depending on whether debugging information
439 is being emitted or not. */
441 int flag_working_directory = -1;
443 /* Nonzero to use __cxa_atexit, rather than atexit, to register
444 destructors for local statics and global objects. */
446 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
448 /* Nonzero means make the default pedwarns warnings instead of errors.
449 The value of this flag is ignored if -pedantic is specified. */
453 /* Nonzero means to implement standard semantics for exception
454 specifications, calling unexpected if an exception is thrown that
455 doesn't match the specification. Zero means to treat them as
456 assertions and optimize accordingly, but not check them. */
458 int flag_enforce_eh_specs = 1;
460 /* Nonzero means warn about implicit declarations. */
462 int warn_implicit = 1;
464 /* Maximum template instantiation depth. This limit is rather
465 arbitrary, but it exists to limit the time it takes to notice
466 infinite template instantiations. */
468 int max_tinst_depth = 500;
472 /* The elements of `ridpointers' are identifier nodes for the reserved
473 type names and storage classes. It is indexed by a RID_... value. */
476 tree (*make_fname_decl) (tree, int);
478 /* If non-NULL, the address of a language-specific function that
479 returns 1 for language-specific statement codes. */
480 int (*lang_statement_code_p) (enum tree_code);
482 /* If non-NULL, the address of a language-specific function that takes
483 any action required right before expand_function_end is called. */
484 void (*lang_expand_function_end) (void);
486 /* Nonzero means the expression being parsed will never be evaluated.
487 This is a count, since unevaluated expressions can nest. */
490 /* Information about how a function name is generated. */
493 tree *const decl; /* pointer to the VAR_DECL. */
494 const unsigned rid; /* RID number for the identifier. */
495 const int pretty; /* How pretty is it? */
498 /* The three ways of getting then name of the current function. */
500 const struct fname_var_t fname_vars[] =
502 /* C99 compliant __func__, must be first. */
503 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
504 /* GCC __FUNCTION__ compliant. */
505 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
506 /* GCC __PRETTY_FUNCTION__ compliant. */
507 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
511 static int constant_fits_type_p (tree, tree);
513 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
514 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
515 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
516 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
517 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
518 static tree handle_always_inline_attribute (tree *, tree, tree, int,
520 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
521 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
522 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
523 static tree handle_transparent_union_attribute (tree *, tree, tree,
525 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
528 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
531 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
532 static tree handle_visibility_attribute (tree *, tree, tree, int,
534 static tree handle_tls_model_attribute (tree *, tree, tree, int,
536 static tree handle_no_instrument_function_attribute (tree *, tree,
538 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
539 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
541 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_deprecated_attribute (tree *, tree, tree, int,
544 static tree handle_vector_size_attribute (tree *, tree, tree, int,
546 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
547 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
548 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
549 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
552 static void check_function_nonnull (tree, tree);
553 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
554 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
555 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
556 static int resort_field_decl_cmp (const void *, const void *);
558 /* Table of machine-independent attributes common to all C-like languages. */
559 const struct attribute_spec c_common_attribute_table[] =
561 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
562 { "packed", 0, 0, false, false, false,
563 handle_packed_attribute },
564 { "nocommon", 0, 0, true, false, false,
565 handle_nocommon_attribute },
566 { "common", 0, 0, true, false, false,
567 handle_common_attribute },
568 /* FIXME: logically, noreturn attributes should be listed as
569 "false, true, true" and apply to function types. But implementing this
570 would require all the places in the compiler that use TREE_THIS_VOLATILE
571 on a decl to identify non-returning functions to be located and fixed
572 to check the function type instead. */
573 { "noreturn", 0, 0, true, false, false,
574 handle_noreturn_attribute },
575 { "volatile", 0, 0, true, false, false,
576 handle_noreturn_attribute },
577 { "noinline", 0, 0, true, false, false,
578 handle_noinline_attribute },
579 { "always_inline", 0, 0, true, false, false,
580 handle_always_inline_attribute },
581 { "used", 0, 0, true, false, false,
582 handle_used_attribute },
583 { "unused", 0, 0, false, false, false,
584 handle_unused_attribute },
585 /* The same comments as for noreturn attributes apply to const ones. */
586 { "const", 0, 0, true, false, false,
587 handle_const_attribute },
588 { "transparent_union", 0, 0, false, false, false,
589 handle_transparent_union_attribute },
590 { "constructor", 0, 0, true, false, false,
591 handle_constructor_attribute },
592 { "destructor", 0, 0, true, false, false,
593 handle_destructor_attribute },
594 { "mode", 1, 1, false, true, false,
595 handle_mode_attribute },
596 { "section", 1, 1, true, false, false,
597 handle_section_attribute },
598 { "aligned", 0, 1, false, false, false,
599 handle_aligned_attribute },
600 { "weak", 0, 0, true, false, false,
601 handle_weak_attribute },
602 { "alias", 1, 1, true, false, false,
603 handle_alias_attribute },
604 { "no_instrument_function", 0, 0, true, false, false,
605 handle_no_instrument_function_attribute },
606 { "malloc", 0, 0, true, false, false,
607 handle_malloc_attribute },
608 { "no_stack_limit", 0, 0, true, false, false,
609 handle_no_limit_stack_attribute },
610 { "pure", 0, 0, true, false, false,
611 handle_pure_attribute },
612 { "deprecated", 0, 0, false, false, false,
613 handle_deprecated_attribute },
614 { "vector_size", 1, 1, false, true, false,
615 handle_vector_size_attribute },
616 { "visibility", 1, 1, true, false, false,
617 handle_visibility_attribute },
618 { "tls_model", 1, 1, true, false, false,
619 handle_tls_model_attribute },
620 { "nonnull", 0, -1, false, true, true,
621 handle_nonnull_attribute },
622 { "nothrow", 0, 0, true, false, false,
623 handle_nothrow_attribute },
624 { "may_alias", 0, 0, false, true, false, NULL },
625 { "cleanup", 1, 1, true, false, false,
626 handle_cleanup_attribute },
627 { "warn_unused_result", 0, 0, false, true, true,
628 handle_warn_unused_result_attribute },
629 { NULL, 0, 0, false, false, false, NULL }
632 /* Give the specifications for the format attributes, used by C and all
635 const struct attribute_spec c_common_format_attribute_table[] =
637 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
638 { "format", 3, 3, false, true, true,
639 handle_format_attribute },
640 { "format_arg", 1, 1, false, true, true,
641 handle_format_arg_attribute },
642 { NULL, 0, 0, false, false, false, NULL }
645 /* Push current bindings for the function name VAR_DECLS. */
648 start_fname_decls (void)
651 tree saved = NULL_TREE;
653 for (ix = 0; fname_vars[ix].decl; ix++)
655 tree decl = *fname_vars[ix].decl;
659 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
660 *fname_vars[ix].decl = NULL_TREE;
663 if (saved || saved_function_name_decls)
664 /* Normally they'll have been NULL, so only push if we've got a
665 stack, or they are non-NULL. */
666 saved_function_name_decls = tree_cons (saved, NULL_TREE,
667 saved_function_name_decls);
670 /* Finish up the current bindings, adding them into the current function's
671 statement tree. This must be done _before_ finish_stmt_tree is called.
672 If there is no current function, we must be at file scope and no statements
673 are involved. Pop the previous bindings. */
676 finish_fname_decls (void)
679 tree stmts = NULL_TREE;
680 tree stack = saved_function_name_decls;
682 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
683 append_to_statement_list (TREE_VALUE (stack), &stmts);
687 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
689 if (TREE_CODE (*bodyp) == BIND_EXPR)
690 bodyp = &BIND_EXPR_BODY (*bodyp);
692 append_to_statement_list (*bodyp, &stmts);
696 for (ix = 0; fname_vars[ix].decl; ix++)
697 *fname_vars[ix].decl = NULL_TREE;
701 /* We had saved values, restore them. */
704 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
706 tree decl = TREE_PURPOSE (saved);
707 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
709 *fname_vars[ix].decl = decl;
711 stack = TREE_CHAIN (stack);
713 saved_function_name_decls = stack;
716 /* Return the text name of the current function, suitably prettified
717 by PRETTY_P. Return string must be freed by caller. */
720 fname_as_string (int pretty_p)
722 const char *name = "top level";
732 if (current_function_decl)
733 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
735 if (c_lex_string_translate)
737 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
738 cpp_string cstr = { 0, 0 }, strname;
740 namep = xmalloc (len);
741 snprintf (namep, len, "\"%s\"", name);
742 strname.text = (unsigned char *) namep;
743 strname.len = len - 1;
745 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
746 return (char *) cstr.text;
749 namep = xstrdup (name);
754 /* Expand DECL if it declares an entity not handled by the
758 c_expand_decl (tree decl)
760 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
762 /* Let the back-end know about this variable. */
763 if (!anon_aggr_type_p (TREE_TYPE (decl)))
764 emit_local_var (decl);
766 expand_anon_union_decl (decl, NULL_TREE,
767 DECL_ANON_UNION_ELEMS (decl));
769 else if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
770 make_rtl_for_local_static (decl);
778 /* Return the VAR_DECL for a const char array naming the current
779 function. If the VAR_DECL has not yet been created, create it
780 now. RID indicates how it should be formatted and IDENTIFIER_NODE
781 ID is its name (unfortunately C and C++ hold the RID values of
782 keywords in different places, so we can't derive RID from ID in
783 this language independent code. */
786 fname_decl (unsigned int rid, tree id)
789 tree decl = NULL_TREE;
791 for (ix = 0; fname_vars[ix].decl; ix++)
792 if (fname_vars[ix].rid == rid)
795 decl = *fname_vars[ix].decl;
798 /* If a tree is built here, it would normally have the lineno of
799 the current statement. Later this tree will be moved to the
800 beginning of the function and this line number will be wrong.
801 To avoid this problem set the lineno to 0 here; that prevents
802 it from appearing in the RTL. */
804 location_t saved_locus = input_location;
807 stmts = push_stmt_list ();
808 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
809 stmts = pop_stmt_list (stmts);
810 if (!IS_EMPTY_STMT (stmts))
811 saved_function_name_decls
812 = tree_cons (decl, stmts, saved_function_name_decls);
813 *fname_vars[ix].decl = decl;
814 input_location = saved_locus;
816 if (!ix && !current_function_decl)
817 pedwarn ("%J'%D' is not defined outside of function scope", decl, decl);
822 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
825 fix_string_type (tree value)
827 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
828 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
829 const int nchars_max = flag_isoc99 ? 4095 : 509;
830 int length = TREE_STRING_LENGTH (value);
833 /* Compute the number of elements, for the array type. */
834 nchars = wide_flag ? length / wchar_bytes : length;
836 if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
837 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
838 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
840 /* Create the array type for the string constant.
841 -Wwrite-strings says make the string constant an array of const char
842 so that copying it to a non-const pointer will get a warning.
843 For C++, this is the standard behavior. */
844 if (flag_const_strings)
847 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
850 = build_array_type (elements,
851 build_index_type (build_int_2 (nchars - 1, 0)));
855 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
856 build_index_type (build_int_2 (nchars - 1, 0)));
858 TREE_CONSTANT (value) = 1;
859 TREE_INVARIANT (value) = 1;
860 TREE_READONLY (value) = 1;
861 TREE_STATIC (value) = 1;
865 /* Print a warning if a constant expression had overflow in folding.
866 Invoke this function on every expression that the language
867 requires to be a constant expression.
868 Note the ANSI C standard says it is erroneous for a
869 constant expression to overflow. */
872 constant_expression_warning (tree value)
874 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
875 || TREE_CODE (value) == VECTOR_CST
876 || TREE_CODE (value) == COMPLEX_CST)
877 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
878 pedwarn ("overflow in constant expression");
881 /* Print a warning if an expression had overflow in folding.
882 Invoke this function on every expression that
883 (1) appears in the source code, and
884 (2) might be a constant expression that overflowed, and
885 (3) is not already checked by convert_and_check;
886 however, do not invoke this function on operands of explicit casts. */
889 overflow_warning (tree value)
891 if ((TREE_CODE (value) == INTEGER_CST
892 || (TREE_CODE (value) == COMPLEX_CST
893 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
894 && TREE_OVERFLOW (value))
896 TREE_OVERFLOW (value) = 0;
897 if (skip_evaluation == 0)
898 warning ("integer overflow in expression");
900 else if ((TREE_CODE (value) == REAL_CST
901 || (TREE_CODE (value) == COMPLEX_CST
902 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
903 && TREE_OVERFLOW (value))
905 TREE_OVERFLOW (value) = 0;
906 if (skip_evaluation == 0)
907 warning ("floating point overflow in expression");
909 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
911 TREE_OVERFLOW (value) = 0;
912 if (skip_evaluation == 0)
913 warning ("vector overflow in expression");
917 /* Print a warning if a large constant is truncated to unsigned,
918 or if -Wconversion is used and a constant < 0 is converted to unsigned.
919 Invoke this function on every expression that might be implicitly
920 converted to an unsigned type. */
923 unsigned_conversion_warning (tree result, tree operand)
925 tree type = TREE_TYPE (result);
927 if (TREE_CODE (operand) == INTEGER_CST
928 && TREE_CODE (type) == INTEGER_TYPE
929 && TYPE_UNSIGNED (type)
930 && skip_evaluation == 0
931 && !int_fits_type_p (operand, type))
933 if (!int_fits_type_p (operand, c_common_signed_type (type)))
934 /* This detects cases like converting -129 or 256 to unsigned char. */
935 warning ("large integer implicitly truncated to unsigned type");
936 else if (warn_conversion)
937 warning ("negative integer implicitly converted to unsigned type");
941 /* Nonzero if constant C has a value that is permissible
942 for type TYPE (an INTEGER_TYPE). */
945 constant_fits_type_p (tree c, tree type)
947 if (TREE_CODE (c) == INTEGER_CST)
948 return int_fits_type_p (c, type);
950 c = convert (type, c);
951 return !TREE_OVERFLOW (c);
954 /* Nonzero if vector types T1 and T2 can be converted to each other
955 without an explicit cast. */
957 vector_types_convertible_p (tree t1, tree t2)
959 return targetm.vector_opaque_p (t1)
960 || targetm.vector_opaque_p (t2)
961 || TYPE_MODE (t1) == TYPE_MODE (t2);
964 /* Convert EXPR to TYPE, warning about conversion problems with constants.
965 Invoke this function on every expression that is converted implicitly,
966 i.e. because of language rules and not because of an explicit cast. */
969 convert_and_check (tree type, tree expr)
971 tree t = convert (type, expr);
972 if (TREE_CODE (t) == INTEGER_CST)
974 if (TREE_OVERFLOW (t))
976 TREE_OVERFLOW (t) = 0;
978 /* Do not diagnose overflow in a constant expression merely
979 because a conversion overflowed. */
980 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
982 /* No warning for converting 0x80000000 to int. */
983 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
984 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
985 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
986 /* If EXPR fits in the unsigned version of TYPE,
987 don't warn unless pedantic. */
989 || TYPE_UNSIGNED (type)
990 || ! constant_fits_type_p (expr,
991 c_common_unsigned_type (type)))
992 && skip_evaluation == 0)
993 warning ("overflow in implicit constant conversion");
996 unsigned_conversion_warning (t, expr);
1001 /* A node in a list that describes references to variables (EXPR), which are
1002 either read accesses if WRITER is zero, or write accesses, in which case
1003 WRITER is the parent of EXPR. */
1010 /* Used to implement a cache the results of a call to verify_tree. We only
1011 use this for SAVE_EXPRs. */
1014 struct tlist_cache *next;
1015 struct tlist *cache_before_sp;
1016 struct tlist *cache_after_sp;
1020 /* Obstack to use when allocating tlist structures, and corresponding
1022 static struct obstack tlist_obstack;
1023 static char *tlist_firstobj = 0;
1025 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1027 static struct tlist *warned_ids;
1028 /* SAVE_EXPRs need special treatment. We process them only once and then
1029 cache the results. */
1030 static struct tlist_cache *save_expr_cache;
1032 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1033 static void merge_tlist (struct tlist **, struct tlist *, int);
1034 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1035 static int warning_candidate_p (tree);
1036 static void warn_for_collisions (struct tlist *);
1037 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1038 static struct tlist *new_tlist (struct tlist *, tree, tree);
1040 /* Create a new struct tlist and fill in its fields. */
1041 static struct tlist *
1042 new_tlist (struct tlist *next, tree t, tree writer)
1045 l = obstack_alloc (&tlist_obstack, sizeof *l);
1052 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1053 is nonnull, we ignore any node we find which has a writer equal to it. */
1056 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1060 struct tlist *next = add->next;
1063 if (! exclude_writer || add->writer != exclude_writer)
1064 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1069 /* Merge the nodes of ADD into TO. This merging process is done so that for
1070 each variable that already exists in TO, no new node is added; however if
1071 there is a write access recorded in ADD, and an occurrence on TO is only
1072 a read access, then the occurrence in TO will be modified to record the
1076 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1078 struct tlist **end = to;
1081 end = &(*end)->next;
1087 struct tlist *next = add->next;
1089 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1090 if (tmp2->expr == add->expr)
1094 tmp2->writer = add->writer;
1098 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1099 end = &(*end)->next;
1106 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1107 references in list LIST conflict with it, excluding reads if ONLY writers
1111 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1116 /* Avoid duplicate warnings. */
1117 for (tmp = warned_ids; tmp; tmp = tmp->next)
1118 if (tmp->expr == written)
1123 if (list->expr == written
1124 && list->writer != writer
1125 && (! only_writes || list->writer))
1127 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1128 warning ("operation on `%s' may be undefined",
1129 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1135 /* Given a list LIST of references to variables, find whether any of these
1136 can cause conflicts due to missing sequence points. */
1139 warn_for_collisions (struct tlist *list)
1143 for (tmp = list; tmp; tmp = tmp->next)
1146 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1150 /* Return nonzero if X is a tree that can be verified by the sequence point
1153 warning_candidate_p (tree x)
1155 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1158 /* Walk the tree X, and record accesses to variables. If X is written by the
1159 parent tree, WRITER is the parent.
1160 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1161 expression or its only operand forces a sequence point, then everything up
1162 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1164 Once we return, we will have emitted warnings if any subexpression before
1165 such a sequence point could be undefined. On a higher level, however, the
1166 sequence point may not be relevant, and we'll merge the two lists.
1168 Example: (b++, a) + b;
1169 The call that processes the COMPOUND_EXPR will store the increment of B
1170 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1171 processes the PLUS_EXPR will need to merge the two lists so that
1172 eventually, all accesses end up on the same list (and we'll warn about the
1173 unordered subexpressions b++ and b.
1175 A note on merging. If we modify the former example so that our expression
1178 care must be taken not simply to add all three expressions into the final
1179 PNO_SP list. The function merge_tlist takes care of that by merging the
1180 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1181 way, so that no more than one access to B is recorded. */
1184 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1187 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1188 enum tree_code code;
1191 /* X may be NULL if it is the operand of an empty statement expression
1197 code = TREE_CODE (x);
1198 class = TREE_CODE_CLASS (code);
1200 if (warning_candidate_p (x))
1202 *pno_sp = new_tlist (*pno_sp, x, writer);
1212 case TRUTH_ANDIF_EXPR:
1213 case TRUTH_ORIF_EXPR:
1214 tmp_before = tmp_nosp = tmp_list3 = 0;
1215 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1216 warn_for_collisions (tmp_nosp);
1217 merge_tlist (pbefore_sp, tmp_before, 0);
1218 merge_tlist (pbefore_sp, tmp_nosp, 0);
1219 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1220 merge_tlist (pbefore_sp, tmp_list3, 0);
1224 tmp_before = tmp_list2 = 0;
1225 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1226 warn_for_collisions (tmp_list2);
1227 merge_tlist (pbefore_sp, tmp_before, 0);
1228 merge_tlist (pbefore_sp, tmp_list2, 1);
1230 tmp_list3 = tmp_nosp = 0;
1231 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1232 warn_for_collisions (tmp_nosp);
1233 merge_tlist (pbefore_sp, tmp_list3, 0);
1235 tmp_list3 = tmp_list2 = 0;
1236 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1237 warn_for_collisions (tmp_list2);
1238 merge_tlist (pbefore_sp, tmp_list3, 0);
1239 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1240 two first, to avoid warning for (a ? b++ : b++). */
1241 merge_tlist (&tmp_nosp, tmp_list2, 0);
1242 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1245 case PREDECREMENT_EXPR:
1246 case PREINCREMENT_EXPR:
1247 case POSTDECREMENT_EXPR:
1248 case POSTINCREMENT_EXPR:
1249 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1253 tmp_before = tmp_nosp = tmp_list3 = 0;
1254 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1255 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1256 /* Expressions inside the LHS are not ordered wrt. the sequence points
1257 in the RHS. Example:
1259 Despite the fact that the modification of "a" is in the before_sp
1260 list (tmp_before), it conflicts with the use of "a" in the LHS.
1261 We can handle this by adding the contents of tmp_list3
1262 to those of tmp_before, and redoing the collision warnings for that
1264 add_tlist (&tmp_before, tmp_list3, x, 1);
1265 warn_for_collisions (tmp_before);
1266 /* Exclude the LHS itself here; we first have to merge it into the
1267 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1268 didn't exclude the LHS, we'd get it twice, once as a read and once
1270 add_tlist (pno_sp, tmp_list3, x, 0);
1271 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1273 merge_tlist (pbefore_sp, tmp_before, 0);
1274 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1275 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1276 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1280 /* We need to warn about conflicts among arguments and conflicts between
1281 args and the function address. Side effects of the function address,
1282 however, are not ordered by the sequence point of the call. */
1283 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1284 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1285 if (TREE_OPERAND (x, 1))
1286 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1287 merge_tlist (&tmp_list3, tmp_list2, 0);
1288 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1289 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1290 warn_for_collisions (tmp_before);
1291 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1295 /* Scan all the list, e.g. indices of multi dimensional array. */
1298 tmp_before = tmp_nosp = 0;
1299 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1300 merge_tlist (&tmp_nosp, tmp_before, 0);
1301 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1308 struct tlist_cache *t;
1309 for (t = save_expr_cache; t; t = t->next)
1315 t = obstack_alloc (&tlist_obstack, sizeof *t);
1316 t->next = save_expr_cache;
1318 save_expr_cache = t;
1320 tmp_before = tmp_nosp = 0;
1321 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1322 warn_for_collisions (tmp_nosp);
1327 struct tlist *t = tmp_nosp;
1329 merge_tlist (&tmp_list3, t, 0);
1331 t->cache_before_sp = tmp_before;
1332 t->cache_after_sp = tmp_list3;
1334 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1335 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1344 if (first_rtl_op (code) == 0)
1346 x = TREE_OPERAND (x, 0);
1361 int max = first_rtl_op (TREE_CODE (x));
1362 for (lp = 0; lp < max; lp++)
1364 tmp_before = tmp_nosp = 0;
1365 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1366 merge_tlist (&tmp_nosp, tmp_before, 0);
1367 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1374 /* Try to warn for undefined behavior in EXPR due to missing sequence
1378 verify_sequence_points (tree expr)
1380 struct tlist *before_sp = 0, *after_sp = 0;
1383 save_expr_cache = 0;
1384 if (tlist_firstobj == 0)
1386 gcc_obstack_init (&tlist_obstack);
1387 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1390 verify_tree (expr, &before_sp, &after_sp, 0);
1391 warn_for_collisions (after_sp);
1392 obstack_free (&tlist_obstack, tlist_firstobj);
1395 /* Validate the expression after `case' and apply default promotions. */
1398 check_case_value (tree value)
1400 if (value == NULL_TREE)
1403 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1404 STRIP_TYPE_NOPS (value);
1405 /* In C++, the following is allowed:
1408 switch (...) { case i: ... }
1410 So, we try to reduce the VALUE to a constant that way. */
1411 if (c_dialect_cxx ())
1413 value = decl_constant_value (value);
1414 STRIP_TYPE_NOPS (value);
1415 value = fold (value);
1418 if (TREE_CODE (value) != INTEGER_CST
1419 && value != error_mark_node)
1421 error ("case label does not reduce to an integer constant");
1422 value = error_mark_node;
1425 /* Promote char or short to int. */
1426 value = default_conversion (value);
1428 constant_expression_warning (value);
1433 /* Return an integer type with BITS bits of precision,
1434 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1437 c_common_type_for_size (unsigned int bits, int unsignedp)
1439 if (bits == TYPE_PRECISION (integer_type_node))
1440 return unsignedp ? unsigned_type_node : integer_type_node;
1442 if (bits == TYPE_PRECISION (signed_char_type_node))
1443 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1445 if (bits == TYPE_PRECISION (short_integer_type_node))
1446 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1448 if (bits == TYPE_PRECISION (long_integer_type_node))
1449 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1451 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1452 return (unsignedp ? long_long_unsigned_type_node
1453 : long_long_integer_type_node);
1455 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1456 return (unsignedp ? widest_unsigned_literal_type_node
1457 : widest_integer_literal_type_node);
1459 if (bits <= TYPE_PRECISION (intQI_type_node))
1460 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1462 if (bits <= TYPE_PRECISION (intHI_type_node))
1463 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1465 if (bits <= TYPE_PRECISION (intSI_type_node))
1466 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1468 if (bits <= TYPE_PRECISION (intDI_type_node))
1469 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1474 /* Used for communication between c_common_type_for_mode and
1475 c_register_builtin_type. */
1476 static GTY(()) tree registered_builtin_types;
1478 /* Return a data type that has machine mode MODE.
1479 If the mode is an integer,
1480 then UNSIGNEDP selects between signed and unsigned types. */
1483 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1487 if (mode == TYPE_MODE (integer_type_node))
1488 return unsignedp ? unsigned_type_node : integer_type_node;
1490 if (mode == TYPE_MODE (signed_char_type_node))
1491 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1493 if (mode == TYPE_MODE (short_integer_type_node))
1494 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1496 if (mode == TYPE_MODE (long_integer_type_node))
1497 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1499 if (mode == TYPE_MODE (long_long_integer_type_node))
1500 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1502 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1503 return unsignedp ? widest_unsigned_literal_type_node
1504 : widest_integer_literal_type_node;
1507 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1510 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1513 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1516 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1518 #if HOST_BITS_PER_WIDE_INT >= 64
1519 if (mode == TYPE_MODE (intTI_type_node))
1520 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1523 if (mode == TYPE_MODE (float_type_node))
1524 return float_type_node;
1526 if (mode == TYPE_MODE (double_type_node))
1527 return double_type_node;
1529 if (mode == TYPE_MODE (long_double_type_node))
1530 return long_double_type_node;
1532 if (mode == TYPE_MODE (void_type_node))
1533 return void_type_node;
1535 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1536 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1538 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1539 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1541 if (VECTOR_MODE_P (mode))
1543 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1544 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1545 if (inner_type != NULL_TREE)
1546 return build_vector_type_for_mode (inner_type, mode);
1549 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1550 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1551 return TREE_VALUE (t);
1556 /* Return an unsigned type the same as TYPE in other respects. */
1558 c_common_unsigned_type (tree type)
1560 tree type1 = TYPE_MAIN_VARIANT (type);
1561 if (type1 == signed_char_type_node || type1 == char_type_node)
1562 return unsigned_char_type_node;
1563 if (type1 == integer_type_node)
1564 return unsigned_type_node;
1565 if (type1 == short_integer_type_node)
1566 return short_unsigned_type_node;
1567 if (type1 == long_integer_type_node)
1568 return long_unsigned_type_node;
1569 if (type1 == long_long_integer_type_node)
1570 return long_long_unsigned_type_node;
1571 if (type1 == widest_integer_literal_type_node)
1572 return widest_unsigned_literal_type_node;
1573 #if HOST_BITS_PER_WIDE_INT >= 64
1574 if (type1 == intTI_type_node)
1575 return unsigned_intTI_type_node;
1577 if (type1 == intDI_type_node)
1578 return unsigned_intDI_type_node;
1579 if (type1 == intSI_type_node)
1580 return unsigned_intSI_type_node;
1581 if (type1 == intHI_type_node)
1582 return unsigned_intHI_type_node;
1583 if (type1 == intQI_type_node)
1584 return unsigned_intQI_type_node;
1586 return c_common_signed_or_unsigned_type (1, type);
1589 /* Return a signed type the same as TYPE in other respects. */
1592 c_common_signed_type (tree type)
1594 tree type1 = TYPE_MAIN_VARIANT (type);
1595 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1596 return signed_char_type_node;
1597 if (type1 == unsigned_type_node)
1598 return integer_type_node;
1599 if (type1 == short_unsigned_type_node)
1600 return short_integer_type_node;
1601 if (type1 == long_unsigned_type_node)
1602 return long_integer_type_node;
1603 if (type1 == long_long_unsigned_type_node)
1604 return long_long_integer_type_node;
1605 if (type1 == widest_unsigned_literal_type_node)
1606 return widest_integer_literal_type_node;
1607 #if HOST_BITS_PER_WIDE_INT >= 64
1608 if (type1 == unsigned_intTI_type_node)
1609 return intTI_type_node;
1611 if (type1 == unsigned_intDI_type_node)
1612 return intDI_type_node;
1613 if (type1 == unsigned_intSI_type_node)
1614 return intSI_type_node;
1615 if (type1 == unsigned_intHI_type_node)
1616 return intHI_type_node;
1617 if (type1 == unsigned_intQI_type_node)
1618 return intQI_type_node;
1620 return c_common_signed_or_unsigned_type (0, type);
1623 /* Return a type the same as TYPE except unsigned or
1624 signed according to UNSIGNEDP. */
1627 c_common_signed_or_unsigned_type (int unsignedp, tree type)
1629 if (! INTEGRAL_TYPE_P (type)
1630 || TYPE_UNSIGNED (type) == unsignedp)
1633 /* Must check the mode of the types, not the precision. Enumeral types
1634 in C++ have precision set to match their range, but may use a wider
1635 mode to match an ABI. If we change modes, we may wind up with bad
1638 if (TYPE_MODE (type) == TYPE_MODE (signed_char_type_node))
1639 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1640 if (TYPE_MODE (type) == TYPE_MODE (integer_type_node))
1641 return unsignedp ? unsigned_type_node : integer_type_node;
1642 if (TYPE_MODE (type) == TYPE_MODE (short_integer_type_node))
1643 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1644 if (TYPE_MODE (type) == TYPE_MODE (long_integer_type_node))
1645 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1646 if (TYPE_MODE (type) == TYPE_MODE (long_long_integer_type_node))
1647 return (unsignedp ? long_long_unsigned_type_node
1648 : long_long_integer_type_node);
1649 if (TYPE_MODE (type) == TYPE_MODE (widest_integer_literal_type_node))
1650 return (unsignedp ? widest_unsigned_literal_type_node
1651 : widest_integer_literal_type_node);
1653 #if HOST_BITS_PER_WIDE_INT >= 64
1654 if (TYPE_MODE (type) == TYPE_MODE (intTI_type_node))
1655 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1657 if (TYPE_MODE (type) == TYPE_MODE (intDI_type_node))
1658 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1659 if (TYPE_MODE (type) == TYPE_MODE (intSI_type_node))
1660 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1661 if (TYPE_MODE (type) == TYPE_MODE (intHI_type_node))
1662 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1663 if (TYPE_MODE (type) == TYPE_MODE (intQI_type_node))
1664 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1669 /* The C version of the register_builtin_type langhook. */
1672 c_register_builtin_type (tree type, const char* name)
1676 decl = build_decl (TYPE_DECL, get_identifier (name), type);
1677 DECL_ARTIFICIAL (decl) = 1;
1678 if (!TYPE_NAME (type))
1679 TYPE_NAME (type) = decl;
1682 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1686 /* Return the minimum number of bits needed to represent VALUE in a
1687 signed or unsigned type, UNSIGNEDP says which. */
1690 min_precision (tree value, int unsignedp)
1694 /* If the value is negative, compute its negative minus 1. The latter
1695 adjustment is because the absolute value of the largest negative value
1696 is one larger than the largest positive value. This is equivalent to
1697 a bit-wise negation, so use that operation instead. */
1699 if (tree_int_cst_sgn (value) < 0)
1700 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1702 /* Return the number of bits needed, taking into account the fact
1703 that we need one more bit for a signed than unsigned type. */
1705 if (integer_zerop (value))
1708 log = tree_floor_log2 (value);
1710 return log + 1 + ! unsignedp;
1713 /* Print an error message for invalid operands to arith operation
1714 CODE. NOP_EXPR is used as a special case (see
1715 c_common_truthvalue_conversion). */
1718 binary_op_error (enum tree_code code)
1725 error ("invalid truth-value expression");
1729 opname = "+"; break;
1731 opname = "-"; break;
1733 opname = "*"; break;
1735 opname = "max"; break;
1737 opname = "min"; break;
1739 opname = "=="; break;
1741 opname = "!="; break;
1743 opname = "<="; break;
1745 opname = ">="; break;
1747 opname = "<"; break;
1749 opname = ">"; break;
1751 opname = "<<"; break;
1753 opname = ">>"; break;
1754 case TRUNC_MOD_EXPR:
1755 case FLOOR_MOD_EXPR:
1756 opname = "%"; break;
1757 case TRUNC_DIV_EXPR:
1758 case FLOOR_DIV_EXPR:
1759 opname = "/"; break;
1761 opname = "&"; break;
1763 opname = "|"; break;
1764 case TRUTH_ANDIF_EXPR:
1765 opname = "&&"; break;
1766 case TRUTH_ORIF_EXPR:
1767 opname = "||"; break;
1769 opname = "^"; break;
1772 opname = "rotate"; break;
1774 opname = "unknown"; break;
1776 error ("invalid operands to binary %s", opname);
1779 /* Subroutine of build_binary_op, used for comparison operations.
1780 See if the operands have both been converted from subword integer types
1781 and, if so, perhaps change them both back to their original type.
1782 This function is also responsible for converting the two operands
1783 to the proper common type for comparison.
1785 The arguments of this function are all pointers to local variables
1786 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1787 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1789 If this function returns nonzero, it means that the comparison has
1790 a constant value. What this function returns is an expression for
1794 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
1795 enum tree_code *rescode_ptr)
1798 tree op0 = *op0_ptr;
1799 tree op1 = *op1_ptr;
1800 int unsignedp0, unsignedp1;
1802 tree primop0, primop1;
1803 enum tree_code code = *rescode_ptr;
1805 /* Throw away any conversions to wider types
1806 already present in the operands. */
1808 primop0 = get_narrower (op0, &unsignedp0);
1809 primop1 = get_narrower (op1, &unsignedp1);
1811 /* Handle the case that OP0 does not *contain* a conversion
1812 but it *requires* conversion to FINAL_TYPE. */
1814 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1815 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1816 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1817 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1819 /* If one of the operands must be floated, we cannot optimize. */
1820 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1821 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1823 /* If first arg is constant, swap the args (changing operation
1824 so value is preserved), for canonicalization. Don't do this if
1825 the second arg is 0. */
1827 if (TREE_CONSTANT (primop0)
1828 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1831 int temi = unsignedp0;
1839 unsignedp0 = unsignedp1;
1862 *rescode_ptr = code;
1865 /* If comparing an integer against a constant more bits wide,
1866 maybe we can deduce a value of 1 or 0 independent of the data.
1867 Or else truncate the constant now
1868 rather than extend the variable at run time.
1870 This is only interesting if the constant is the wider arg.
1871 Also, it is not safe if the constant is unsigned and the
1872 variable arg is signed, since in this case the variable
1873 would be sign-extended and then regarded as unsigned.
1874 Our technique fails in this case because the lowest/highest
1875 possible unsigned results don't follow naturally from the
1876 lowest/highest possible values of the variable operand.
1877 For just EQ_EXPR and NE_EXPR there is another technique that
1878 could be used: see if the constant can be faithfully represented
1879 in the other operand's type, by truncating it and reextending it
1880 and see if that preserves the constant's value. */
1882 if (!real1 && !real2
1883 && TREE_CODE (primop1) == INTEGER_CST
1884 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1886 int min_gt, max_gt, min_lt, max_lt;
1887 tree maxval, minval;
1888 /* 1 if comparison is nominally unsigned. */
1889 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
1892 type = c_common_signed_or_unsigned_type (unsignedp0,
1893 TREE_TYPE (primop0));
1895 /* In C, if TYPE is an enumeration, then we need to get its
1896 min/max values from its underlying integral type, not the
1897 enumerated type itself. In C++, TYPE_MAX_VALUE and
1898 TYPE_MIN_VALUE have already been set correctly on the
1899 enumeration type. */
1900 if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
1901 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
1903 maxval = TYPE_MAX_VALUE (type);
1904 minval = TYPE_MIN_VALUE (type);
1906 if (unsignedp && !unsignedp0)
1907 *restype_ptr = c_common_signed_type (*restype_ptr);
1909 if (TREE_TYPE (primop1) != *restype_ptr)
1910 primop1 = convert (*restype_ptr, primop1);
1911 if (type != *restype_ptr)
1913 minval = convert (*restype_ptr, minval);
1914 maxval = convert (*restype_ptr, maxval);
1917 if (unsignedp && unsignedp0)
1919 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1920 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1921 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1922 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1926 min_gt = INT_CST_LT (primop1, minval);
1927 max_gt = INT_CST_LT (primop1, maxval);
1928 min_lt = INT_CST_LT (minval, primop1);
1929 max_lt = INT_CST_LT (maxval, primop1);
1933 /* This used to be a switch, but Genix compiler can't handle that. */
1934 if (code == NE_EXPR)
1936 if (max_lt || min_gt)
1937 val = truthvalue_true_node;
1939 else if (code == EQ_EXPR)
1941 if (max_lt || min_gt)
1942 val = truthvalue_false_node;
1944 else if (code == LT_EXPR)
1947 val = truthvalue_true_node;
1949 val = truthvalue_false_node;
1951 else if (code == GT_EXPR)
1954 val = truthvalue_true_node;
1956 val = truthvalue_false_node;
1958 else if (code == LE_EXPR)
1961 val = truthvalue_true_node;
1963 val = truthvalue_false_node;
1965 else if (code == GE_EXPR)
1968 val = truthvalue_true_node;
1970 val = truthvalue_false_node;
1973 /* If primop0 was sign-extended and unsigned comparison specd,
1974 we did a signed comparison above using the signed type bounds.
1975 But the comparison we output must be unsigned.
1977 Also, for inequalities, VAL is no good; but if the signed
1978 comparison had *any* fixed result, it follows that the
1979 unsigned comparison just tests the sign in reverse
1980 (positive values are LE, negative ones GE).
1981 So we can generate an unsigned comparison
1982 against an extreme value of the signed type. */
1984 if (unsignedp && !unsignedp0)
1991 primop1 = TYPE_MIN_VALUE (type);
1997 primop1 = TYPE_MAX_VALUE (type);
2004 type = c_common_unsigned_type (type);
2007 if (TREE_CODE (primop0) != INTEGER_CST)
2009 if (val == truthvalue_false_node)
2010 warning ("comparison is always false due to limited range of data type");
2011 if (val == truthvalue_true_node)
2012 warning ("comparison is always true due to limited range of data type");
2017 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2018 if (TREE_SIDE_EFFECTS (primop0))
2019 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2023 /* Value is not predetermined, but do the comparison
2024 in the type of the operand that is not constant.
2025 TYPE is already properly set. */
2027 else if (real1 && real2
2028 && (TYPE_PRECISION (TREE_TYPE (primop0))
2029 == TYPE_PRECISION (TREE_TYPE (primop1))))
2030 type = TREE_TYPE (primop0);
2032 /* If args' natural types are both narrower than nominal type
2033 and both extend in the same manner, compare them
2034 in the type of the wider arg.
2035 Otherwise must actually extend both to the nominal
2036 common type lest different ways of extending
2038 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2040 else if (unsignedp0 == unsignedp1 && real1 == real2
2041 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2042 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2044 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2045 type = c_common_signed_or_unsigned_type (unsignedp0
2046 || TYPE_UNSIGNED (*restype_ptr),
2048 /* Make sure shorter operand is extended the right way
2049 to match the longer operand. */
2051 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2052 TREE_TYPE (primop0)),
2055 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2056 TREE_TYPE (primop1)),
2061 /* Here we must do the comparison on the nominal type
2062 using the args exactly as we received them. */
2063 type = *restype_ptr;
2067 if (!real1 && !real2 && integer_zerop (primop1)
2068 && TYPE_UNSIGNED (*restype_ptr))
2074 /* All unsigned values are >= 0, so we warn if extra warnings
2075 are requested. However, if OP0 is a constant that is
2076 >= 0, the signedness of the comparison isn't an issue,
2077 so suppress the warning. */
2078 if (extra_warnings && !in_system_header
2079 && ! (TREE_CODE (primop0) == INTEGER_CST
2080 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2082 warning ("comparison of unsigned expression >= 0 is always true");
2083 value = truthvalue_true_node;
2087 if (extra_warnings && !in_system_header
2088 && ! (TREE_CODE (primop0) == INTEGER_CST
2089 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2091 warning ("comparison of unsigned expression < 0 is always false");
2092 value = truthvalue_false_node;
2101 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2102 if (TREE_SIDE_EFFECTS (primop0))
2103 return build (COMPOUND_EXPR, TREE_TYPE (value),
2110 *op0_ptr = convert (type, primop0);
2111 *op1_ptr = convert (type, primop1);
2113 *restype_ptr = truthvalue_type_node;
2118 /* Return a tree for the sum or difference (RESULTCODE says which)
2119 of pointer PTROP and integer INTOP. */
2122 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2126 /* The result is a pointer of the same type that is being added. */
2128 tree result_type = TREE_TYPE (ptrop);
2130 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2132 if (pedantic || warn_pointer_arith)
2133 pedwarn ("pointer of type `void *' used in arithmetic");
2134 size_exp = integer_one_node;
2136 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2138 if (pedantic || warn_pointer_arith)
2139 pedwarn ("pointer to a function used in arithmetic");
2140 size_exp = integer_one_node;
2142 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2144 if (pedantic || warn_pointer_arith)
2145 pedwarn ("pointer to member function used in arithmetic");
2146 size_exp = integer_one_node;
2149 size_exp = size_in_bytes (TREE_TYPE (result_type));
2151 /* If what we are about to multiply by the size of the elements
2152 contains a constant term, apply distributive law
2153 and multiply that constant term separately.
2154 This helps produce common subexpressions. */
2156 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2157 && ! TREE_CONSTANT (intop)
2158 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2159 && TREE_CONSTANT (size_exp)
2160 /* If the constant comes from pointer subtraction,
2161 skip this optimization--it would cause an error. */
2162 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2163 /* If the constant is unsigned, and smaller than the pointer size,
2164 then we must skip this optimization. This is because it could cause
2165 an overflow error if the constant is negative but INTOP is not. */
2166 && (! TYPE_UNSIGNED (TREE_TYPE (intop))
2167 || (TYPE_PRECISION (TREE_TYPE (intop))
2168 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2170 enum tree_code subcode = resultcode;
2171 tree int_type = TREE_TYPE (intop);
2172 if (TREE_CODE (intop) == MINUS_EXPR)
2173 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2174 /* Convert both subexpression types to the type of intop,
2175 because weird cases involving pointer arithmetic
2176 can result in a sum or difference with different type args. */
2177 ptrop = build_binary_op (subcode, ptrop,
2178 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2179 intop = convert (int_type, TREE_OPERAND (intop, 0));
2182 /* Convert the integer argument to a type the same size as sizetype
2183 so the multiply won't overflow spuriously. */
2185 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2186 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2187 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2188 TYPE_UNSIGNED (sizetype)), intop);
2190 /* Replace the integer argument with a suitable product by the object size.
2191 Do this multiplication as signed, then convert to the appropriate
2192 pointer type (actually unsigned integral). */
2194 intop = convert (result_type,
2195 build_binary_op (MULT_EXPR, intop,
2196 convert (TREE_TYPE (intop), size_exp), 1));
2198 /* Create the sum or difference. */
2199 return fold (build (resultcode, result_type, ptrop, intop));
2202 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2203 or validate its data type for an `if' or `while' statement or ?..: exp.
2205 This preparation consists of taking the ordinary
2206 representation of an expression expr and producing a valid tree
2207 boolean expression describing whether expr is nonzero. We could
2208 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2209 but we optimize comparisons, &&, ||, and !.
2211 The resulting type should always be `truthvalue_type_node'. */
2214 c_common_truthvalue_conversion (tree expr)
2216 if (TREE_CODE (expr) == ERROR_MARK)
2219 if (TREE_CODE (expr) == FUNCTION_DECL)
2220 expr = build_unary_op (ADDR_EXPR, expr, 0);
2222 switch (TREE_CODE (expr))
2224 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2225 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2226 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2227 case ORDERED_EXPR: case UNORDERED_EXPR:
2228 case TRUTH_ANDIF_EXPR:
2229 case TRUTH_ORIF_EXPR:
2230 case TRUTH_AND_EXPR:
2232 case TRUTH_XOR_EXPR:
2233 case TRUTH_NOT_EXPR:
2234 TREE_TYPE (expr) = truthvalue_type_node;
2241 return integer_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2244 return real_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2248 if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2249 && ! DECL_WEAK (TREE_OPERAND (expr, 0)))
2251 /* Common Ada/Pascal programmer's mistake. We always warn
2252 about this since it is so bad. */
2253 warning ("the address of `%D', will always evaluate as `true'",
2254 TREE_OPERAND (expr, 0));
2255 return truthvalue_true_node;
2258 /* If we are taking the address of an external decl, it might be
2259 zero if it is weak, so we cannot optimize. */
2260 if (DECL_P (TREE_OPERAND (expr, 0))
2261 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2264 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2265 return build (COMPOUND_EXPR, truthvalue_type_node,
2266 TREE_OPERAND (expr, 0), truthvalue_true_node);
2268 return truthvalue_true_node;
2272 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2273 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2274 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)),
2275 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2281 /* These don't change whether an object is nonzero or zero. */
2282 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2286 /* These don't change whether an object is zero or nonzero, but
2287 we can't ignore them if their second arg has side-effects. */
2288 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2289 return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1),
2290 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)));
2292 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2295 /* Distribute the conversion into the arms of a COND_EXPR. */
2296 return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0),
2297 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2298 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 2))));
2301 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2302 since that affects how `default_conversion' will behave. */
2303 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2304 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2306 /* Fall through.... */
2308 /* If this is widening the argument, we can ignore it. */
2309 if (TYPE_PRECISION (TREE_TYPE (expr))
2310 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2311 return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2315 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2316 aren't guaranteed to the be same for modes that can represent
2317 infinity, since if x and y are both +infinity, or both
2318 -infinity, then x - y is not a number.
2320 Note that this transformation is safe when x or y is NaN.
2321 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2323 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2325 /* Fall through.... */
2327 /* This and MINUS_EXPR can be changed into a comparison of the
2329 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2330 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2331 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2332 TREE_OPERAND (expr, 1), 1);
2333 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2334 fold (build1 (NOP_EXPR,
2335 TREE_TYPE (TREE_OPERAND (expr, 0)),
2336 TREE_OPERAND (expr, 1))), 1);
2339 if (integer_onep (TREE_OPERAND (expr, 1))
2340 && TREE_TYPE (expr) != truthvalue_type_node)
2341 /* Using convert here would cause infinite recursion. */
2342 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2346 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2347 warning ("suggest parentheses around assignment used as truth value");
2354 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2356 tree t = save_expr (expr);
2357 return (build_binary_op
2358 ((TREE_SIDE_EFFECTS (expr)
2359 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2360 lang_hooks.truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2361 lang_hooks.truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2365 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2368 static tree builtin_function_2 (const char *, const char *, tree, tree,
2369 int, enum built_in_class, int, int,
2372 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2373 down to the element type of an array. */
2376 c_build_qualified_type (tree type, int type_quals)
2378 if (type == error_mark_node)
2381 if (TREE_CODE (type) == ARRAY_TYPE)
2382 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2384 TYPE_DOMAIN (type));
2386 /* A restrict-qualified pointer type must be a pointer to object or
2387 incomplete type. Note that the use of POINTER_TYPE_P also allows
2388 REFERENCE_TYPEs, which is appropriate for C++. */
2389 if ((type_quals & TYPE_QUAL_RESTRICT)
2390 && (!POINTER_TYPE_P (type)
2391 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2393 error ("invalid use of `restrict'");
2394 type_quals &= ~TYPE_QUAL_RESTRICT;
2397 return build_qualified_type (type, type_quals);
2400 /* Apply the TYPE_QUALS to the new DECL. */
2403 c_apply_type_quals_to_decl (int type_quals, tree decl)
2405 tree type = TREE_TYPE (decl);
2407 if (type == error_mark_node)
2410 if (((type_quals & TYPE_QUAL_CONST)
2411 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2412 /* An object declared 'const' is only readonly after it is
2413 initialized. We don't have any way of expressing this currently,
2414 so we need to be conservative and unset TREE_READONLY for types
2415 with constructors. Otherwise aliasing code will ignore stores in
2416 an inline constructor. */
2417 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2418 TREE_READONLY (decl) = 1;
2419 if (type_quals & TYPE_QUAL_VOLATILE)
2421 TREE_SIDE_EFFECTS (decl) = 1;
2422 TREE_THIS_VOLATILE (decl) = 1;
2424 if (type_quals & TYPE_QUAL_RESTRICT)
2426 while (type && TREE_CODE (type) == ARRAY_TYPE)
2427 /* Allow 'restrict' on arrays of pointers.
2428 FIXME currently we just ignore it. */
2429 type = TREE_TYPE (type);
2431 || !POINTER_TYPE_P (type)
2432 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2433 error ("invalid use of `restrict'");
2434 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2435 /* Indicate we need to make a unique alias set for this pointer.
2436 We can't do it here because it might be pointing to an
2438 DECL_POINTER_ALIAS_SET (decl) = -2;
2442 /* Hash function for the problem of multiple type definitions in
2443 different files. This must hash all types that will compare
2444 equal via comptypes to the same value. In practice it hashes
2445 on some of the simple stuff and leaves the details to comptypes. */
2448 c_type_hash (const void *p)
2454 switch (TREE_CODE (t))
2456 /* For pointers, hash on pointee type plus some swizzling. */
2458 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2459 /* Hash on number of elements and total size. */
2462 t2 = TYPE_VALUES (t);
2466 t2 = TYPE_FIELDS (t);
2468 case QUAL_UNION_TYPE:
2470 t2 = TYPE_FIELDS (t);
2474 t2 = TYPE_FIELDS (t);
2479 for (; t2; t2 = TREE_CHAIN (t2))
2481 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2482 return ((size << 24) | (i << shift));
2485 /* Return the typed-based alias set for T, which may be an expression
2486 or a type. Return -1 if we don't do anything special. */
2489 c_common_get_alias_set (tree t)
2493 static htab_t type_hash_table;
2495 /* Permit type-punning when accessing a union, provided the access
2496 is directly through the union. For example, this code does not
2497 permit taking the address of a union member and then storing
2498 through it. Even the type-punning allowed here is a GCC
2499 extension, albeit a common and useful one; the C standard says
2500 that such accesses have implementation-defined behavior. */
2502 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2503 u = TREE_OPERAND (u, 0))
2504 if (TREE_CODE (u) == COMPONENT_REF
2505 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2508 /* That's all the expressions we handle specially. */
2512 /* The C standard guarantees that any object may be accessed via an
2513 lvalue that has character type. */
2514 if (t == char_type_node
2515 || t == signed_char_type_node
2516 || t == unsigned_char_type_node)
2519 /* If it has the may_alias attribute, it can alias anything. */
2520 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2523 /* The C standard specifically allows aliasing between signed and
2524 unsigned variants of the same type. We treat the signed
2525 variant as canonical. */
2526 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2528 tree t1 = c_common_signed_type (t);
2530 /* t1 == t can happen for boolean nodes which are always unsigned. */
2532 return get_alias_set (t1);
2534 else if (POINTER_TYPE_P (t))
2538 /* Unfortunately, there is no canonical form of a pointer type.
2539 In particular, if we have `typedef int I', then `int *', and
2540 `I *' are different types. So, we have to pick a canonical
2541 representative. We do this below.
2543 Technically, this approach is actually more conservative that
2544 it needs to be. In particular, `const int *' and `int *'
2545 should be in different alias sets, according to the C and C++
2546 standard, since their types are not the same, and so,
2547 technically, an `int **' and `const int **' cannot point at
2550 But, the standard is wrong. In particular, this code is
2555 const int* const* cipp = ipp;
2557 And, it doesn't make sense for that to be legal unless you
2558 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2559 the pointed-to types. This issue has been reported to the
2561 t1 = build_type_no_quals (t);
2563 return get_alias_set (t1);
2566 /* Handle the case of multiple type nodes referring to "the same" type,
2567 which occurs with IMA. These share an alias set. FIXME: Currently only
2568 C90 is handled. (In C99 type compatibility is not transitive, which
2569 complicates things mightily. The alias set splay trees can theoretically
2570 represent this, but insertion is tricky when you consider all the
2571 different orders things might arrive in.) */
2573 if (c_language != clk_c || flag_isoc99)
2576 /* Save time if there's only one input file. */
2577 if (!current_file_decl || TREE_CHAIN (current_file_decl) == NULL_TREE)
2580 /* Pointers need special handling if they point to any type that
2581 needs special handling (below). */
2582 if (TREE_CODE (t) == POINTER_TYPE)
2585 /* Find bottom type under any nested POINTERs. */
2586 for (t2 = TREE_TYPE (t);
2587 TREE_CODE (t2) == POINTER_TYPE;
2588 t2 = TREE_TYPE (t2))
2590 if (TREE_CODE (t2) != RECORD_TYPE
2591 && TREE_CODE (t2) != ENUMERAL_TYPE
2592 && TREE_CODE (t2) != QUAL_UNION_TYPE
2593 && TREE_CODE (t2) != UNION_TYPE)
2595 if (TYPE_SIZE (t2) == 0)
2598 /* These are the only cases that need special handling. */
2599 if (TREE_CODE (t) != RECORD_TYPE
2600 && TREE_CODE (t) != ENUMERAL_TYPE
2601 && TREE_CODE (t) != QUAL_UNION_TYPE
2602 && TREE_CODE (t) != UNION_TYPE
2603 && TREE_CODE (t) != POINTER_TYPE)
2606 if (TYPE_SIZE (t) == 0)
2609 /* Look up t in hash table. Only one of the compatible types within each
2610 alias set is recorded in the table. */
2611 if (!type_hash_table)
2612 type_hash_table = htab_create (1021, c_type_hash,
2613 (htab_eq) lang_hooks.types_compatible_p,
2615 slot = htab_find_slot (type_hash_table, t, INSERT);
2617 return TYPE_ALIAS_SET ((tree)*slot);
2619 /* Our caller will assign and record (in t) a new alias set; all we need
2620 to do is remember t in the hash table. */
2626 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2627 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2628 flag controls whether we should diagnose possibly ill-formed
2629 constructs or not. */
2631 c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2633 const char *op_name;
2635 enum tree_code type_code = TREE_CODE (type);
2637 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
2638 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2640 if (type_code == FUNCTION_TYPE)
2642 if (op == SIZEOF_EXPR)
2644 if (complain && (pedantic || warn_pointer_arith))
2645 pedwarn ("invalid application of `sizeof' to a function type");
2646 value = size_one_node;
2649 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2651 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2653 if (type_code == VOID_TYPE
2654 && complain && (pedantic || warn_pointer_arith))
2655 pedwarn ("invalid application of `%s' to a void type", op_name);
2656 value = size_one_node;
2658 else if (!COMPLETE_TYPE_P (type))
2661 error ("invalid application of `%s' to incomplete type `%T' ",
2663 value = size_zero_node;
2667 if (op == SIZEOF_EXPR)
2668 /* Convert in case a char is more than one unit. */
2669 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2670 size_int (TYPE_PRECISION (char_type_node)
2673 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2676 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2677 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2678 never happen. However, this node should really have type
2679 `size_t', which is just a typedef for an ordinary integer type. */
2680 value = fold (build1 (NOP_EXPR, size_type_node, value));
2681 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
2686 /* Implement the __alignof keyword: Return the minimum required
2687 alignment of EXPR, measured in bytes. For VAR_DECL's and
2688 FIELD_DECL's return DECL_ALIGN (which can be set from an
2689 "aligned" __attribute__ specification). */
2692 c_alignof_expr (tree expr)
2696 if (TREE_CODE (expr) == VAR_DECL)
2697 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2699 else if (TREE_CODE (expr) == COMPONENT_REF
2700 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2702 error ("`__alignof' applied to a bit-field");
2705 else if (TREE_CODE (expr) == COMPONENT_REF
2706 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2707 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2709 else if (TREE_CODE (expr) == INDIRECT_REF)
2711 tree t = TREE_OPERAND (expr, 0);
2713 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2715 while (TREE_CODE (t) == NOP_EXPR
2716 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2720 t = TREE_OPERAND (t, 0);
2721 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2722 if (thisalign > bestalign)
2723 best = t, bestalign = thisalign;
2725 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2728 return c_alignof (TREE_TYPE (expr));
2730 return fold (build1 (NOP_EXPR, size_type_node, t));
2733 /* Handle C and C++ default attributes. */
2735 enum built_in_attribute
2737 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2738 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2739 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2740 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2741 #include "builtin-attrs.def"
2742 #undef DEF_ATTR_NULL_TREE
2744 #undef DEF_ATTR_IDENT
2745 #undef DEF_ATTR_TREE_LIST
2749 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
2751 static void c_init_attributes (void);
2753 /* Build tree nodes and builtin functions common to both C and C++ language
2757 c_common_nodes_and_builtins (void)
2761 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2762 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2763 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2764 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2765 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2766 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2767 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2768 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2769 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2770 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2771 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2772 #include "builtin-types.def"
2773 #undef DEF_PRIMITIVE_TYPE
2774 #undef DEF_FUNCTION_TYPE_0
2775 #undef DEF_FUNCTION_TYPE_1
2776 #undef DEF_FUNCTION_TYPE_2
2777 #undef DEF_FUNCTION_TYPE_3
2778 #undef DEF_FUNCTION_TYPE_4
2779 #undef DEF_FUNCTION_TYPE_VAR_0
2780 #undef DEF_FUNCTION_TYPE_VAR_1
2781 #undef DEF_FUNCTION_TYPE_VAR_2
2782 #undef DEF_FUNCTION_TYPE_VAR_3
2783 #undef DEF_POINTER_TYPE
2787 typedef enum builtin_type builtin_type;
2789 tree builtin_types[(int) BT_LAST];
2790 int wchar_type_size;
2791 tree array_domain_type;
2792 tree va_list_ref_type_node;
2793 tree va_list_arg_type_node;
2795 /* Define `int' and `char' first so that dbx will output them first. */
2796 record_builtin_type (RID_INT, NULL, integer_type_node);
2797 record_builtin_type (RID_CHAR, "char", char_type_node);
2799 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2800 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2801 but not C. Are the conditionals here needed? */
2802 if (c_dialect_cxx ())
2803 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2804 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2805 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2806 record_builtin_type (RID_MAX, "long unsigned int",
2807 long_unsigned_type_node);
2808 if (c_dialect_cxx ())
2809 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2810 record_builtin_type (RID_MAX, "long long int",
2811 long_long_integer_type_node);
2812 record_builtin_type (RID_MAX, "long long unsigned int",
2813 long_long_unsigned_type_node);
2814 if (c_dialect_cxx ())
2815 record_builtin_type (RID_MAX, "long long unsigned",
2816 long_long_unsigned_type_node);
2817 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2818 record_builtin_type (RID_MAX, "short unsigned int",
2819 short_unsigned_type_node);
2820 if (c_dialect_cxx ())
2821 record_builtin_type (RID_MAX, "unsigned short",
2822 short_unsigned_type_node);
2824 /* Define both `signed char' and `unsigned char'. */
2825 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2826 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2828 /* These are types that c_common_type_for_size and
2829 c_common_type_for_mode use. */
2830 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2832 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2834 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2836 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2838 #if HOST_BITS_PER_WIDE_INT >= 64
2839 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2840 get_identifier ("__int128_t"),
2843 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2844 unsigned_intQI_type_node));
2845 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2846 unsigned_intHI_type_node));
2847 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2848 unsigned_intSI_type_node));
2849 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2850 unsigned_intDI_type_node));
2851 #if HOST_BITS_PER_WIDE_INT >= 64
2852 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2853 get_identifier ("__uint128_t"),
2854 unsigned_intTI_type_node));
2857 /* Create the widest literal types. */
2858 widest_integer_literal_type_node
2859 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2860 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2861 widest_integer_literal_type_node));
2863 widest_unsigned_literal_type_node
2864 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2865 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2866 widest_unsigned_literal_type_node));
2868 /* `unsigned long' is the standard type for sizeof.
2869 Note that stddef.h uses `unsigned long',
2870 and this must agree, even if long and int are the same size. */
2872 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2873 signed_size_type_node = c_common_signed_type (size_type_node);
2874 set_sizetype (size_type_node);
2877 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
2879 build_common_tree_nodes_2 (flag_short_double);
2881 record_builtin_type (RID_FLOAT, NULL, float_type_node);
2882 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2883 record_builtin_type (RID_MAX, "long double", long_double_type_node);
2885 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2886 get_identifier ("complex int"),
2887 complex_integer_type_node));
2888 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2889 get_identifier ("complex float"),
2890 complex_float_type_node));
2891 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2892 get_identifier ("complex double"),
2893 complex_double_type_node));
2894 lang_hooks.decls.pushdecl
2895 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2896 complex_long_double_type_node));
2898 if (c_dialect_cxx ())
2899 /* For C++, make fileptr_type_node a distinct void * type until
2900 FILE type is defined. */
2901 fileptr_type_node = build_type_copy (ptr_type_node);
2903 record_builtin_type (RID_VOID, NULL, void_type_node);
2905 void_zero_node = build_int_2 (0, 0);
2906 TREE_TYPE (void_zero_node) = void_type_node;
2908 void_list_node = build_void_list_node ();
2910 /* Make a type to be the domain of a few array types
2911 whose domains don't really matter.
2912 200 is small enough that it always fits in size_t
2913 and large enough that it can hold most function names for the
2914 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2915 array_domain_type = build_index_type (size_int (200));
2917 /* Make a type for arrays of characters.
2918 With luck nothing will ever really depend on the length of this
2920 char_array_type_node
2921 = build_array_type (char_type_node, array_domain_type);
2923 /* Likewise for arrays of ints. */
2925 = build_array_type (integer_type_node, array_domain_type);
2927 string_type_node = build_pointer_type (char_type_node);
2928 const_string_type_node
2929 = build_pointer_type (build_qualified_type
2930 (char_type_node, TYPE_QUAL_CONST));
2932 /* This is special for C++ so functions can be overloaded. */
2933 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
2934 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2935 wchar_type_size = TYPE_PRECISION (wchar_type_node);
2936 if (c_dialect_cxx ())
2938 if (TYPE_UNSIGNED (wchar_type_node))
2939 wchar_type_node = make_unsigned_type (wchar_type_size);
2941 wchar_type_node = make_signed_type (wchar_type_size);
2942 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2946 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
2947 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
2950 /* This is for wide string constants. */
2951 wchar_array_type_node
2952 = build_array_type (wchar_type_node, array_domain_type);
2955 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2958 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2960 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2962 default_function_type = build_function_type (integer_type_node, NULL_TREE);
2964 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2965 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
2967 lang_hooks.decls.pushdecl
2968 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2969 va_list_type_node));
2971 lang_hooks.decls.pushdecl
2972 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2973 ptrdiff_type_node));
2975 lang_hooks.decls.pushdecl
2976 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2979 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2981 va_list_arg_type_node = va_list_ref_type_node =
2982 build_pointer_type (TREE_TYPE (va_list_type_node));
2986 va_list_arg_type_node = va_list_type_node;
2987 va_list_ref_type_node = build_reference_type (va_list_type_node);
2990 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2991 builtin_types[(int) ENUM] = VALUE;
2992 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2993 builtin_types[(int) ENUM] \
2994 = build_function_type (builtin_types[(int) RETURN], \
2996 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2997 builtin_types[(int) ENUM] \
2998 = build_function_type (builtin_types[(int) RETURN], \
2999 tree_cons (NULL_TREE, \
3000 builtin_types[(int) ARG1], \
3002 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3003 builtin_types[(int) ENUM] \
3004 = build_function_type \
3005 (builtin_types[(int) RETURN], \
3006 tree_cons (NULL_TREE, \
3007 builtin_types[(int) ARG1], \
3008 tree_cons (NULL_TREE, \
3009 builtin_types[(int) ARG2], \
3011 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3012 builtin_types[(int) ENUM] \
3013 = build_function_type \
3014 (builtin_types[(int) RETURN], \
3015 tree_cons (NULL_TREE, \
3016 builtin_types[(int) ARG1], \
3017 tree_cons (NULL_TREE, \
3018 builtin_types[(int) ARG2], \
3019 tree_cons (NULL_TREE, \
3020 builtin_types[(int) ARG3], \
3022 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3023 builtin_types[(int) ENUM] \
3024 = build_function_type \
3025 (builtin_types[(int) RETURN], \
3026 tree_cons (NULL_TREE, \
3027 builtin_types[(int) ARG1], \
3028 tree_cons (NULL_TREE, \
3029 builtin_types[(int) ARG2], \
3032 builtin_types[(int) ARG3], \
3033 tree_cons (NULL_TREE, \
3034 builtin_types[(int) ARG4], \
3035 void_list_node)))));
3036 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3037 builtin_types[(int) ENUM] \
3038 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3039 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3040 builtin_types[(int) ENUM] \
3041 = build_function_type (builtin_types[(int) RETURN], \
3042 tree_cons (NULL_TREE, \
3043 builtin_types[(int) ARG1], \
3046 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3047 builtin_types[(int) ENUM] \
3048 = build_function_type \
3049 (builtin_types[(int) RETURN], \
3050 tree_cons (NULL_TREE, \
3051 builtin_types[(int) ARG1], \
3052 tree_cons (NULL_TREE, \
3053 builtin_types[(int) ARG2], \
3056 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3057 builtin_types[(int) ENUM] \
3058 = build_function_type \
3059 (builtin_types[(int) RETURN], \
3060 tree_cons (NULL_TREE, \
3061 builtin_types[(int) ARG1], \
3062 tree_cons (NULL_TREE, \
3063 builtin_types[(int) ARG2], \
3064 tree_cons (NULL_TREE, \
3065 builtin_types[(int) ARG3], \
3068 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3069 builtin_types[(int) ENUM] \
3070 = build_pointer_type (builtin_types[(int) TYPE]);
3071 #include "builtin-types.def"
3072 #undef DEF_PRIMITIVE_TYPE
3073 #undef DEF_FUNCTION_TYPE_1
3074 #undef DEF_FUNCTION_TYPE_2
3075 #undef DEF_FUNCTION_TYPE_3
3076 #undef DEF_FUNCTION_TYPE_4
3077 #undef DEF_FUNCTION_TYPE_VAR_0
3078 #undef DEF_FUNCTION_TYPE_VAR_1
3079 #undef DEF_FUNCTION_TYPE_VAR_2
3080 #undef DEF_FUNCTION_TYPE_VAR_3
3081 #undef DEF_POINTER_TYPE
3083 c_init_attributes ();
3085 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3086 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3091 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3095 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3098 ? (NAME + strlen ("__builtin_")) \
3100 built_in_attributes[(int) ATTRS]); \
3102 decl = builtin_function_2 (NAME, \
3103 NAME + strlen ("__builtin_"), \
3104 builtin_types[TYPE], \
3105 builtin_types[LIBTYPE], \
3110 built_in_attributes[(int) ATTRS]); \
3112 built_in_decls[(int) ENUM] = decl; \
3114 implicit_built_in_decls[(int) ENUM] = decl; \
3116 #include "builtins.def"
3119 targetm.init_builtins ();
3121 main_identifier_node = get_identifier ("main");
3125 build_va_arg (tree expr, tree type)
3127 return build1 (VA_ARG_EXPR, type, expr);
3131 /* Linked list of disabled built-in functions. */
3133 typedef struct disabled_builtin
3136 struct disabled_builtin *next;
3138 static disabled_builtin *disabled_builtins = NULL;
3140 static bool builtin_function_disabled_p (const char *);
3142 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3143 begins with "__builtin_", give an error. */
3146 disable_builtin_function (const char *name)
3148 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3149 error ("cannot disable built-in function `%s'", name);
3152 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3154 new->next = disabled_builtins;
3155 disabled_builtins = new;
3160 /* Return true if the built-in function NAME has been disabled, false
3164 builtin_function_disabled_p (const char *name)
3166 disabled_builtin *p;
3167 for (p = disabled_builtins; p != NULL; p = p->next)
3169 if (strcmp (name, p->name) == 0)
3176 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3177 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3178 of these may be NULL (though both being NULL is useless).
3179 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3180 TYPE is the type of the function with the ordinary name. These
3181 may differ if the ordinary name is declared with a looser type to avoid
3182 conflicts with headers. FUNCTION_CODE and CLASS are as for
3183 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3184 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3185 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3186 ATTRS is the tree list representing the builtin's function attributes.
3187 Returns the declaration of BUILTIN_NAME, if any, otherwise
3188 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3189 or if NONANSI_P and flag_no_nonansi_builtin. */
3192 builtin_function_2 (const char *builtin_name, const char *name,
3193 tree builtin_type, tree type, int function_code,
3194 enum built_in_class class, int library_name_p,
3195 int nonansi_p, tree attrs)
3197 tree bdecl = NULL_TREE;
3198 tree decl = NULL_TREE;
3200 if (builtin_name != 0)
3201 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3202 class, library_name_p ? name : NULL, attrs);
3204 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3205 && !(nonansi_p && flag_no_nonansi_builtin))
3206 decl = builtin_function (name, type, function_code, class, NULL, attrs);
3208 return (bdecl != 0 ? bdecl : decl);
3211 /* Nonzero if the type T promotes to int. This is (nearly) the
3212 integral promotions defined in ISO C99 6.3.1.1/2. */
3215 c_promoting_integer_type_p (tree t)
3217 switch (TREE_CODE (t))
3220 return (TYPE_MAIN_VARIANT (t) == char_type_node
3221 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3222 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3223 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3224 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3225 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3228 /* ??? Technically all enumerations not larger than an int
3229 promote to an int. But this is used along code paths
3230 that only want to notice a size change. */
3231 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3241 /* Return 1 if PARMS specifies a fixed number of parameters
3242 and none of their types is affected by default promotions. */
3245 self_promoting_args_p (tree parms)
3248 for (t = parms; t; t = TREE_CHAIN (t))
3250 tree type = TREE_VALUE (t);
3252 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3258 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3261 if (c_promoting_integer_type_p (type))
3267 /* Recursively examines the array elements of TYPE, until a non-array
3268 element type is found. */
3271 strip_array_types (tree type)
3273 while (TREE_CODE (type) == ARRAY_TYPE)
3274 type = TREE_TYPE (type);
3279 /* Recursively remove any '*' or '&' operator from TYPE. */
3281 strip_pointer_operator (tree t)
3283 while (POINTER_TYPE_P (t))
3288 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3289 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3290 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3291 value, the traversal is aborted, and the value returned by FUNC is
3292 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3293 the node being visited are not walked.
3295 We don't need a without_duplicates variant of this one because the
3296 statement tree is a tree, not a graph. */
3299 walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
3301 enum tree_code code;
3306 #define WALK_SUBTREE(NODE) \
3309 result = walk_stmt_tree (&(NODE), func, data); \
3315 /* Skip empty subtrees. */
3319 /* Skip subtrees below non-statement nodes. */
3320 if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
3323 /* Call the function. */
3325 result = (*func) (tp, &walk_subtrees, data);
3327 /* If we found something, return it. */
3331 /* FUNC may have modified the tree, recheck that we're looking at a
3333 code = TREE_CODE (*tp);
3334 if (!STATEMENT_CODE_P (code))
3337 /* Visit the subtrees unless FUNC decided that there was nothing
3338 interesting below this point in the tree. */
3341 /* Walk over all the sub-trees of this operand. Statement nodes
3342 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3343 len = TREE_CODE_LENGTH (code);
3345 /* Go through the subtrees. We need to do this in forward order so
3346 that the scope of a FOR_EXPR is handled properly. */
3347 for (i = 0; i < len; ++i)
3348 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3351 /* Finally visit the chain. This can be tail-recursion optimized if
3352 we write it this way. */
3353 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3358 /* Used to compare case labels. K1 and K2 are actually tree nodes
3359 representing case labels, or NULL_TREE for a `default' label.
3360 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3361 K2, and 0 if K1 and K2 are equal. */
3364 case_compare (splay_tree_key k1, splay_tree_key k2)
3366 /* Consider a NULL key (such as arises with a `default' label) to be
3367 smaller than anything else. */
3373 return tree_int_cst_compare ((tree) k1, (tree) k2);
3376 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3377 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3378 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3379 case label was declared using the usual C/C++ syntax, rather than
3380 the GNU case range extension. CASES is a tree containing all the
3381 case ranges processed so far; COND is the condition for the
3382 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3383 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3386 c_add_case_label (splay_tree cases, tree cond, tree low_value,
3392 splay_tree_node node;
3394 /* Create the LABEL_DECL itself. */
3395 label = create_artificial_label ();
3397 /* If there was an error processing the switch condition, bail now
3398 before we get more confused. */
3399 if (!cond || cond == error_mark_node)
3402 if ((low_value && TREE_TYPE (low_value)
3403 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3404 || (high_value && TREE_TYPE (high_value)
3405 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3406 error ("pointers are not permitted as case values");
3408 /* Case ranges are a GNU extension. */
3409 if (high_value && pedantic)
3410 pedwarn ("range expressions in switch statements are non-standard");
3412 type = TREE_TYPE (cond);
3415 low_value = check_case_value (low_value);
3416 low_value = convert_and_check (type, low_value);
3420 high_value = check_case_value (high_value);
3421 high_value = convert_and_check (type, high_value);
3424 /* If an error has occurred, bail out now. */
3425 if (low_value == error_mark_node || high_value == error_mark_node)
3428 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3429 really a case range, even though it was written that way. Remove
3430 the HIGH_VALUE to simplify later processing. */
3431 if (tree_int_cst_equal (low_value, high_value))
3432 high_value = NULL_TREE;
3433 if (low_value && high_value
3434 && !tree_int_cst_lt (low_value, high_value))
3435 warning ("empty range specified");
3437 /* Look up the LOW_VALUE in the table of case labels we already
3439 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3440 /* If there was not an exact match, check for overlapping ranges.
3441 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3442 that's a `default' label and the only overlap is an exact match. */
3443 if (!node && (low_value || high_value))
3445 splay_tree_node low_bound;
3446 splay_tree_node high_bound;
3448 /* Even though there wasn't an exact match, there might be an
3449 overlap between this case range and another case range.
3450 Since we've (inductively) not allowed any overlapping case
3451 ranges, we simply need to find the greatest low case label
3452 that is smaller that LOW_VALUE, and the smallest low case
3453 label that is greater than LOW_VALUE. If there is an overlap
3454 it will occur in one of these two ranges. */
3455 low_bound = splay_tree_predecessor (cases,
3456 (splay_tree_key) low_value);
3457 high_bound = splay_tree_successor (cases,
3458 (splay_tree_key) low_value);
3460 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3461 the LOW_VALUE, so there is no need to check unless the
3462 LOW_BOUND is in fact itself a case range. */
3464 && CASE_HIGH ((tree) low_bound->value)
3465 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3468 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3469 range is bigger than the low end of the current range, so we
3470 are only interested if the current range is a real range, and
3471 not an ordinary case label. */
3474 && (tree_int_cst_compare ((tree) high_bound->key,
3479 /* If there was an overlap, issue an error. */
3482 tree duplicate = CASE_LABEL ((tree) node->value);
3486 error ("duplicate (or overlapping) case value");
3487 error ("%Jthis is the first entry overlapping that value", duplicate);
3491 error ("duplicate case value") ;
3492 error ("%Jpreviously used here", duplicate);
3496 error ("multiple default labels in one switch");
3497 error ("%Jthis is the first default label", duplicate);
3502 /* Add a CASE_LABEL to the statement-tree. */
3503 case_label = add_stmt (build_case_label (low_value, high_value, label));
3504 /* Register this case label in the splay tree. */
3505 splay_tree_insert (cases,
3506 (splay_tree_key) low_value,
3507 (splay_tree_value) case_label);
3512 /* Add a label so that the back-end doesn't think that the beginning of
3513 the switch is unreachable. Note that we do not add a case label, as
3514 that just leads to duplicates and thence to aborts later on. */
3517 tree t = create_artificial_label ();
3518 add_stmt (build_stmt (LABEL_EXPR, t));
3520 return error_mark_node;
3523 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3524 Used to verify that case values match up with enumerator values. */
3527 match_case_to_enum_1 (tree key, tree type, tree label)
3529 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3531 /* ??? Not working too hard to print the double-word value.
3532 Should perhaps be done with %lwd in the diagnostic routines? */
3533 if (TREE_INT_CST_HIGH (key) == 0)
3534 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3535 TREE_INT_CST_LOW (key));
3536 else if (!TYPE_UNSIGNED (type)
3537 && TREE_INT_CST_HIGH (key) == -1
3538 && TREE_INT_CST_LOW (key) != 0)
3539 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3540 -TREE_INT_CST_LOW (key));
3542 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3543 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3545 if (TYPE_NAME (type) == 0)
3546 warning ("%Jcase value `%s' not in enumerated type",
3547 CASE_LABEL (label), buf);
3549 warning ("%Jcase value `%s' not in enumerated type `%T'",
3550 CASE_LABEL (label), buf, type);
3554 match_case_to_enum (splay_tree_node node, void *data)
3556 tree label = (tree) node->value;
3559 /* Skip default case. */
3560 if (!CASE_LOW (label))
3563 /* If TREE_ADDRESSABLE is not set, that means CASE_LOW did not appear
3564 when we did our enum->case scan. Reset our scratch bit after. */
3565 if (!TREE_ADDRESSABLE (label))
3566 match_case_to_enum_1 (CASE_LOW (label), type, label);
3568 TREE_ADDRESSABLE (label) = 0;
3570 /* If CASE_HIGH is non-null, we have a range. Here we must search.
3571 Note that the old code in stmt.c did not check for the values in
3572 the range either, just the endpoints. */
3573 if (CASE_HIGH (label))
3575 tree chain, key = CASE_HIGH (label);
3577 for (chain = TYPE_VALUES (type);
3578 chain && !tree_int_cst_equal (key, TREE_VALUE (chain));
3579 chain = TREE_CHAIN (chain))
3582 match_case_to_enum_1 (key, type, label);
3588 /* Handle -Wswitch*. Called from the front end after parsing the switch
3590 /* ??? Should probably be somewhere generic, since other languages besides
3591 C and C++ would want this. We'd want to agree on the datastructure,
3592 however, which is a problem. Alternately, we operate on gimplified
3593 switch_exprs, which I don't especially like. At the moment, however,
3594 C/C++ are the only tree-ssa languages that support enumerations at all,
3595 so the point is moot. */
3598 c_do_switch_warnings (splay_tree cases, tree switch_stmt)
3600 splay_tree_node default_node;
3601 location_t *switch_locus;
3604 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3607 switch_locus = EXPR_LOCUS (switch_stmt);
3609 switch_locus = &input_location;
3610 type = SWITCH_TYPE (switch_stmt);
3612 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3613 if (warn_switch_default && !default_node)
3614 warning ("%Hswitch missing default case", switch_locus);
3616 /* If the switch expression was an enumerated type, check that
3617 exactly all enumeration literals are covered by the cases.
3618 The check is made when -Wswitch was specified and there is no
3619 default case, or when -Wswitch-enum was specified. */
3620 if (((warn_switch && !default_node) || warn_switch_enum)
3621 && type && TREE_CODE (type) == ENUMERAL_TYPE
3622 && TREE_CODE (SWITCH_COND (switch_stmt)) != INTEGER_CST)
3626 /* The time complexity here is O(N*lg(N)) worst case, but for the
3627 common case of monotonically increasing enumerators, it is
3628 O(N), since the nature of the splay tree will keep the next
3629 element adjacent to the root at all times. */
3631 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3633 splay_tree_node node
3634 = splay_tree_lookup (cases, (splay_tree_key) TREE_VALUE (chain));
3638 /* Mark the CASE_LOW part of the case entry as seen, so
3639 that we save time later. Choose TREE_ADDRESSABLE
3640 randomly as a bit that won't have been set to-date. */
3641 tree label = (tree) node->value;
3642 TREE_ADDRESSABLE (label) = 1;
3646 /* Warn if there are enumerators that don't correspond to
3647 case expressions. */
3648 warning ("%Henumeration value `%E' not handled in switch",
3649 switch_locus, TREE_PURPOSE (chain));
3653 /* Warn if there are case expressions that don't correspond to
3654 enumerators. This can occur since C and C++ don't enforce
3655 type-checking of assignments to enumeration variables.
3657 The time complexity here is O(N**2) worst case, since we've
3658 not sorted the enumeration values. However, in the absence
3659 of case ranges this is O(N), since all single cases that
3660 corresponded to enumerations have been marked above. */
3662 splay_tree_foreach (cases, match_case_to_enum, type);
3666 /* Finish an expression taking the address of LABEL (an
3667 IDENTIFIER_NODE). Returns an expression for the address. */
3670 finish_label_address_expr (tree label)
3675 pedwarn ("taking the address of a label is non-standard");
3677 if (label == error_mark_node)
3678 return error_mark_node;
3680 label = lookup_label (label);
3681 if (label == NULL_TREE)
3682 result = null_pointer_node;
3685 TREE_USED (label) = 1;
3686 result = build1 (ADDR_EXPR, ptr_type_node, label);
3687 /* The current function in not necessarily uninlinable.
3688 Computed gotos are incompatible with inlining, but the value
3689 here could be used only in a diagnostic, for example. */
3695 /* Hook used by expand_expr to expand language-specific tree codes. */
3696 /* The only things that should go here are bits needed to expand
3697 constant initializers. Everything else should be handled by the
3698 gimplification routines. */
3701 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
3702 int modifier /* Actually enum_modifier. */,
3705 switch (TREE_CODE (exp))
3707 case COMPOUND_LITERAL_EXPR:
3709 /* Initialize the anonymous variable declared in the compound
3710 literal, then return the variable. */
3711 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3712 emit_local_var (decl);
3713 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
3721 /* Hook used by safe_from_p to handle language-specific tree codes. */
3724 c_safe_from_p (rtx target, tree exp)
3726 /* We can see statements here when processing the body of a
3727 statement-expression. For a declaration statement declaring a
3728 variable, look at the variable's initializer. */
3729 if (TREE_CODE (exp) == DECL_STMT)
3731 tree decl = DECL_STMT_DECL (exp);
3733 if (TREE_CODE (decl) == VAR_DECL
3734 && DECL_INITIAL (decl)
3735 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3739 /* Assume everything else is safe. */
3743 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3746 c_common_unsafe_for_reeval (tree exp)
3748 /* Statement expressions may not be reevaluated, likewise compound
3750 if (TREE_CODE (exp) == STMT_EXPR
3751 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
3754 /* Walk all other expressions. */
3758 /* Hook used by staticp to handle language-specific tree codes. */
3761 c_staticp (tree exp)
3763 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3764 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
3770 /* Given a boolean expression ARG, return a tree representing an increment
3771 or decrement (as indicated by CODE) of ARG. The front end must check for
3772 invalid cases (e.g., decrement in C++). */
3774 boolean_increment (enum tree_code code, tree arg)
3777 tree true_res = boolean_true_node;
3779 arg = stabilize_reference (arg);
3782 case PREINCREMENT_EXPR:
3783 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3785 case POSTINCREMENT_EXPR:
3786 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3787 arg = save_expr (arg);
3788 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3789 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3791 case PREDECREMENT_EXPR:
3792 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3794 case POSTDECREMENT_EXPR:
3795 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3796 arg = save_expr (arg);
3797 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3798 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3803 TREE_SIDE_EFFECTS (val) = 1;
3807 /* Built-in macros for stddef.h, that require macros defined in this
3810 c_stddef_cpp_builtins(void)
3812 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
3813 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
3814 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
3815 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
3819 c_init_attributes (void)
3821 /* Fill in the built_in_attributes array. */
3822 #define DEF_ATTR_NULL_TREE(ENUM) \
3823 built_in_attributes[(int) ENUM] = NULL_TREE;
3824 #define DEF_ATTR_INT(ENUM, VALUE) \
3825 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
3826 #define DEF_ATTR_IDENT(ENUM, STRING) \
3827 built_in_attributes[(int) ENUM] = get_identifier (STRING);
3828 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
3829 built_in_attributes[(int) ENUM] \
3830 = tree_cons (built_in_attributes[(int) PURPOSE], \
3831 built_in_attributes[(int) VALUE], \
3832 built_in_attributes[(int) CHAIN]);
3833 #include "builtin-attrs.def"
3834 #undef DEF_ATTR_NULL_TREE
3836 #undef DEF_ATTR_IDENT
3837 #undef DEF_ATTR_TREE_LIST
3840 /* Attribute handlers common to C front ends. */
3842 /* Handle a "packed" attribute; arguments as in
3843 struct attribute_spec.handler. */
3846 handle_packed_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
3847 int flags, bool *no_add_attrs)
3851 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
3852 *node = build_type_copy (*node);
3853 TYPE_PACKED (*node) = 1;
3854 if (TYPE_MAIN_VARIANT (*node) == *node)
3856 /* If it is the main variant, then pack the other variants
3857 too. This happens in,
3860 struct Foo const *ptr; // creates a variant w/o packed flag
3861 } __ attribute__((packed)); // packs it now.
3865 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
3866 TYPE_PACKED (probe) = 1;
3870 else if (TREE_CODE (*node) == FIELD_DECL)
3871 DECL_PACKED (*node) = 1;
3872 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
3873 used for DECL_REGISTER. It wouldn't mean anything anyway.
3874 We can't set DECL_PACKED on the type of a TYPE_DECL, because
3875 that changes what the typedef is typing. */
3878 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3879 *no_add_attrs = true;
3885 /* Handle a "nocommon" attribute; arguments as in
3886 struct attribute_spec.handler. */
3889 handle_nocommon_attribute (tree *node, tree name,
3890 tree args ATTRIBUTE_UNUSED,
3891 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
3893 if (TREE_CODE (*node) == VAR_DECL)
3894 DECL_COMMON (*node) = 0;
3897 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3898 *no_add_attrs = true;
3904 /* Handle a "common" attribute; arguments as in
3905 struct attribute_spec.handler. */
3908 handle_common_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
3909 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
3911 if (TREE_CODE (*node) == VAR_DECL)
3912 DECL_COMMON (*node) = 1;
3915 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3916 *no_add_attrs = true;
3922 /* Handle a "noreturn" attribute; arguments as in
3923 struct attribute_spec.handler. */
3926 handle_noreturn_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
3927 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
3929 tree type = TREE_TYPE (*node);
3931 /* See FIXME comment in c_common_attribute_table. */
3932 if (TREE_CODE (*node) == FUNCTION_DECL)
3933 TREE_THIS_VOLATILE (*node) = 1;
3934 else if (TREE_CODE (type) == POINTER_TYPE
3935 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
3937 = build_pointer_type
3938 (build_type_variant (TREE_TYPE (type),
3939 TYPE_READONLY (TREE_TYPE (type)), 1));
3942 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3943 *no_add_attrs = true;
3949 /* Handle a "noinline" attribute; arguments as in
3950 struct attribute_spec.handler. */
3953 handle_noinline_attribute (tree *node, tree name,
3954 tree args ATTRIBUTE_UNUSED,
3955 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
3957 if (TREE_CODE (*node) == FUNCTION_DECL)
3958 DECL_UNINLINABLE (*node) = 1;
3961 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3962 *no_add_attrs = true;
3968 /* Handle a "always_inline" attribute; arguments as in
3969 struct attribute_spec.handler. */
3972 handle_always_inline_attribute (tree *node, tree name,
3973 tree args ATTRIBUTE_UNUSED,
3974 int flags ATTRIBUTE_UNUSED,
3977 if (TREE_CODE (*node) == FUNCTION_DECL)
3979 /* Do nothing else, just set the attribute. We'll get at
3980 it later with lookup_attribute. */
3984 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3985 *no_add_attrs = true;
3991 /* Handle a "used" attribute; arguments as in
3992 struct attribute_spec.handler. */
3995 handle_used_attribute (tree *pnode, tree name, tree args ATTRIBUTE_UNUSED,
3996 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4000 if (TREE_CODE (node) == FUNCTION_DECL
4001 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4003 TREE_USED (node) = 1;
4007 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4008 *no_add_attrs = true;
4014 /* Handle a "unused" attribute; arguments as in
4015 struct attribute_spec.handler. */
4018 handle_unused_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4019 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4025 if (TREE_CODE (decl) == PARM_DECL
4026 || TREE_CODE (decl) == VAR_DECL
4027 || TREE_CODE (decl) == FUNCTION_DECL
4028 || TREE_CODE (decl) == LABEL_DECL
4029 || TREE_CODE (decl) == TYPE_DECL)
4030 TREE_USED (decl) = 1;
4033 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4034 *no_add_attrs = true;
4039 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4040 *node = build_type_copy (*node);
4041 TREE_USED (*node) = 1;
4047 /* Handle a "const" attribute; arguments as in
4048 struct attribute_spec.handler. */
4051 handle_const_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4052 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4054 tree type = TREE_TYPE (*node);
4056 /* See FIXME comment on noreturn in c_common_attribute_table. */
4057 if (TREE_CODE (*node) == FUNCTION_DECL)
4058 TREE_READONLY (*node) = 1;
4059 else if (TREE_CODE (type) == POINTER_TYPE
4060 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4062 = build_pointer_type
4063 (build_type_variant (TREE_TYPE (type), 1,
4064 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4067 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4068 *no_add_attrs = true;
4074 /* Handle a "transparent_union" attribute; arguments as in
4075 struct attribute_spec.handler. */
4078 handle_transparent_union_attribute (tree *node, tree name,
4079 tree args ATTRIBUTE_UNUSED, int flags,
4082 tree decl = NULL_TREE;
4089 type = &TREE_TYPE (decl);
4090 is_type = TREE_CODE (*node) == TYPE_DECL;
4092 else if (TYPE_P (*node))
4093 type = node, is_type = 1;
4096 && TREE_CODE (*type) == UNION_TYPE
4098 || (TYPE_FIELDS (*type) != 0
4099 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4101 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4102 *type = build_type_copy (*type);
4103 TYPE_TRANSPARENT_UNION (*type) = 1;
4105 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4106 && TREE_CODE (*type) == UNION_TYPE
4107 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4108 DECL_TRANSPARENT_UNION (decl) = 1;
4111 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4112 *no_add_attrs = true;
4118 /* Handle a "constructor" attribute; arguments as in
4119 struct attribute_spec.handler. */
4122 handle_constructor_attribute (tree *node, tree name,
4123 tree args ATTRIBUTE_UNUSED,
4124 int flags ATTRIBUTE_UNUSED,
4128 tree type = TREE_TYPE (decl);
4130 if (TREE_CODE (decl) == FUNCTION_DECL
4131 && TREE_CODE (type) == FUNCTION_TYPE
4132 && decl_function_context (decl) == 0)
4134 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4135 TREE_USED (decl) = 1;
4139 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4140 *no_add_attrs = true;
4146 /* Handle a "destructor" attribute; arguments as in
4147 struct attribute_spec.handler. */
4150 handle_destructor_attribute (tree *node, tree name,
4151 tree args ATTRIBUTE_UNUSED,
4152 int flags ATTRIBUTE_UNUSED,
4156 tree type = TREE_TYPE (decl);
4158 if (TREE_CODE (decl) == FUNCTION_DECL
4159 && TREE_CODE (type) == FUNCTION_TYPE
4160 && decl_function_context (decl) == 0)
4162 DECL_STATIC_DESTRUCTOR (decl) = 1;
4163 TREE_USED (decl) = 1;
4167 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4168 *no_add_attrs = true;
4174 /* Handle a "mode" attribute; arguments as in
4175 struct attribute_spec.handler. */
4178 handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4179 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4183 *no_add_attrs = true;
4185 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4186 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4190 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4191 int len = strlen (p);
4192 enum machine_mode mode = VOIDmode;
4196 if (len > 4 && p[0] == '_' && p[1] == '_'
4197 && p[len - 1] == '_' && p[len - 2] == '_')
4199 char *newp = alloca (len - 1);
4201 strcpy (newp, &p[2]);
4202 newp[len - 4] = '\0';
4206 /* Change this type to have a type with the specified mode.
4207 First check for the special modes. */
4208 if (! strcmp (p, "byte"))
4210 else if (!strcmp (p, "word"))
4212 else if (! strcmp (p, "pointer"))
4215 for (j = 0; j < NUM_MACHINE_MODES; j++)
4216 if (!strcmp (p, GET_MODE_NAME (j)))
4217 mode = (enum machine_mode) j;
4219 if (mode == VOIDmode)
4221 error ("unknown machine mode `%s'", p);
4225 if (VECTOR_MODE_P (mode))
4227 warning ("specifying vector types with __attribute__ ((mode)) "
4229 warning ("use __attribute__ ((vector_size)) instead");
4232 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4233 if (typefm == NULL_TREE)
4234 error ("no data type for mode `%s'", p);
4236 else if ((TREE_CODE (type) == POINTER_TYPE
4237 || TREE_CODE (type) == REFERENCE_TYPE)
4238 && !targetm.valid_pointer_mode (mode))
4239 error ("invalid pointer mode `%s'", p);
4242 /* If this is a vector, make sure we either have hardware
4243 support, or we can emulate it. */
4244 if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
4246 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
4250 if (TREE_CODE (type) == POINTER_TYPE)
4252 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
4256 else if (TREE_CODE (type) == REFERENCE_TYPE)
4258 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
4264 /* No need to layout the type here. The caller should do this. */
4271 /* Handle a "section" attribute; arguments as in
4272 struct attribute_spec.handler. */
4275 handle_section_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4276 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4280 if (targetm.have_named_sections)
4282 if ((TREE_CODE (decl) == FUNCTION_DECL
4283 || TREE_CODE (decl) == VAR_DECL)
4284 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4286 if (TREE_CODE (decl) == VAR_DECL
4287 && current_function_decl != NULL_TREE
4288 && ! TREE_STATIC (decl))
4290 error ("%Jsection attribute cannot be specified for "
4291 "local variables", decl);
4292 *no_add_attrs = true;
4295 /* The decl may have already been given a section attribute
4296 from a previous declaration. Ensure they match. */
4297 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4298 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4299 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4301 error ("%Jsection of '%D' conflicts with previous declaration",
4303 *no_add_attrs = true;
4306 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4310 error ("%Jsection attribute not allowed for '%D'", *node, *node);
4311 *no_add_attrs = true;
4316 error ("%Jsection attributes are not supported for this target", *node);
4317 *no_add_attrs = true;
4323 /* Handle a "aligned" attribute; arguments as in
4324 struct attribute_spec.handler. */
4327 handle_aligned_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4328 int flags, bool *no_add_attrs)
4330 tree decl = NULL_TREE;
4333 tree align_expr = (args ? TREE_VALUE (args)
4334 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4340 type = &TREE_TYPE (decl);
4341 is_type = TREE_CODE (*node) == TYPE_DECL;
4343 else if (TYPE_P (*node))
4344 type = node, is_type = 1;
4346 /* Strip any NOPs of any kind. */
4347 while (TREE_CODE (align_expr) == NOP_EXPR
4348 || TREE_CODE (align_expr) == CONVERT_EXPR
4349 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4350 align_expr = TREE_OPERAND (align_expr, 0);
4352 if (TREE_CODE (align_expr) != INTEGER_CST)
4354 error ("requested alignment is not a constant");
4355 *no_add_attrs = true;
4357 else if ((i = tree_log2 (align_expr)) == -1)
4359 error ("requested alignment is not a power of 2");
4360 *no_add_attrs = true;
4362 else if (i > HOST_BITS_PER_INT - 2)
4364 error ("requested alignment is too large");
4365 *no_add_attrs = true;
4369 /* If we have a TYPE_DECL, then copy the type, so that we
4370 don't accidentally modify a builtin type. See pushdecl. */
4371 if (decl && TREE_TYPE (decl) != error_mark_node
4372 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4374 tree tt = TREE_TYPE (decl);
4375 *type = build_type_copy (*type);
4376 DECL_ORIGINAL_TYPE (decl) = tt;
4377 TYPE_NAME (*type) = decl;
4378 TREE_USED (*type) = TREE_USED (decl);
4379 TREE_TYPE (decl) = *type;
4381 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4382 *type = build_type_copy (*type);
4384 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4385 TYPE_USER_ALIGN (*type) = 1;
4387 else if (TREE_CODE (decl) != VAR_DECL
4388 && TREE_CODE (decl) != FIELD_DECL)
4390 error ("%Jalignment may not be specified for '%D'", decl, decl);
4391 *no_add_attrs = true;
4395 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4396 DECL_USER_ALIGN (decl) = 1;
4402 /* Handle a "weak" attribute; arguments as in
4403 struct attribute_spec.handler. */
4406 handle_weak_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
4407 tree args ATTRIBUTE_UNUSED,
4408 int flags ATTRIBUTE_UNUSED,
4409 bool *no_add_attrs ATTRIBUTE_UNUSED)
4411 declare_weak (*node);
4416 /* Handle an "alias" attribute; arguments as in
4417 struct attribute_spec.handler. */
4420 handle_alias_attribute (tree *node, tree name, tree args,
4421 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4425 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4426 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
4428 error ("%J'%D' defined both normally and as an alias", decl, decl);
4429 *no_add_attrs = true;
4432 /* Note that the very first time we process a nested declaration,
4433 decl_function_context will not be set. Indeed, *would* never
4434 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4435 we do below. After such frobbery, pushdecl would set the context.
4436 In any case, this is never what we want. */
4437 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4441 id = TREE_VALUE (args);
4442 if (TREE_CODE (id) != STRING_CST)
4444 error ("alias arg not a string");
4445 *no_add_attrs = true;
4448 id = get_identifier (TREE_STRING_POINTER (id));
4449 /* This counts as a use of the object pointed to. */
4452 if (TREE_CODE (decl) == FUNCTION_DECL)
4453 DECL_INITIAL (decl) = error_mark_node;
4456 DECL_EXTERNAL (decl) = 0;
4457 TREE_STATIC (decl) = 1;
4462 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4463 *no_add_attrs = true;
4469 /* Handle an "visibility" attribute; arguments as in
4470 struct attribute_spec.handler. */
4473 handle_visibility_attribute (tree *node, tree name, tree args,
4474 int flags ATTRIBUTE_UNUSED,
4478 tree id = TREE_VALUE (args);
4480 *no_add_attrs = true;
4482 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
4484 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4488 if (TREE_CODE (id) != STRING_CST)
4490 error ("visibility arg not a string");
4494 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4495 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4496 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4497 DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4498 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4499 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4500 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4501 DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4503 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4508 /* Handle an "tls_model" attribute; arguments as in
4509 struct attribute_spec.handler. */
4512 handle_tls_model_attribute (tree *node, tree name, tree args,
4513 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4517 if (! DECL_THREAD_LOCAL (decl))
4519 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4520 *no_add_attrs = true;
4526 id = TREE_VALUE (args);
4527 if (TREE_CODE (id) != STRING_CST)
4529 error ("tls_model arg not a string");
4530 *no_add_attrs = true;
4533 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
4534 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
4535 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
4536 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4538 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4539 *no_add_attrs = true;
4547 /* Handle a "no_instrument_function" attribute; arguments as in
4548 struct attribute_spec.handler. */
4551 handle_no_instrument_function_attribute (tree *node, tree name,
4552 tree args ATTRIBUTE_UNUSED,
4553 int flags ATTRIBUTE_UNUSED,
4558 if (TREE_CODE (decl) != FUNCTION_DECL)
4560 error ("%J'%E' attribute applies only to functions", decl, name);
4561 *no_add_attrs = true;
4563 else if (DECL_INITIAL (decl))
4565 error ("%Jcan't set '%E' attribute after definition", decl, name);
4566 *no_add_attrs = true;
4569 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
4574 /* Handle a "malloc" attribute; arguments as in
4575 struct attribute_spec.handler. */
4578 handle_malloc_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4579 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4581 if (TREE_CODE (*node) == FUNCTION_DECL)
4582 DECL_IS_MALLOC (*node) = 1;
4583 /* ??? TODO: Support types. */
4586 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4587 *no_add_attrs = true;
4593 /* Handle a "no_limit_stack" attribute; arguments as in
4594 struct attribute_spec.handler. */
4597 handle_no_limit_stack_attribute (tree *node, tree name,
4598 tree args ATTRIBUTE_UNUSED,
4599 int flags ATTRIBUTE_UNUSED,
4604 if (TREE_CODE (decl) != FUNCTION_DECL)
4606 error ("%J'%E' attribute applies only to functions", decl, name);
4607 *no_add_attrs = true;
4609 else if (DECL_INITIAL (decl))
4611 error ("%Jcan't set '%E' attribute after definition", decl, name);
4612 *no_add_attrs = true;
4615 DECL_NO_LIMIT_STACK (decl) = 1;
4620 /* Handle a "pure" attribute; arguments as in
4621 struct attribute_spec.handler. */
4624 handle_pure_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4625 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4627 if (TREE_CODE (*node) == FUNCTION_DECL)
4628 DECL_IS_PURE (*node) = 1;
4629 /* ??? TODO: Support types. */
4632 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4633 *no_add_attrs = true;
4639 /* Handle a "deprecated" attribute; arguments as in
4640 struct attribute_spec.handler. */
4643 handle_deprecated_attribute (tree *node, tree name,
4644 tree args ATTRIBUTE_UNUSED, int flags,
4647 tree type = NULL_TREE;
4649 const char *what = NULL;
4654 type = TREE_TYPE (decl);
4656 if (TREE_CODE (decl) == TYPE_DECL
4657 || TREE_CODE (decl) == PARM_DECL
4658 || TREE_CODE (decl) == VAR_DECL
4659 || TREE_CODE (decl) == FUNCTION_DECL
4660 || TREE_CODE (decl) == FIELD_DECL)
4661 TREE_DEPRECATED (decl) = 1;
4665 else if (TYPE_P (*node))
4667 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4668 *node = build_type_copy (*node);
4669 TREE_DEPRECATED (*node) = 1;
4677 *no_add_attrs = true;
4678 if (type && TYPE_NAME (type))
4680 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
4681 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
4682 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
4683 && DECL_NAME (TYPE_NAME (type)))
4684 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
4687 warning ("`%s' attribute ignored for `%s'",
4688 IDENTIFIER_POINTER (name), what);
4690 warning ("`%s' attribute ignored",
4691 IDENTIFIER_POINTER (name));
4697 /* Handle a "vector_size" attribute; arguments as in
4698 struct attribute_spec.handler. */
4701 handle_vector_size_attribute (tree *node, tree name, tree args,
4702 int flags ATTRIBUTE_UNUSED,
4705 unsigned HOST_WIDE_INT vecsize, nunits;
4706 enum machine_mode mode, orig_mode, new_mode;
4707 tree type = *node, new_type, size;
4709 *no_add_attrs = true;
4711 /* Stripping NON_LVALUE_EXPR allows declarations such as
4712 typedef short v4si __attribute__((vector_size (4 * sizeof(short)))). */
4713 size = TREE_VALUE (args);
4714 if (TREE_CODE (size) == NON_LVALUE_EXPR)
4715 size = TREE_OPERAND (size, 0);
4717 if (! host_integerp (size, 1))
4719 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4723 /* Get the vector size (in bytes). */
4724 vecsize = tree_low_cst (size, 1);
4726 /* We need to provide for vector pointers, vector arrays, and
4727 functions returning vectors. For example:
4729 __attribute__((vector_size(16))) short *foo;
4731 In this case, the mode is SI, but the type being modified is
4732 HI, so we need to look further. */
4734 while (POINTER_TYPE_P (type)
4735 || TREE_CODE (type) == FUNCTION_TYPE
4736 || TREE_CODE (type) == METHOD_TYPE
4737 || TREE_CODE (type) == ARRAY_TYPE)
4738 type = TREE_TYPE (type);
4740 /* Get the mode of the type being modified. */
4741 orig_mode = TYPE_MODE (type);
4743 if (TREE_CODE (type) == RECORD_TYPE
4744 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
4745 && GET_MODE_CLASS (orig_mode) != MODE_INT)
4746 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
4748 error ("invalid vector type for attribute `%s'",
4749 IDENTIFIER_POINTER (name));
4753 /* Calculate how many units fit in the vector. */
4754 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
4756 /* Find a suitably sized vector. */
4757 new_mode = VOIDmode;
4758 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
4760 : MODE_VECTOR_FLOAT);
4762 mode = GET_MODE_WIDER_MODE (mode))
4763 if (vecsize == GET_MODE_SIZE (mode)
4764 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
4770 if (new_mode == VOIDmode)
4772 error ("no vector mode with the size and type specified could be found");
4776 new_type = build_vector_type_for_mode (type, new_mode);
4778 /* Build back pointers if needed. */
4779 *node = reconstruct_complex_type (*node, new_type);
4784 /* Handle the "nonnull" attribute. */
4786 handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
4787 tree args, int flags ATTRIBUTE_UNUSED,
4791 unsigned HOST_WIDE_INT attr_arg_num;
4793 /* If no arguments are specified, all pointer arguments should be
4794 non-null. Verify a full prototype is given so that the arguments
4795 will have the correct types when we actually check them later. */
4798 if (! TYPE_ARG_TYPES (type))
4800 error ("nonnull attribute without arguments on a non-prototype");
4801 *no_add_attrs = true;
4806 /* Argument list specified. Verify that each argument number references
4807 a pointer argument. */
4808 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
4811 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
4813 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
4815 error ("nonnull argument has invalid operand number (arg %lu)",
4816 (unsigned long) attr_arg_num);
4817 *no_add_attrs = true;
4821 argument = TYPE_ARG_TYPES (type);
4824 for (ck_num = 1; ; ck_num++)
4826 if (! argument || ck_num == arg_num)
4828 argument = TREE_CHAIN (argument);
4832 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
4834 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
4835 (unsigned long) attr_arg_num, (unsigned long) arg_num);
4836 *no_add_attrs = true;
4840 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
4842 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
4843 (unsigned long) attr_arg_num, (unsigned long) arg_num);
4844 *no_add_attrs = true;
4853 /* Check the argument list of a function call for null in argument slots
4854 that are marked as requiring a non-null pointer argument. */
4857 check_function_nonnull (tree attrs, tree params)
4859 tree a, args, param;
4862 for (a = attrs; a; a = TREE_CHAIN (a))
4864 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
4866 args = TREE_VALUE (a);
4868 /* Walk the argument list. If we encounter an argument number we
4869 should check for non-null, do it. If the attribute has no args,
4870 then every pointer argument is checked (in which case the check
4871 for pointer type is done in check_nonnull_arg). */
4872 for (param = params, param_num = 1; ;
4873 param_num++, param = TREE_CHAIN (param))
4877 if (! args || nonnull_check_p (args, param_num))
4878 check_function_arguments_recurse (check_nonnull_arg, NULL,
4886 /* Helper for check_function_nonnull; given a list of operands which
4887 must be non-null in ARGS, determine if operand PARAM_NUM should be
4891 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
4893 unsigned HOST_WIDE_INT arg_num = 0;
4895 for (; args; args = TREE_CHAIN (args))
4897 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
4900 if (arg_num == param_num)
4906 /* Check that the function argument PARAM (which is operand number
4907 PARAM_NUM) is non-null. This is called by check_function_nonnull
4908 via check_function_arguments_recurse. */
4911 check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED, tree param,
4912 unsigned HOST_WIDE_INT param_num)
4914 /* Just skip checking the argument if it's not a pointer. This can
4915 happen if the "nonnull" attribute was given without an operand
4916 list (which means to check every pointer argument). */
4918 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
4921 if (integer_zerop (param))
4922 warning ("null argument where non-null required (arg %lu)",
4923 (unsigned long) param_num);
4926 /* Helper for nonnull attribute handling; fetch the operand number
4927 from the attribute argument list. */
4930 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
4932 /* Strip any conversions from the arg number and verify they
4934 while (TREE_CODE (arg_num_expr) == NOP_EXPR
4935 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
4936 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
4937 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
4939 if (TREE_CODE (arg_num_expr) != INTEGER_CST
4940 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
4943 *valp = TREE_INT_CST_LOW (arg_num_expr);
4947 /* Handle a "nothrow" attribute; arguments as in
4948 struct attribute_spec.handler. */
4951 handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4952 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4954 if (TREE_CODE (*node) == FUNCTION_DECL)
4955 TREE_NOTHROW (*node) = 1;
4956 /* ??? TODO: Support types. */
4959 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4960 *no_add_attrs = true;
4966 /* Handle a "cleanup" attribute; arguments as in
4967 struct attribute_spec.handler. */
4970 handle_cleanup_attribute (tree *node, tree name, tree args,
4971 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4974 tree cleanup_id, cleanup_decl;
4976 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
4977 for global destructors in C++. This requires infrastructure that
4978 we don't have generically at the moment. It's also not a feature
4979 we'd be missing too much, since we do have attribute constructor. */
4980 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4982 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4983 *no_add_attrs = true;
4987 /* Verify that the argument is a function in scope. */
4988 /* ??? We could support pointers to functions here as well, if
4989 that was considered desirable. */
4990 cleanup_id = TREE_VALUE (args);
4991 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
4993 error ("cleanup arg not an identifier");
4994 *no_add_attrs = true;
4997 cleanup_decl = lookup_name (cleanup_id);
4998 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5000 error ("cleanup arg not a function");
5001 *no_add_attrs = true;
5005 /* That the function has proper type is checked with the
5006 eventual call to build_function_call. */
5011 /* Handle a "warn_unused_result" attribute. No special handling. */
5014 handle_warn_unused_result_attribute (tree *node, tree name,
5015 tree args ATTRIBUTE_UNUSED,
5016 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5018 /* Ignore the attribute for functions not returning any value. */
5019 if (VOID_TYPE_P (TREE_TYPE (*node)))
5021 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5022 *no_add_attrs = true;
5028 /* Check for valid arguments being passed to a function. */
5030 check_function_arguments (tree attrs, tree params)
5032 /* Check for null being passed in a pointer argument that must be
5033 non-null. We also need to do this if format checking is enabled. */
5036 check_function_nonnull (attrs, params);
5038 /* Check for errors in format strings. */
5041 check_function_format (NULL, attrs, params);
5044 /* Generic argument checking recursion routine. PARAM is the argument to
5045 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5046 once the argument is resolved. CTX is context for the callback. */
5048 check_function_arguments_recurse (void (*callback)
5049 (void *, tree, unsigned HOST_WIDE_INT),
5050 void *ctx, tree param,
5051 unsigned HOST_WIDE_INT param_num)
5053 if (TREE_CODE (param) == NOP_EXPR)
5055 /* Strip coercion. */
5056 check_function_arguments_recurse (callback, ctx,
5057 TREE_OPERAND (param, 0), param_num);
5061 if (TREE_CODE (param) == CALL_EXPR)
5063 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5065 bool found_format_arg = false;
5067 /* See if this is a call to a known internationalization function
5068 that modifies a format arg. Such a function may have multiple
5069 format_arg attributes (for example, ngettext). */
5071 for (attrs = TYPE_ATTRIBUTES (type);
5073 attrs = TREE_CHAIN (attrs))
5074 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5077 tree format_num_expr;
5081 /* Extract the argument number, which was previously checked
5083 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5084 while (TREE_CODE (format_num_expr) == NOP_EXPR
5085 || TREE_CODE (format_num_expr) == CONVERT_EXPR
5086 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5087 format_num_expr = TREE_OPERAND (format_num_expr, 0);
5089 if (TREE_CODE (format_num_expr) != INTEGER_CST
5090 || TREE_INT_CST_HIGH (format_num_expr) != 0)
5093 format_num = TREE_INT_CST_LOW (format_num_expr);
5095 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5097 inner_args = TREE_CHAIN (inner_args), i++)
5098 if (i == format_num)
5100 check_function_arguments_recurse (callback, ctx,
5101 TREE_VALUE (inner_args),
5103 found_format_arg = true;
5108 /* If we found a format_arg attribute and did a recursive check,
5109 we are done with checking this argument. Otherwise, we continue
5110 and this will be considered a non-literal. */
5111 if (found_format_arg)
5115 if (TREE_CODE (param) == COND_EXPR)
5117 /* Check both halves of the conditional expression. */
5118 check_function_arguments_recurse (callback, ctx,
5119 TREE_OPERAND (param, 1), param_num);
5120 check_function_arguments_recurse (callback, ctx,
5121 TREE_OPERAND (param, 2), param_num);
5125 (*callback) (ctx, param, param_num);
5128 /* C implementation of lang_hooks.tree_inlining.walk_subtrees. Tracks the
5129 locus from EXPR_LOCUS and handles DECL_STMT specially. */
5132 c_walk_subtrees (tree *tp, int *walk_subtrees_p ATTRIBUTE_UNUSED,
5133 walk_tree_fn func, void *data, void *htab)
5135 enum tree_code code = TREE_CODE (*tp);
5136 location_t save_locus;
5139 #define WALK_SUBTREE(NODE) \
5142 result = walk_tree (&(NODE), func, data, htab); \
5143 if (result) goto out; \
5147 if (code != DECL_STMT)
5150 /* Set input_location here so we get the right instantiation context
5151 if we call instantiate_decl from inlinable_function_p. */
5152 save_locus = input_location;
5153 if (EXPR_LOCUS (*tp))
5154 input_location = *EXPR_LOCUS (*tp);
5156 /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
5157 into declarations that are just mentioned, rather than
5158 declared; they don't really belong to this part of the tree.
5159 And, we can see cycles: the initializer for a declaration can
5160 refer to the declaration itself. */
5161 WALK_SUBTREE (DECL_INITIAL (DECL_STMT_DECL (*tp)));
5162 WALK_SUBTREE (DECL_SIZE (DECL_STMT_DECL (*tp)));
5163 WALK_SUBTREE (DECL_SIZE_UNIT (DECL_STMT_DECL (*tp)));
5164 WALK_SUBTREE (TREE_CHAIN (*tp));
5165 *walk_subtrees_p = 0;
5167 /* We didn't find what we were looking for. */
5169 input_location = save_locus;
5175 /* Function to help qsort sort FIELD_DECLs by name order. */
5178 field_decl_cmp (const void *x_p, const void *y_p)
5180 const tree *const x = x_p;
5181 const tree *const y = y_p;
5182 if (DECL_NAME (*x) == DECL_NAME (*y))
5183 /* A nontype is "greater" than a type. */
5184 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5185 if (DECL_NAME (*x) == NULL_TREE)
5187 if (DECL_NAME (*y) == NULL_TREE)
5189 if (DECL_NAME (*x) < DECL_NAME (*y))
5195 gt_pointer_operator new_value;
5199 /* This routine compares two fields like field_decl_cmp but using the
5200 pointer operator in resort_data. */
5203 resort_field_decl_cmp (const void *x_p, const void *y_p)
5205 const tree *const x = x_p;
5206 const tree *const y = y_p;
5208 if (DECL_NAME (*x) == DECL_NAME (*y))
5209 /* A nontype is "greater" than a type. */
5210 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5211 if (DECL_NAME (*x) == NULL_TREE)
5213 if (DECL_NAME (*y) == NULL_TREE)
5216 tree d1 = DECL_NAME (*x);
5217 tree d2 = DECL_NAME (*y);
5218 resort_data.new_value (&d1, resort_data.cookie);
5219 resort_data.new_value (&d2, resort_data.cookie);
5226 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5229 resort_sorted_fields (void *obj,
5230 void *orig_obj ATTRIBUTE_UNUSED ,
5231 gt_pointer_operator new_value,
5234 struct sorted_fields_type *sf = obj;
5235 resort_data.new_value = new_value;
5236 resort_data.cookie = cookie;
5237 qsort (&sf->elts[0], sf->len, sizeof (tree),
5238 resort_field_decl_cmp);
5241 /* Issue the error given by MSGID, indicating that it occurred before
5242 TOKEN, which had the associated VALUE. */
5245 c_parse_error (const char *msgid, enum cpp_ttype token, tree value)
5247 const char *string = _(msgid);
5249 if (token == CPP_EOF)
5250 error ("%s at end of input", string);
5251 else if (token == CPP_CHAR || token == CPP_WCHAR)
5253 unsigned int val = TREE_INT_CST_LOW (value);
5254 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5255 if (val <= UCHAR_MAX && ISGRAPH (val))
5256 error ("%s before %s'%c'", string, ell, val);
5258 error ("%s before %s'\\x%x'", string, ell, val);
5260 else if (token == CPP_STRING
5261 || token == CPP_WSTRING)
5262 error ("%s before string constant", string);
5263 else if (token == CPP_NUMBER)
5264 error ("%s before numeric constant", string);
5265 else if (token == CPP_NAME)
5266 error ("%s before \"%s\"", string, IDENTIFIER_POINTER (value));
5267 else if (token < N_TTYPES)
5268 error ("%s before '%s' token", string, cpp_type2name (token));
5270 error ("%s", string);
5273 /* Walk a gimplified function and warn for functions whose return value is
5274 ignored and attribute((warn_unused_result)) is set. This is done before
5275 inlining, so we don't have to worry about that. */
5278 c_warn_unused_result (tree *top_p)
5281 tree_stmt_iterator i;
5284 switch (TREE_CODE (t))
5286 case STATEMENT_LIST:
5287 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
5288 c_warn_unused_result (tsi_stmt_ptr (i));
5292 c_warn_unused_result (&COND_EXPR_THEN (t));
5293 c_warn_unused_result (&COND_EXPR_ELSE (t));
5296 c_warn_unused_result (&BIND_EXPR_BODY (t));
5298 case TRY_FINALLY_EXPR:
5299 case TRY_CATCH_EXPR:
5300 c_warn_unused_result (&TREE_OPERAND (t, 0));
5301 c_warn_unused_result (&TREE_OPERAND (t, 1));
5304 c_warn_unused_result (&CATCH_BODY (t));
5306 case EH_FILTER_EXPR:
5307 c_warn_unused_result (&EH_FILTER_FAILURE (t));
5311 /* This is a naked call, as opposed to a CALL_EXPR nested inside
5312 a MODIFY_EXPR. All calls whose value is ignored should be
5313 represented like this. Look for the attribute. */
5314 fdecl = get_callee_fndecl (t);
5316 ftype = TREE_TYPE (fdecl);
5319 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
5320 /* Look past pointer-to-function to the function type itself. */
5321 ftype = TREE_TYPE (ftype);
5324 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
5327 warning ("%Hignoring return value of `%D', "
5328 "declared with attribute warn_unused_result",
5329 EXPR_LOCUS (t), fdecl);
5331 warning ("%Hignoring return value of function "
5332 "declared with attribute warn_unused_result",
5338 /* Not a container, not a call, or a call whose value is used. */
5343 #include "gt-c-common.h"